Chilipedia - User contributions [en]

Std::variant

2018-10-17T19:28:55Z

Albinopapa:

== What is <code>std::variant</code>? ==
In C++17, std::variant was introduced and is basically a strongly typed <code>union</code>. It allows you to specify a list of states that the <code>std::variant</code> can be in. These states are actually types, such as <code>int, float, double, MyClass</code>. It can only be in one state at a time, so if you assign it an <code>int</code> on one line, then assign it a <code>float</code> on another, the int is no long able to be retrieved.

== How to use <code>std::variant</code> ==
Std::variant has kind of a black-box approach in dealing with access to the data stored. While this does allow for some optimizations to be made in the form of compile time knowledge for the compiler, it makes it non-trivial for the user to access. Luckily, there are options, from safe but requires a bit of boiler-plate to not so safe but trivial. Look at the examples below.

First, the safe way. There are a few versions that pretty much do the same thing. Since the compiler knows the type stored in an <code>std::variant</code>, you can use the <code>std::visit</code> function to have the compiler choose which function to handle the variant.

<source>
#include <variant> // for std::variant, std::visit and an overload of std::get that works with std::variant
#include <iostream> // for std::cout

void PrintNumber( const int _number )
{
std::cout << _number << '\n';
}
void PrintNumber( const float _number )
{
std::cout << _number << '\n';
}
void PrintNumber( const double _number )
{
std::cout << _number << '\n';
}

int main( int ArgsC, char* ArgV[] )
{
std::variant<int, float, double> number;

number = 42; // number is now considered an int
std::visit( &PrintNumber, number ); // The PrintNumber( int ) overload should be called

number = 3.14159f; // number is now considered a float
std::visit( &PrintNumber, number ); // The PrintNumber( float ) overload should be called

number = 2.5 // number is now considered a double
std::visit( &PrintNumber, number ); // The PrintNumber( double ) overload should be called

return 0;
}
</source>
Version two using a function object as the 'visitor'.
<source>
#include <variant> // for std::variant, std::visit and an overload of std::get that works with std::variant
#include <iostream> // for std::cout

struct PrintNumber
{
void operator()( const int _number )
{
std::cout << _number << '\n';
}
void operator()( const float _number )
{
std::cout << _number << '\n';
}
void operator()( const double _number )
{
std::cout << _number << '\n';
}
};

int main( int ArgsC, char* ArgV[] )
{
std::variant<int, float, double> number;

number = 42; // number is now considered an int
std::visit( PrintNumber(), number ); // The PrintNumber::operator()( int ) overload should be called

number = 3.14159f; // number is now considered a float
std::visit( PrintNumber(), number ); // The PrintNumber::operator()( float ) overload should be called

number = 2.5 // number is now considered a double
std::visit( PrintNumber(), number ); // The PrintNumber::operator()( double ) overload should be called

return 0;
}
</source>
Version 3 using lambdas for the 'visitor'
<source>
#include <variant> // for std::variant, std::visit and an overload of std::get that works with std::variant
#include <iostream> // for std::cout

int main( int ArgsC, char* ArgV[] )
{
auto PrintNumber = []( auto _number )
{
using type = std::decay_t<decltype( _number )>;
if constexpr( std::is_same_v<type, int> )
{
std::cout << _number << '\n';
}
else if constexpr( std::is_same_v<type, float> )
{
std::cout << _number << '\n';
}
else if constexpr( std::is_same_v<type, double> )
{
std::cout << _number << '\n';
}
};

std::variant<int, float, double> number;

number = 42; // number is now considered an int
std::visit( PrintNumber, number ); // The if constexpr( std::is_same_v<type, int> ) branch should be used

number = 3.14159f; // number is now considered a float
std::visit( PrintNumber, number ); // The else if constexpr( std::is_same_v<type, float> ) branch should be used

number = 2.5 // number is now considered a double
std::visit( PrintNumber, number ); // The else if constexpr( std::is_same_v<type, double> ) branch should be used

return 0;
}
</source>
Do note that for each type in the variant, you must have a case handling the 'visit' or you'll get a compile time error, and it is nowhere near helpful in determining what case you missed, but not impossible.

