Chilipedia - User contributions [en]

Constexpr

2018-11-12T11:06:11Z

Rudra:

<code>constexpr</code> is a keyword applied to variables and functions. It's basically the same as the <code>[[http://wiki.planetchili.net/index.php?title=Const const]]</code> keyword but enforces an additional rule that "The value of this const will be available at compile time"

== Difference between const & constexpr ==
=== Basics ===
In C++ there can be 2 types of constants:
<ol style="list-style-type: decimal;">
<li><p>Whose value is known at compile time.</p>
</li></ol>
<source>
const int x = 50;
const int z = x + 1;
</source>

During compile time, the compiler knows the value of x and z would be 50 and 51 respectively. And the values won’t change throughout the lifetime of the program. So it goes “I’ll just substitute all the references to x and z with 50 and 51, instead of looking up what the values of x and z every time during runtime”.

This allows 50 and 51 to be used as literals (hardcoded values) with all their advantages and at the same time not clutter our code with random numbers that are hard to interpret the meaning of.

<ol start="2" style="list-style-type: decimal;">
<li><p>Whose value is not known at compile time.</p>
</li></ol>
<source>const int y = GenRandomNumber();</source>
In this case the value of y would be impossible to determine at compile time as a we don’t know what random number would be generated at runtime.

NOTE: the variable is still a constant, once a random number is assigned to it the value cannot change.

When the compiler comes across scenario #1 it marks x an z as constant expressions i.e. their value can be evaluated at compile time and in scenario #2 marks y as being a constant but not a constant expression as it can only be evaluated during runtime.

This can be a bit confusing in certain contexts e.g.
<source>
int anArray[x]; // Compiles successfully
int anotherArray[y]; // Fails compilation
</source>
Certain operations require compile-time knowledge of a variable, in this case, anotherArray declaration would throw an error even though y is a const just like x. This is because the value of y cannot be computed until the function GenRandomNum() is run.

Due to this confusion, it is hard to evaluate what constants will be available during compile time, and which won’t like in our example above. As your code base gets bigger this can spiral out of control, as multiple people are working on the same code base.

This is where the keyword <code>constexpr</code> comes in as it tells the compiler that the value of this variable should be deduced at compile time to allow for scenarios such as the one above. If y was declared as <code> constexpr int y = GetRandomNumber()</code> the compiler would throw an error that the value cannot be evaluated at compile time. It clarifies the intended use of the variable.

<source>
constexpr int y = GetRandomNumber(); // error
constexpr int y = 69; // Compiles fine
</source>

== Advanced ==
=== Pointers ===
<code>constexpr</code> Pointers are implicitly const, i.e you cannot change where the pointer points to but you can change the data at the memory address.
<source>
static constexpr int x = 5
static constexpr int y = 10;
constexpr int* integer = &x; // Equivalent to 'int* const integer = &x' but evaluated at compile time

integer = &y // Error, cannot retarget the pointer
*integer = 15 // Valid, value of x is changed to 15
</source>

To ensure the pointer is evaluated at compile time, cannot be retargeted and is not able to change its target a <code>const</code> keyword can be added after <code>constexpr</code>
<source>
static constexpr int x = 5;
static constexpr int y = 10;
constexpr const int* integer = &x; // Equivalent to 'const int* const integer = &x' but guaranteed to be evaluated at compile time.

integer = &y; // Error, Cannot Retarget the pointer
*integer = 15; // Error, the value at the pointed address cannot be modified.
</source>

=== Functions ===
Functions can also be evaluated at compile time by using the keyword <code>constexpr</code> which means "should be usable in a constant expression when given constant expressions as arguments."
<source>
constexpr double square(double x) {return x * x;}
</source>

If the arguments to a function is a constexpr the function returns a constexpr.

To declare a function as a constexpr, the function cannot contain:

# ASM definition {<code>movl $7, %eax</code>}
# A <code>goto</code> statement
# A statement with a label other than case and default {<code>label: take that compiler</code>}
# A try-block {<code>try {std::cout << "My dick stinks" << std:endl; }</code>}
# Variable definition of non-literal type {<code>MyCustomClass anObject</code>}
# Static variable
# Uninitialized variable

Why do you care? Constexpr function are a good way to write cleaner code as compared to using macros everywhere, improve performance (but rarely used for this purpose)

=== Constexpr Classes ===

Simple user-defined classes can also be used as constant expressions.

To make a class a <code>constexpr</code> class it needs to have a <code>constexpr</code> constructor with an empty body and all member functions should be initialized by constant expressions.

