What I think each part of a piece of code does

Unreal Courses Talk
,
#21 
#include <iostream>

int main()      
{       
    std::cout << "You are a legendary thief attempting to breach Balothil's Tower, the Master Sorcerer...";
    std::cout << std::endl;
    std::cout << "Balothil uses secret codes that you must enter to breach the tower...";
    
    const int a = 4;
    const int b = 2;
    const int c = 3;

    const int sum = a + b + c;
    const int prod = a * b * c;

    std::cout << std::endl;
    std::cout << sum << std::endl;
    std::cout << prod;

    return 0;       
}

The Preprocessor Directive portion is importing code
The Main function houses all of the code that is getting executed
The Expression Statements are what gets outputted to the terminal so the user can see what is happening.
The Declaration Statements are values assigned to variables used later.
The Return Statement is the end result of the code and in this case it’s “0” meaning no errors and the program can exit.

#22

Preprocessor directive: Contains all of the code to be used within the program. So sort of like a paint palette or a box of Lego bricks - ‘building blocks’. It contains pre-requisite functions that you can choose from in your program - so code like ‘int’?
Main function: The program you are running. So the resultant portrait/lego house derived from the preprocessor kit.
Expression statements: Statements that result in some change in the user/players interface but do not modify the main function.
Declaration statements: Statements that are used by and modify the main function but are not visible to the user.
Return statement: Ends the program and returns the user from whence they came.

#23

Preprocessor Directive: Gathers code from a library to be used for specific commands
Main Function: Creates the definition of what the main function does when called upon
Expression Statements: Outputs something
Declaration Statements: Declares Variables
Return Statement: Ends the function

#24

Preprocessor Directive: it’s a library that contains some instruction or commands to use in the code.

Main Function: This function is the most important and contains the instructions neccesaries to run the program

Expression statements: There are all the statements to interact with the user, show messages and get information.

Declaration Statements: In this section we declare, assign and make operation, the user can’t see this part

Return Statement: This ends the function

#25

Preprocessor directive is basically used for compiling the program easily

Main Function include that part of the code which the compiler has to run and give the output accordingly

Expression Statement is basically an expression which ends with a semicolon

Declaration Statement is declaring something variables, functions and etc

Return Statement is terminates the program and return the control to the function

#27

What I think each part of the code does:
Preprocessor Directive: codes and files that loaded before coding starts
Main Function: Everything located in the main function is the code that we want to be ran
Expression statements: Code that we want printed into the console
Declaration Statements: Assign variables a value and can do order or operations in our code

#28

The main function = the main body of code, where the main part of the code will be functioning
Expression statement = the outputs
Declaration statements = the statements that declare things like variables

Return = What the function is returning

#29

I think,
the preprocessor directive informs the compiler to include code from another source in our program.

the main function is the first function that the compiler accesses and the essential functions of the programs first steps. In triple x it contains all of our code thus far outside of our preprocessor directives

expression statements are any expression, basic lines of code, in proper syntax that is followed by a semi colon;

declaration statement, is the first time a variable is declared. in triple x it is used to create integer variables that the program will use for the math game.

return statement is the output of a function, in main it returns 0 so that the program will complete and exit without an error.

#30

I think that the Processor Directive: is where we put all of the files we want to be compiled before the the rest of our code.
Main function: is where we put all of our code to start with
Expression statements are what we want to be printed in the terminal
Declaration statements are where we declare our variables
Return statement is used to stop the code

So what do you guys think

#31

Processor Directive: Include a library of predefined code and tell the compiler to process prior to running any code below it.

Main Function: The main function of your code. Other functions may be run, but will eventually always revert back to the main function state.

Expression statements: Used to print to the console and to end lines - expressing visibly into the interface.

Deceleration Statements: Used to declare values, to state something in code that can be referenced upon later.

Return Statement: Ends / exits the current function. In the case of the main function, exits the program.

Hopefully these are kind of right!

#32

Preprocessor Directive: The #include statement includes the iostream library to this particular .cpp file that we are using. It contains information required for inputs and outputs(std::cout).

main() function: No C++ program can be run without a main() function. It is inside this main() function where previously defined methods/functions can be used to create a working program.

Expression statements: Expression statements write output(and maybe receive input too?) and also can be assignments to previously declared variables.

Declaration Statements: Statements where variables are declared(initialized?).

Return Statements: Statement where a value is returned from a function.

#33

Hi! This is my first post here, and I’ve been asked to explain the distinct parts of the code seen in section 2, lecture 22 of Learn C++ and Make Video Games

The first element of our source code is the preprocessor directive, distinguished by being before the main function and having a unique syntax #include “<“a library”>” - this code tells our compiler to include the library we referenced and is necessary so that other syntax is understood by the compiler.