Next is a safe way, but can be less efficient depending on your accuracy in knowing the type being stored.
<source>
#include <variant> // for std::variant, std::visit and an overload of std::get that works with std::variant
#include <iostream> // for std::cout

void PrintNumber( std::variant<int, float, double>& _number )
{
if( const int* myInt = std::get_if<int>( &_number ); myInt != nullptr )
{
std::cout << *myInt << '\n';
}
else if( const float* myFloat = std::get_if<float>( &_number ); myFloat != nullptr )
{
std::cout << *myFloat << '\n';
}
else if( const double* myDouble = std::get_if<double>( &_number ); myDouble != nullptr )
{
std::cout << *myDouble << '\n';
}
}

int main( int ArgsC, char* ArgV[] )
{
std::variant<int, float, double> number;

number = 42; // number is now considered an int
PrintNumber( number );

number = 3.14159f; // number is now considered a float
PrintNumber( number );

number = 2.5 // number is now considered a double
PrintNumber( number );

return 0;
}
</source>
Unlike <code>std::tuple</code>, variants cannot hold multiples of the same type. Each type in the template parameter list must be unique.

Finally, the unsafe way.
<source>
#include <variant> // for std::variant, std::visit and an overload of std::get that works with std::variant
#include <iostream> // for std::cout

int main( int ArgsC, char* ArgV[] )
{
std::variant<int, float, double> number;

number = 42; // number is now considered an int
int& myInt = std::get<int>( number );
myInt = 69;
std::cout << myInt << '\n';

number = 3.14159f; // number is now considered a float
float& myFloat = std::get<float>( number );
myFloat = 0.707f
std::cout << myFloat << '\n';

number = 2.5 // number is now considered a double
double& myDouble = std::get<double>( number );
myDouble = 419.999999999
std::cout << myDouble << '\n';

return 0;
}
</source>
This example, made it safe by using the retrieved type directly after assignment, but after that, the user may not know what state the variant is in and calling <code>std::get</code> on the wrong type will throw a <code>std::bad_variant_access</code> exception. The above method of assigning the value, then retrieving a reference to the underlying type allows you to modify the state of the object from within without having to setup visitors just for initialization.

== Requirements for <code>std::variant</code> ==
* The list of types must be unique, a variant cannot be declared with two ints and a float
* The types in a variant must be default constructable or the use of <code>std::monostate</code> can be set as the first type in the parameter list
<source>
std::variant<std::monostate, MyComplexClass, MyComplexClass1> data;
</source>
* Types in <code>std::variant</code> parameter list, must not be forward declared types. The compiler must be able to determine whether or not the types in the list are default constructable before instantiating a variant of those types.
* The list may not contain reference types: int&, const MyCompolexClass&

Std::variant

2018-10-17T18:59:15Z

Albinopapa: Created page with " == What is <code>std::variant</code>? == In C++17, std::variant was introduced and is basically a strongly typed <code>union</code>. It allows you to specify a list of state..."

== What is <code>std::variant</code>? ==
In C++17, std::variant was introduced and is basically a strongly typed <code>union</code>. It allows you to specify a list of states that the <code>std::variant</code> can be in. These states are actually types, such as <code>int, float, double, MyClass</code>. It can only be in one state at a time, so if you assign it an <code>int</code> on one line, then assign it a <code>float</code> on another, the int is no long able to be retrieved.

== How to use <code>std::variant</code> ==
Std::variant has kind of a black-box approach in dealing with access to the data stored. While this does allow for some optimizations to be made in the form of compile time knowledge for the compiler, it makes it non-trivial for the user to access. Luckily, there are options, from safe but requires a bit of boiler-plate to not so safe but trivial. Look at the examples below.

First, the safe way. There are a few versions that pretty much do the same thing. Since the compiler knows the type stored in an <code>std::variant</code>, you can use the <code>std::visit</code> function to have the compiler choose which function to handle the variant.