Declaring a constructor as <code>constexpr</code> turns your class into "User Defined Literals" i.e. you class can now be used as a literal

== Planet Chili Tutorial Video ==
* [[Beginner C++ Game Programming Tutorial 9]]

== Other Tutorials ==

* https://hackernoon.com/a-tour-of-c-17-if-constexpr-3ea62f62ff65

* https://www.geeksforgeeks.org/understanding-constexper-specifier-in-c/

* https://en.cppreference.com/w/cpp/language/constexpr

== See Also ==
* [[Beginner_C++_Game_Programming_Series#Topics_Covered|List of Beginner C++ Topics]]

Constexpr

2018-09-02T04:03:27Z

Rudra: /* Basics */

Constexpr

2018-09-02T04:01:22Z

Rudra:

Constexpr

2018-09-02T03:40:39Z

Rudra: Created page with "<code>constexpr</code> is a keyword applied to variables and functions. It's basically the same as the <code>http://wiki.planetchili.net/index.php?title=Const const</code>..."

Arrays

2018-09-01T09:55:07Z

Rudra: Created page with "Arrays are a collection of elements usually of the same type grouped together and referenced using an index to a unique identifier. If you think of variables as boxes in whi..."

Arrays are a collection of elements usually of the same type grouped together and referenced using an index to a unique identifier.

If you think of variables as boxes in which you can keep stuff and label them <code>box0</code>, <code>box1</code> ... arrays can be thought of as a large box with compartments in it, where the box can be called <code>box</code> and each compartment is labeled <code>box[0]</code>, <code>box[1]</code>, <code>box[2]</code> and so on.

== Using Arrays ==
=== Syntax ===

<source>
// create a big box that stores integers with 10 compartments
int box[10];

// Now to put values in these compartments all we have to do is
box[0] = 50;
box[1] = 89;
box[2] = 69;
box[3] = 50;
.
.
.
box[9] = 30;

// NOTE - There are 10 comparments in the box, so we start with compartment 0
// and go all the way to compartment 9.
</source>

Notice how the array declaration follows the format:
<source>
// TypeOfBox NameOfBox[CompartmentsInBox]
int box [10]

// To get access to a compartment use use the syntax
// NameOfBox[CompartmentNumber]
box[0] // Gives you access to the first compartment in the box.
box[1] // Gives access to the second compartment
box[9] // Gives access to the last compartment
</source>
Other ways to declare an array:
<source>
// An array of 20 ints
int box[20];

// An array of 5 ints where the first three values are initialised, the other two have default values
int box[5] = {50, -35, 69};

// Create an array of ints and initialize all elements to zero
int box[10] = {}

// Both of these statements define an array of 3 ints initializes them with the values provided.
int box[] = {50, 23, 40};
int box[]{50, 23, 40};
</source>

The size of the array should be known at compile time and the size cannot be changed throughout the lifetime of the program. This is because the space for your container needs to be known at compile time
<source>
// FAIL
int size = 10;
int box[size]; // Error: Here the variable value can be changed during the life of the program because it is not a constant

// PASS
constexp int size = 10; // When using constexr it is guaranteed that size won't be changed and it will be known at complie time.
int box[size];
</source>
Accessing compartments that don't exist is a common mistake, in debug mode you'll get an error but bad things will happen in release mode. Especially be careful while accessing the last compartment of the array.
<source>
box[20] = 69 // Gives an error as our box only has 10 compartments and we're trying to access the 21st compartment.
box[10] = 69 // Again gives an error as our box has 10 compartments starting at 0, and going upto 9
</source>

=== But why arrays ? ===
Imagine you wanted to store the health of 10 enemies you could store them as enemyHealth0, enemyHealth1 and so on
<source>
// Store the health of 10 enemies
int enemyHealth0 = 44
int enemyHealth1 = 35
int enemyHealth2 = 45
.
.
.
int enemyHealth9 = 84
</source>
So far so good, now lets say you wanted to display the health of all 10 of your enemies
<source>
DisplayHealth(enemyHealth0);
DisplayHealth(enemyHealth1);
DisplayHealth(enemyHealth2);
.
.
.
DisplayHealth(enemyHealth9);
</source>
As you can probably see that you need to type DisplayHealth() repeatedly , what if we could do the same thing but with a lot less code ? That's where arrays come in:
<source>
// Declare an array of size 10 and set health variables to
int enemyHealth[10] = {44, 35, 45 ... 84};

// use a for loop to diplay enemy health
for(int i = 0; i < 10; i++)
{
DisplayHealth(enemyHealth[i]);
}
</source>
We could do the same if we wanted to kill off all enemies, just go through an array of all the enemies and kill them.
Arrays work really well with loops, in the above example we only had 10 values, but imagine if we had 100 values we could just loop over all of them with the same code by just changing the condition to <code>i < 100 </code>.

== What's really going on here tho ==
When you create an array e.g. <code>int box[10]</code> your computer takes a portion of your memory and gives a name to that block i.e. <code>box</code> in our case. The size of the block is decided by the type of the array. In our case int, a single int is <code>4 bytes</code> in size [https://msdn.microsoft.com/en-us/library/s3f49ktz.aspx MSDN Reference] and we need space to store 10 ints so your computer allocates <code>10 x 4 bytes</code> of memory i.e. <code>40 bytes</code> of memory where each int occupies 4 bytes one after the other.

Now when you access the third compartment in your array <code>box</code> and use the syntax <code>box[3]</code>. Your CPU says I am going to go to the starting point of box , you want the 3rd compartment? Ok, so each compartment is <code>4bytes</code> long (int) so to get to the third compartment I can take the starting point of block and move 3 times the size of each compartment, which in our case would be <code>3 * 4 = 12 bytes</code> . Now we are at the starting point of the third block. And because the type of the array is an <code>int</code> (size 4 bytes), your CPU knows that the next 4 bytes in the memory block are the contents of compartment 3.

If you're starting out with arrays, you don't need to know how arrays work under the hood; more gems will be revealed as you move on to the intermediate series. What's important is that you get a solid understanding of the concept of arrays as being big compartmentalized containers to store stuff that work really well with loops.

== Planet Chili Tutorial Video ==
* [[Beginner C++ Game Programming Tutorial 13]]

== Other Tutorials ==
* http://www.cplusplus.com/reference/array/array/

* https://www.tutorialspoint.com/cplusplus/cpp_arrays.htm

* https://www.programiz.com/cpp-programming/arrays

* https://www.geeksforgeeks.org/arrays-in-c-language-set-1-introduction/

== See Also ==
* [[Beginner_C++_Game_Programming_Series#Topics_Covered|List of Beginner C++ Topics]]

References

2018-07-06T11:04:49Z

Rudra: Created page with "References are a way to access one variable with two names. References are useful when we want to pass a variable to a function and make changes to it inside that function. =..."

References are a way to access one variable with two names. References are useful when we want to pass a variable to a function and make changes to it inside that function.

== Using References ==
To understand why we need references let's look at an example:

If we wanted to move our player to the right, one of the ways we could do it is:
<source>
// We have x position for our player on screen;
int posX = 50;
MoveRight(posX); // Should set posX to 51
DisplayValue(posX); // Should display 51 on Screen

// We create a function to move our player 1 unit in x direction
void MoveRight(int x)
{
// Add 1 to the value
x = x + 1;
}
// Takes in a variable and Displays its value on the screen
DisplayValue(int x)
{
// Do some stuff to display the variable on screen
}
</source>
After running this code you would expect 51 to be displayed on screen.
But when you run this code what would actually be displayed is:
<source>
//output
50
</source>

This happens because when you pass posX to the MoveRight function, it creates a copy of posX and does all the operations on that copy:

<source>
// x position of player on screen
int posX = 50;
MoveRight(posX); // Here a copy of posX is created and passed into the MoveRight function
DispayValue(posX); // Since a copy of posX was incremented and the actual variable is untouched we get an output of 50;

void MoveRight(int x)
{
// Add 1 to the value
x = x + 1; // The copy of posX is incremented by 1
}
</source>

=== Passing by Reference ===
Now, to move our player we want actual value of posX to change and not of a copy, so we need to grab c++ by the collar and tell it "listen to me, I do NOT want you to create a copy of my variable but change the original variable instead". If we change our MoveRight function to:
<source>
// Add an & after int - This tells c++ not to copy the value of whatever variable is passed in but to use 'x' as an alias for that variable
void MoveRight(int& x)
{
// x is an alias for posX
x = x + 1;
}
</source>
Now if we were to run the same code:
<source>
int posX = 50;
MoveRight(posX); // Now the address of posX is passed onto x and it becomes an alias for posX
DispayValue(posX); // Here we get an output of 51

// Add an & after int - This tells c++ not to copy the value of whatever variable is passed in but to use 'x' as an alias for that variable
void MoveRight(int& x)
{
// x is an alias for posX
x = x + 1;
}
</source>
Here by using the <code>&</code> sign when declaring the function, we instruct c++ not to copy the variable passed but use x as another name for posX. So whatever changes you make to x will be reflected on posX. This is also called passing by reference.

== What's really going on here tho ==
We know that we can create multiple variables, you can also think of variables as boxes where you can store data. But where are those boxes actually stored? In your computers memory. And how does your computer find that box when it needs to access the value ? It does it just like a postman finds your house when you get a letter i.e. by looking up your address.

Similarly, each of these boxes (variables) have addresses just like houses on a street would. So when you add the '&' sign like we did in the example above, you are telling c++ : Every time someone passes a variable into this function, take the address of that variable and refer to data at that address using the newly declared variable (x in our case).

Passing by reference is also faster than passing by value as you are not creating copies of the variable every time you call the function.

== Planet Chili Tutorial Video ==
* [[Beginner C++ Game Programming Tutorial 10]]

== Other Tutorials ==
* [https://www.tutorialspoint.com/cplusplus/cpp_references.htm Tutorials Point]
* [https://www.cprogramming.com/tutorial/references.html References and Efficieny]
* [http://www.cplusplus.com/doc/tutorial/pointers/ References and Pointers]

== See Also ==
* [[Beginner_C++_Game_Programming_Series#Topics_Covered|List of Beginner C++ Topics]]

If Statement

2018-06-13T10:36:37Z

Rudra: Created page with "If statements are a way to make decisions in your program. e.g., if the player presses Space Bar, make the player jump or IF the health is 0, end the game. == Using If State..."

If statements are a way to make decisions in your program. e.g., if the player presses Space Bar, make the player jump or IF the health is 0, end the game.

== Using If Statements ==
When making a decision in your program, two things need to happen
# You need to evaluate the condition.
# There should be a set of instructions(code) to execute based on that condition.
<source>
if(condition == true)
{
// Do something
}</source>

We use the <code>if</code> keyword followed by opening and closing parentheses <code>()</code> which contain the condition we want to evaluate followed by the block of code (surrounded by <code>{}</code>) that needs to be executed if that condition is true.
<source>
int PlayerHealth = 50;
if(PlayerHealth > 0) // Check the condition, if it is evaluated to be true, the code inside the {} is executed
{
// If true, execute some code
}
</source>
Here we set PlayerHealth to 50. And somewhere in our game, we want to check if the player is still alive, if so we do some shit.

A boolean can also be used as a condition. The code above can be written as:
<source>
int playerHealth = 50;
bool isAlive = (playerHealth > 0);
if(isAlive)
{
// Do stuff
}
</source>
If statement is controlled by the value inside <code>()</code> - Only when it is true, is your code executed.

But what if you want something to happen if the condition is not true, you stick the else keyword at the end:
<source>
int playerHealth = 0;
bool isAlive = (playerHealth > 0);
if(isAlive) // Evaluated to false
{
// Will not execute
}
else // Will execute
{
// You dead
}
</source>

You can even stick if conditions inside if conditions, this is called 'nesting':
<source>
std::string Weapon = "Gun";
if(Weapon == "Gun")
{
// Pew Pew Pew
}
else
{
if(condition)
{
// do some stuff
}
else
{
// run this block of code
}
}
</source>

The code above can be simplified and written as:
<source>
std::string Weapon = "Gun";
if(Weapon == "Gun") // Evaluate Condition
{
// Pew Pew Pew
}
else if(condition) // *Only* if the first if condition fails, evaluate this, otherwise skip
{
// do some stuff
}
else
{
// run this block of code if everything else fails
}
</source>
C++ gives us the <code>else if</code> keyword that allows us to keep checking for different conditions. You can use as many <code>else if</code> as you want, but remember it will only run if the condition before it has failed.

== What's really going on here tho ==
When you run your program all your c++ code is converted to machine code all of which is loaded into memory. When you use an if statement, you're effectively telling your computer - if this condition is true then jump to this part of memory. If you care about performance(you should you are using c++) you should know that this jumping around does carry some overhead, very fast code does try to avoid if statements in clever ways. If you are just starting out, you don't need to worry about all this.

== Tutorial Videos ==
[[Beginner C++ Game Programming Tutorial 3]]

== See Also ==
https://www.youtube.com/watch?v=qEgCT87KOfc&t=904s

http://www.cplusplus.com/doc/tutorial/control/

https://www.tutorialspoint.com/cplusplus/cpp_if_else_statement.htm

https://www.cprogramming.com/tutorial/lesson2.html