Then our main function begins and all functions have 4 parts, they are: the return type in our case, it’s int (short for integer) followed by the function name (here, main) then the parameter list - the variables that we require in our function (they are optional in case of a main function) and they have to be written inside round parentheses “( )”.

After the parameter list, we have our function body represented by statements inside curly braces “{ }”. In our code so far we’ve used three types of statements, expression statements - these are basic commands for the computer to do something like “cout” (character output to the console); declaration statements which allocate some space in memory (size depends on the variable type) assign a name, chosen by us, to that particular space in memory (we have a few naming conventions, for example your variable name cannot begin with a number, spaces in the name are not allowed and variables cannot have the same name as other commands); and, finally, the return statement which returns a variable of the type we’ve used when declaring the function, afaik returning 0 in our main function used to be or still is (in case of a linux based os) a way for us to know that our code ran and ended successfully meaning that the compiler went through each line in order, found no issues with our syntax (no compile-time errors and for brevity no link-time errors). It’s possible to have our code return 0 and also have logic errors though so returning a 0 doesn’t mean our source code is bug free.

Thanks for reading my post and do know that any feedback is appreciated!

#34

What I think each part of the code does in my own words:

  • Preprocessor Directive: It includes a library from outside our code.
  • Main Function: This is the main function of our code, the core of the program from where we can call all others sub-functions.
  • Expression Statement: These are instructions on what our code has to do.
  • Declaration Statement: These are statements that declare variables, functions, arrays, pointers, and constants.
  • Return Statement: Since the main function is declared with an integer, and number must be returned, which can confirm that there are no syntax errors.

What do you guys think of my explanations? How accurate are they?

#35

This is what I have picked up, I’m not a complete programming beginner but with C++ I am so hopefully this makes sense.

int main() (Main Function)
int main() is the entry point of the program. Every C++ program requires int main()
Without a int main() function the program will not build.

return 0; (Return Statement)
return 0; is a return statement that is the exit code of your program.
Successful code returns a 0, while unsuccessful one returns a non-zero (1-255) value that usually can be interpreted as an error code.
The 0 exit code is a widely accepted convention for ‘execution was successful’.

Preprocessor Directive (i.e “#”) is an instruction to the compiler that it has to go through before it goes through the actual code you have written/built.

Example:
#include tells the compiler to include a library to go through before it goes through your own.

Expression: an expression is a combination of symbols that represents a value, i.e an expression is a statement that has both a value and a type. (this was not included in the task but I felt it was necessary)

Expression Statements: are assignments or function calls.

Declaration Statements: Code that declares something. A declaration statement usually defines a variable or it is “holding information” for some sort of value.

#36

the processor directive gives us access to the std namespace, out of which we use cout.
The expression statements output data to the console, using the cout mechanism,
The declarative statements define new variables, which are output in the expression statements.
The main() function is our program,
The return statement is the system code, with which the program has finished, 0 = OK, anything else = not OK

#37

The Preprocessor statement is a piece of code written by other people that we can “include” in our code.

The Main function just the function that runs form the start of the code.

The Expression statement is the expression that you make like input, text, line breaks, etc.

The Declaration statement tells the complier what to put like variables.

#38

What I think each part of the code does:
Preprocessor Directive: includes needed files into code such as iostream(input and output
functionality)
Main Function: Function that compiler knows to run
Expression Statement: Statements that work with data in some way
Declaration Statement: Statements that declare variables and other types of memory
Return statement: returns the int that is stated in the function declaration, so in this case it is
an int so 0 is returned to satisfy this.

#39

Preprocessor directive, this is a function that includes a library of the sort needed for our code to run
The main function: allows the code to run
expression statement: This is statements that end with a semicolon, they are often how the programmer interacts with end-user I guess
Declaration Statements is used to declare variables
Return statement: This returns the code back to the main function thereby completing it

#40

Preprocessor Directive: It takes data from libraries in VS Code into your code.
Main Function: It is the heart of your program, your program won’t run without it.
Expression Statements: The ones with the semicolon.
Declaration Statements: They declare variables and such in the code.
Return Statements: They Signify that the program has run successfully.

#41

Hi there!
Andres Ferdinandez here!
The parts of the code and its functions according to me are as follows:

Preprocessor Directive: It allows any pre-written code or libraries that one wants to recall and use in their program be applied.

Main Fuction: It is an organizing tool for the compiler to know what will be processed through.

Expression Statement: These are strings that will be processed through. In our case, it outputs information for our game so that the player can have their instructions.

Declaration Statement: They help form variables for the purpose of strings or equations or fuctions depending on their purpose in the code.

Return Statement:It provides an ending to the Main Fuction and output.

Thanks guys!

Privacy & Terms