<code>
#include <variant> // for std::variant, std::visit and an overload of std::get that works with std::variant
#include <iostream> // for std::cout

void PrintNumber( const int _number )
{
std::cout << _number << '\n';
}
void PrintNumber( const float _number )
{
std::cout << _number << '\n';
}
void PrintNumber( const double _number )
{
std::cout << _number << '\n';
}

int main( int ArgsC, char* ArgV[] )
{
std::variant<int, float, double> number;

number = 42; // number is now considered an int
std::visit( &PrintNumber, number ); // The PrintNumber( int ) overload should be called

number = 3.14159f; // number is now considered a float
std::visit( &PrintNumber, number ); // The PrintNumber( float ) overload should be called

number = 2.5 // number is now considered a double
std::visit( &PrintNumber, number ); // The PrintNumber( double ) overload should be called

return 0;
}
</code>
Version two using a function object as the 'visitor'.
<code>
#include <variant> // for std::variant, std::visit and an overload of std::get that works with std::variant
#include <iostream> // for std::cout

struct PrintNumber
{
void operator()( const int _number )
{
std::cout << _number << '\n';
}
void operator()( const float _number )
{
std::cout << _number << '\n';
}
void operator()( const double _number )
{
std::cout << _number << '\n';
}
};

int main( int ArgsC, char* ArgV[] )
{
std::variant<int, float, double> number;

number = 42; // number is now considered an int
std::visit( PrintNumber(), number ); // The PrintNumber::operator()( int ) overload should be called

number = 3.14159f; // number is now considered a float
std::visit( PrintNumber(), number ); // The PrintNumber::operator()( float ) overload should be called

number = 2.5 // number is now considered a double
std::visit( PrintNumber(), number ); // The PrintNumber::operator()( double ) overload should be called

return 0;
}
</code>
Version 3 using lambdas for the 'visitor'
<code>
#include <variant> // for std::variant, std::visit and an overload of std::get that works with std::variant
#include <iostream> // for std::cout

int main( int ArgsC, char* ArgV[] )
{
auto PrintNumber = []( auto _number )
{
using type = std::decay_t<decltype( _number )>;
if constexpr( std::is_same_v<type, int> )
{
std::cout << _number << '\n';
}
else if constexpr( std::is_same_v<type, float> )
{
std::cout << _number << '\n';
}
else if constexpr( std::is_same_v<type, double> )
{
std::cout << _number << '\n';
}
};

std::variant<int, float, double> number;

number = 42; // number is now considered an int
std::visit( PrintNumber, number ); // The if constexpr( std::is_same_v<type, int> ) branch should be used

number = 3.14159f; // number is now considered a float
std::visit( PrintNumber, number ); // The else if constexpr( std::is_same_v<type, float> ) branch should be used

number = 2.5 // number is now considered a double
std::visit( PrintNumber, number ); // The else if constexpr( std::is_same_v<type, double> ) branch should be used

return 0;
}
</code>
Do note that for each type in the variant, you must have a case handling the 'visit' or you'll get a compile time error, and it is nowhere near helpful in determining what case you missed, but not impossible.

Next is a safe way, but can be less efficient depending on your accuracy in knowing the type being stored.
<code>
#include <variant> // for std::variant, std::visit and an overload of std::get that works with std::variant
#include <iostream> // for std::cout

void PrintNumber( std::variant<int, float, double>& _number )
{
if( const int* myInt = std::get_if<int>( &_number ); myInt != nullptr )
{
std::cout << *myInt << '\n';
}
else if( const float* myFloat = std::get_if<float>( &_number ); myFloat != nullptr )
{
std::cout << *myFloat << '\n';
}
else if( const double* myDouble = std::get_if<double>( &_number ); myDouble != nullptr )
{
std::cout << *myDouble << '\n';
}
}

int main( int ArgsC, char* ArgV[] )
{
std::variant<int, float, double> number;

number = 42; // number is now considered an int
PrintNumber( number );

number = 3.14159f; // number is now considered a float
PrintNumber( number );

number = 2.5 // number is now considered a double
PrintNumber( number );

return 0;
}
</code>
Unlike <code>std::tuple</code>, variants cannot hold multiples of the same type. Each type in the template parameter list must be unique.

Finally, the unsafe way.
<code>
#include <variant> // for std::variant, std::visit and an overload of std::get that works with std::variant
#include <iostream> // for std::cout

int main( int ArgsC, char* ArgV[] )
{
std::variant<int, float, double> number;

number = 42; // number is now considered an int
int& myInt = std::get<int>( number );
myInt = 69;
std::cout << myInt << '\n';

number = 3.14159f; // number is now considered a float
float& myFloat = std::get<float>( number );
myFloat = 0.707f
std::cout << myFloat << '\n';

number = 2.5 // number is now considered a double
double& myDouble = std::get<double>( number );
myDouble = 419.999999999
std::cout << myDouble << '\n';

return 0;
}
</code>
This example, made it safe by using the retrieved type directly after assignment, but after that, the user may not know what state the variant is in and calling <code>std::get</code> on the wrong type will throw a <code>std::bad_variant_access</code> exception. The above method of assigning the value, then retrieving a reference to the underlying type allows you to modify the state of the object from within without having to setup visitors just for initialization.

== Requirements for <code>std::variant</code> ==

If Statement

2018-10-17T17:41:03Z

Albinopapa: /* What's really going on here tho */

If statements are a way to make decisions in your program. e.g., <code>if</code> the player presses the space bar, make the player jump, or <code>if</code> health is 0, end the game.

== Using If Statements ==
=== Basics ===
When a decision is made at an if statement in your program, two things happen:
# A condition is evaluated
# A set of instructions (code) is executed (or skipped) based on the above 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. The condition is followed by a block of code (surrounded by braces <code>{}</code>) that is executed if that condition evaluates to <code>true</code>.
<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 check if the player is still alive, and if so we do some shit.

A <code>bool</code> can also be used directly as a condition. The code above can be written as:
<source>
int playerHealth = 50;
bool isAlive = (playerHealth > 0);
if(isAlive)
{
// Do stuff
}
</source>
An <code>if</code> statement is controlled by the value inside the parentheses <code>()</code>--only when it is true is your code executed.
=== Else Statement ===
But what if you want something to happen only if the condition is ''not'' true? Then you stick the <code>else</code> keyword after the <code>if</code> code block:
<source>
int playerHealth = 0;
bool isAlive = (playerHealth > 0);
if(isAlive) // Evaluated to false
{
// Will not execute
}
else // Will execute
{
// You dead
}
</source>
=== Nesting ===
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>
=== Chaining ===
You can also chain multiple <code>if</code> statements together using the <code>else</code> keyword. 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 <code>if</code> statement, you're effectively telling your computer - if this condition is true then jump to another location in memory, but if it is false, just continue executing the next instruction in memory.

If you care about performance, you should know that this jumping around (called branching) can carry some overhead. The CPU has highly specialized circuits that attempt to predict which branch of code the execution will follow. For many situations these circuits are very successful in making the predictions, and thus the cost of branching is effectively zero. But in some situations it is very difficult for the branch predictor to accurately predict which branch is going to be taken, and in these situations highly optimized code tries to avoid if statements in clever ways.

If you are just starting out, you don't need to worry about all this.

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

== Other Tutorials ==
* http://www.cplusplus.com/doc/tutorial/control/

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

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

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

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

Keyboard (Chili Framework)

2017-06-27T09:26:47Z

Albinopapa: /* Virtual Key Codes */

With <code>Keyboard</code>, you can get the current state of depressed keys (have a Valium mate), and you can pop key press and release events out of an <code>Event</code> queue contained in <code>Keyboard</code>. You can also turn autorepeat on/off. Whopee. (''Note: the ''<code>kbd</code>'' object lives in ''<code>MainWindow</code>'''s belly.'')

== Example of Use ==
<syntaxhighlight lang="cpp" line="1" >
// how to respond to key release event

// keep processing events as long as queue contains them
while( !wnd.kbd.IsEmpty() )
{
// get an event from the queue
const Keyboard::Event e = wnd.kbd.ReadKey();
// check if it is a release event
if( e.IsRelease() )
{
// check if the event was for the space key
if( e.GetCode() == VK_SPACE )
{
// respond to space key release event
}
}
}
</syntaxhighlight>

== Members ==
=== KeyIsPressed ===
<code>bool Keyboard::KeyIsPressed( unsigned char keycode ) const</code> 
Checks to see if a specific key is currently in the pressed state. The function parameter is the [[#Virtual Key Codes|virtual key code]] of the key that you want to check.

=== ReadKey ===
<code>Event Keyboard::ReadKey()</code> 
Pull a fresh <code>[[#Event|Event]]</code> object out of the key press/release event queue. Erases an event from the queue and returns a copy if there is a key press event in the queue. Returns an invalid Event object if the queue is empty.

=== KeyIsEmpty ===
<code>bool Keyboard::KeyIsEmpty() const</code> 
Returns <code>true</code> if the key event queue is empty.

=== ReadChar ===
<code>char Keyboard::ReadChar()</code> 
Pull a fresh character off of the character queue. Returns a <code>'\0'</code> (null) character if the queue is empty. See also: [[#ReadKey vs. ReadChar|ReadKey vs. ReadChar]].

=== CharIsEmpty ===
<code>bool Keyboard::CharIsEmpty() const</code> 
Returns <code>true</code> if the character queue is empty.

=== Buffer Flushing Bullshit ===
<code>void Keyboard::FlushKey()</code> 
<code>void Keyboard::FlushChar()</code> 
<code>void Keyboard::Flush()</code> 
These functions empty the respective queues. Flush() empties both in one fell swoop. It's like taking a pee and a poo at the same time.

=== Autorepeat Bullshit ===
<code>void Keyboard::EnableAutorepeat()</code> 
<code>void Keyboard::DisableAutorepeat()</code> 
<code>bool Keyboard::AutorepeatIsEnabled() const</code> 
If you hhhhhhhhhhhhhhhhhold a key down for a while, it will start machine gunning events and characters into your queues like a motherfucker. You can disable that if it pisses you off.

== Event ==
<code>class Keyboard::Event</code> 

Key press and release events are held in a queue in <code>Keyboard</code> in the order they occurred. These events are modeled with their own class because they're precious fucking little snowflakes. They store the type of event (press or release) and the [[#Virtual Key Codes|virtual key code]] of the associated key. You pull them out of the buffer with <code>Keyboard::ReadKey()</code>.

=== IsPress ===
<code>bool Keyboard::Event::IsPress() const</code> 

Returns <code>true</code> if the event is a press event.

=== IsRelease ===
<code>bool Keyboard::Event::IsRelease() const</code> 

Returns <code>true</code> if the event is a release event.

=== IsValid ===
<code>bool Keyboard::Event::IsValid() const</code> 

Returns <code>true</code> if the event is a valid event (reading from an empty buffer will return an invalid event object).

=== GetCode ===
<code>char Keyboard::Event::GetCode() const</code> 

Gets the virtual key code of the key associated with the <code>Event</code> object.

== Miscellaneous ==
=== Virtual Key Codes ===
The virtual key code for a standard alphanumeric key is just the <code>char</code> literal (capital if alphabetic), e.g. <code>'A'</code> or <code>'9'</code>. Virtual key codes for other keys are defined with <code>#define</code> macros included with <code>Windows.h</code>. Some common ones are:
* <code>VK_SPACE</code>
* <code>VK_SHIFT</code>
* <code>VK_RETURN</code>
* <code>VK_ESCAPE</code>
See the Microsoft [https://msdn.microsoft.com/en-us/library/windows/desktop/dd375731(v=vs.85).aspx documentation] for the full list of virtual key codes defined in the Windows headers.

=== ReadKey vs. ReadChar ===
There are two main differences between the events read with <code>ReadKey()</code> and the <code>char</code> values read with <code>ReadChar()</code>:
# Each key press and release sequence puts two events (press event and release event) into the <code>ReadKey()</code> queue, but the same sequence only puts one <code>char</code> value into the <code>ReadChar()</code> queue.
# The <code>char</code> values read with <code>ReadChar()</code> have the shift modifier applied to them, whereas those read by <code>ReadKey()</code> are just the raw virtual key codes. For example, pressing the 'A' key puts <code>'a'</code> into the <code>ReadChar()</code> queue when the shift key is not pressed and <code>'A'</code> when it is pressed, but the virtual key code in either case is <code>'A'</code> for <code>ReadKey()</code>.
In general, you should use <code>ReadKey()</code> for controlling shit and <code>ReadChar()</code> for text input.

== See also ==
* The [[Chili Framework]]

Variable

2016-08-30T23:00:43Z

Albinopapa: /* Variable Types */

Variables are like little boxes to store data in and read data from, typically numbers. What's in the box?!

== How to Declare a Variable ==
You declare/create a variable by stating its type and then stating its name: <code>int myVar;</code>. You can also give an initial value for the variable during creation using the assignment operator: <code>int myVar = 69;</code>.

== Variable Names ==
Variables names (the same as any other type of user-defined symbol) can contain any number, letter, and the underscore character. They cannot start with a number. Case matters (<code>_DirtayBoi69</code> is not the same symbol as <code>_dirtayboi69</code>).

== Variable Types ==
=== Integral types ===
Integral types are variables that store integers. There are signed and unsigned versions of each integral type and the built-in or simple types are char, short, int/long, and long long/uint64_t. Generally, for the signed versions, you do not have to specify signed, but for unsigned versions; unsigned char, unsigned short, unsigned int, unsigned long long, you do have to specify. Unsigned integrals are integers that don't have negative numbers, they go from 0 to double + 1 their signed counterparts in the positive direction.

As an example, signed char goes from -128 to 127 whereas unsigned char goes from 0 to 255.
=== char ===
<code>char</code> variables store an integer ranging from -128 to 127. They occupy 1 byte of memory and are most commonly used for narrow text/string manipulation.
=== short===
<code>short</code> variables store an integer ranging from -32768 to 32767. They occupy 2 bytes of memory. An alias for short is wchar_t and is used for wide character text and strings used to extend support for languages with more characters than the char range can handle.
=== long long ===
<code>long long</code> variables store an integer ranging from –9,223,372,036,854,775,808 to 9,223,372,036,854,775,807. They occupy 8 bytes in memory. The type long long can also be referred to as int64_t because it is 64 bits long.
=== int ===
<code>int</code> variables store an integer (non-fractional number) ranging from -2147483648 to 2147483647. They occupy 4 bytes of memory.
=== bool ===
<code>bool</code> variables store a Boolean logic value (true or false). They occupy 4 bytes of memory. The <code>bool</code> type is used to control the operation of flow control statements, such as the <code>if</code> statement.

== The const Specifier ==
You can specify that a variable's value cannot be changed by declaring it like this: <code>const int blazeItFgt = 420;</code>. Doing so can protect your code from unintentional bugs and is generally considered a fucking good practice called 'const correctness'. Note that when you declare a variable as <code>const</code>, you need to initialize it during creation because you cannot assign to it afterwards.

Function

2016-08-30T22:40:15Z

Albinopapa:

A function is a grouping of code that you can invoke or 'call' from one or more points in your program. You can even call a function from itself (motherfucking funception)!

== Function Calls ==
A function call in C++ generally looks something like this <code>obj.MyFunction( param1,param2 )</code>. It consists of the function name (<code>Myfunction</code> in the example above) followed by parentheses () which surround parameters separated by commas (,). To call a member function of an object, you first type the object name, then a period '.', and then the function name (e.g. <code>obj.</code>).

The function parameters are used to control the behavior of the function. A function can have zero or more of these. A function can also return a value, which can be used in other operations. If a function does not return a value, its return type is <code>void</code>.

== Declaring and Defining Functions ==
Declaring a function is pretty straight forward as described above. You have the three parts; the return type, the name, the parameter list. Functions can be declared as global functions or member functions. Global functions are functions that do not belong to a class or struct, which would be called member functions. You can declare a global function in the header file (.h) or in the source file (.cpp).

Examples:
A global function that returns nothing and doesn't take any parameters.
void DoSomething();

A global function that returns nothing and takes two parameters.
void PrintAandB(int A, int B);

A global function that returns an int, and takes two int parameters.
int AddThese(int A, int B);

A member function is declared in the same manner, the only difference is they are declared inside the class declaration.

class MyClass
{
void DoSomething();
void Print(int A, int B);
int AddThese(int A, int B);
};

Defining functions is handled differently depending on where you define them and whether they are global or member functions. A functions can be declared and defined in the same place. If a global function is declared and defined in the header file, it must be preceded with the word inline, letting the compiler know that you are defining it there instead of trying to look for it in a source file.

inline void DoSomething()
{
// Put code here...
}

If you declare the function in the header file and define it in the source file, you don't need the inline declaration.

If you declare and define a member function in the class declaration, you also do not need the inline declaration.

class MyClass
{
int AddThese(int A, int B)
{
return A + B;
}
};

== What's really goin on here tho ==
What actually happens when a function is called is: the values to be passed to the function are placed somewhere where the function code can access them (called the stack, or in some calling conventions the parameters are put into CPU registers), then the current execution address is saved and the CPU jumps to the function address and begins executing the function instructions. At the end of the function, the result (if any) is placed in a predetermined location (typically a register), and the CPU jumps back to the address that it had previously saved and continues on its merry way.

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

== See Also ==
http://www.cplusplus.com/doc/tutorial/functions/

Graphics (Chili Framework)

2016-07-25T07:28:58Z

Albinopapa: /* Screen Dimensions */

This class takes care of all the Direct3D setup bullshit and provides an interface to the graphical output of the application. Use <code>Graphics</code> to draw on the screen, anything you like, even dicks (''especially'' dicks). <code>PutPixel()</code> is generally how this is gone about, although later on more sophisticated dick-drawing routines are created based on <code>PutPixel()</code>. You can also use <code>Graphics::ScreenWidth</code> etc. to make sure you keep your dicks inside the screen boundaries.

== Members ==

=== PutPixel ===

<code>void Graphics::PutPixel(int x,int y,int r,int g,int b)</code> 
<code>void Graphics::PutPixel(int x,int y,Color c)</code> 

This little number lets you set the color any pixel on the screen (actually streamer, it sets the pixels in a buffer residing in system memory, which then is copied to a texture in graphics memory and drawn to the backbuffer, which is subsequently presented to a region of the screen corresponding to the client area of the application window YEAH OKAY FUCK OFF NOW), which means you can pretty much create any image you want with this function, even Teletubbie porn. 

As you might expect, <code>x</code> and <code>y</code> specify the coordinates on the screen ('''(0,0)''' being the top left, '''(width-1,height-1)''' being the bottom right), and <code>r</code>, <code>g</code>, and <code>b</code> specify the color (0 being lowest and 255 being highest). If you try and draw outside of the screen space, you might get F'ed in the A. So don't do that.

=== Screen Dimensions ===

<code>static constexpr unsigned int Graphics::ScreenWidth = 1280u</code> 
<code>static constexpr unsigned int Graphics::ScreenHeight = 720u</code>

These values tell you the maximum size dick you can draw on the screen. Since they are <code>static</code> members, you can access them with, for example, <code>Graphics::ScreenWidth</code> (you can do <code>gfx.ScreenWidth</code> too if you really wanna). Changing the default values from 1280 and 720 to something different will make the window larger or smaller depending on the values. Neato!

== See also ==
* The [[Chili Framework]]

User:Albinopapa

2016-07-25T07:22:49Z

Albinopapa: Created page with "Loyal planetchili citezen, that is all."

Loyal planetchili citezen, that is all.