jbtronics - CheatSheet Poster

Winslow - Unreal Engine 5 Blueprint CheatSheet Dark Theme

Winslow - Unreal Engine 5 C++ CheatSheet Dark Theme

Winslow - Unreal Engine 5 Editor CheatSheet Dark Theme

VictoriaLyons - ProfilingCheatSheet

Syntax refers to the set of rules that define the structure, format and grammar of a programming language. It dictates how statements and expressions should be written to form valid code.

C++ follows a structured syntax that includes elements such as keywords², identifiers, operators and control structures. The syntax is designed to provide precise instructions to the compiler on how to interpret and execute the code.

Weak and strong typing refer to different approaches in how programming languages handle data types and type safety.

In C++, the language is considered strongly typed, as it requires explicit type conversions and does not perform implicit type coercion without the programmer's explicit instruction (except number data types). C++ enforces strong typing to ensure type safety and minimize potential errors.

Weak Typing (Python³ code):

a = 5 # Compiled! Because Python is a weak typing language.

Strong Typing (C++ code):

a = 5; // Error!
int a = 5; // Compiled!

In C++, a semicolon (;) is used to mark the end of a statement. It serves as a delimiter, indicating to the compiler that one statement has finished and another begins. The presence of semicolons allows the compiler to separate statements and interpret code correctly.

The requirement for semicolons in C++ is a design choice that provides explicit statement termination. This approach allows for more fine-grained control over program execution and eliminates ambiguity.

In contrast, languages like Python³ use indentation to define blocks of code, eliminating the need for explicit statement termination with semicolons.

int a = 5; // Compiled!
int b = 5 // Error! Semicolon missing.

C++ uses curly braces ({}) as block delimiters to enclose multiple statements or define the body of control structures, functions, and classes. The use of curly braces provides a clear and explicit way to define the boundaries of code blocks (also know as a scope).

Curly braces help define the scope of variables and maintain code readability. They ensure that statements within the braces are treated as a single unit, making it easier to understand the flow and logic of the program.

class Car
{

};

namespace MyNamespace
{

}

void MyFunction()
{
    {
        // Scope inside a function
    }
}

Both single-line and multi-line comments are helpful for adding explanatory notes, documenting code, or temporarily disabling sections of code during debugging or development. They enhance code readability, facilitate collaboration, and provide valuable information to developers maintaining the codebase.

Single-line comments start with two forward slashes // and continue until the end of the line.

They are typically used for brief comments or explanations on a single line.

// This is a single-line comment in C++

Multi-line comments, also known as block comments, start with a forward slash (/) followed by an asterisk (*) and end with an asterisk (*) followed by a forward slash (/).

Multi-line comments can span multiple lines and are used for more extensive comments or documentation.

/*
    This is a multi-line comment
    It can span multiple lines
*/

In C++, header files and source files are two types of files used to organize and manage code in a C++ program.

Other languages, like C#⁴, Java⁵, and Python³, continued to use single file extensions because they adopted a more integrated approach to handling both declarations and implementations within a single file.

In modern programming, the choice of using single file extensions or separate header and source files depends on the language's design philosophy and the needs of the development community. Both approaches have their strengths and weaknesses, and different languages adopt the one that best aligns with their goals and use cases.

In C++, the include directive is used to bring external code (headers or libraries) into your source code. It allows you to access the declarations and definitions present in those files.

The include directive is typically written as:

#include "filename.h"   // Using double quotes for user-defined headers
#include <filename.h>   // Using angular brackets for standard library headers

Here's the difference between using double quotes and angular brackets:

1. Double Quotes (`"filename.h"): When you use double quotes, the preprocessor searches for the header file in the current directory first. If it doesn't find the file there, it will look in the additional include directories specified in the project settings.

   Example: #include "MyHeader.h"

2. Angular Brackets (<filename.h>): When you use angular brackets, the preprocessor only searches for the header file in the standard library directories specified for the compiler.

   Example: #include <iostream>

In general, you use double quotes for your own header files (which may be part of your project) and angular brackets for standard library headers (like iostream, vector, etc.) or headers from external libraries.

The standard library in C++ is a collection of pre-defined classes and functions that provide a wide range of functionality for common tasks. It is a part of the C++ Standard Template Library (STL) and is officially known as the C++ Standard Library. The library is designed to be platform-independent and provides a standardized set of features that are supported across different C++ compilers and environments.

The C++ Standard Library is organized into several header files, each of which contains declarations for specific classes and functions. Some of the key components of the standard library include containers (like vectors, lists, maps, etc.), algorithms (sorting, searching, etc.), iterators, input/output operations, strings, and more.

To use the standard library in C++, you include the appropriate header files in your code, and then you can directly use the classes and functions provided by the library. For example, to use the std::vector class, you include the <vector> header file and then create instances of the vector and use its methods.

The name "std" comes from the fact that all the classes, functions, and other elements of the standard library are part of the std namespace. The namespace std is used to avoid naming conflicts with other libraries and user-defined code. By using the std:: prefix before any element from the standard library, you explicitly specify that you are referring to the elements in the std namespace.

Here's a simple example of how to use the standard library in C++:

#include <iostream>
#include <vector>
#include <algorithm>

std::vector<int> numbers = {5, 2, 9, 1, 7};

// Use standard library algorithm to sort the vector
std::sort(numbers.begin(), numbers.end());

// Use standard library to print the sorted vector
for (int num : numbers)
{
    std::cout << num << " ";
}

Table from Microsoft Learn about Data Type Ranges.

If its name begins with two underscores (__), a data type is non-standard.

[!WARNING] C++ lacks explicitness about data types size, leading to potential variation. For instance, the int type can manifest as either 16-bits or 32-bits, depending on the context.

Here is a summary of the explicit data sizes:

char myChar = 'a';

bool isDead = true;

int health = 10;

C++ allows the char, int, and double data types to have modifiers preceding them. A modifier is used to alter the meaning of the base type so that it more precisely fits the needs of various situations.

The modifiers signed, unsigned, long and short can be applied to integer base types. In addition, signed and unsigned can be applied to char, and long can be applied to double.

The modifiers signed and unsigned can also be used as prefix to long or short modifiers.

For example:

unsigned long int // Same as unsigned 32-bit integer (unsigned int)

[!NOTE] The default behavior for all integer types is signed.

Here is a list of modifiers for integer data type:

float speedInMetersPerSecond = 5.5f; // C++ always uses 'f' or 'F' literal for defining a float variable.

double speedInMetersPerSecond = 5.5; // C++ never uses a literal for defining a double variable.

In C++, the typedef keyword² is used to create an alias or alternative name for existing data types. It provides a way to define a new name that can be used as a shorthand for the original type, improving code readability and maintainability.

Here's an example:

typedef int myInt; // Declare our alias for custom type

myInt x = 5;  // Equivalent to: int x = 5;

[!WARNING] Unreal Engine doesn't support typedefs with UHT⁷. Meaning, you can't expose to Blueprint.

Members are variables or functions that are part of a class or object. They define the properties and behaviors of the class.

There are two main types of members: variables and functions.

Members that store data. They can be of different types such as numbers, strings, booleans, or custom data types. Variables hold values that can be accessed and manipulated within the class or object.

There are abbreviations for frequently done kinds of assignments. Here are a few:

Functions are blocks of code that perform a specific task or set of tasks. They encapsulate a series of instructions and can be called and executed from various parts of a program. Functions can accept input parameters (arguments) and can also return a value as a result.

Functions can be defined outside of classes as standalone functions or can be defined within classes as member functions. Standalone functions are typically used for common tasks that are not specific to any particular class or object.

Here's an example:

/// @brief Calculates the factorial of a number using recursion.
/// @param n Number of times.
/// @result A number.
int Factorial(int n)
{
    if (n == 0 || n == 1)
        return 1;
    else
        return n * Factorial(n - 1);
}

Classes are the building blocks of object-oriented programming (OOP). They are a blueprint for creating objects, which are instances of a class. A class defines the structure and behavior of objects by specifying the members it contains.

A class can have variables (members) to store data and functions (methods) to perform actions. The variables defined within a class are often referred to as attributes, while the functions are referred to as methods.

Objects created from a class can access and modify the class's members. They provide a way to create multiple instances that share the same structure and behavior defined by the class. Objects can be thought of as individual entities that represent real-world objects or abstract concepts.

Classes allow for code reusability, encapsulation (hiding internal details), and the ability to model complex systems by organizing related data and behavior together.

Here's an example:

class Person
{
public:
    Person(std::string name, int age)
        : name(name)
        , age(age)
    { }

    void DisplayInfo()
    {
        // ...
    }

private:
    std::string name;
    int age;
};

In C++, a struct is a user-defined data type that allows you to group multiple variables of different data types under a single name. It is similar to a class, but with some key differences.

Usage of struct in C++

• Structs are used to create lightweight data structures to hold related data elements.
• They are commonly used to represent simple data objects or records that do not require complex behavior or methods.

Difference between class and struct In C++, the main difference between a class and a struct is the default access level. In a class, the default access level for its members is private, while in a struct, the default access level is public. This means that members of a struct are accessible outside the struct without the need for access specifiers.

For example:

struct Vector3
{
    float x;
    float y;
    float z;

    Vector3(float _x = 0.0f, float _y = 0.0f, float _z = 0.0f)
        : x(_x)
        , y(_y)
        , z(_z)
    { }
};

Vector3 v1(1.0f, 2.0f, 3.0f);
Vector3 v2(4.0f, 5.0f, 6.0f);

float dx = v1.x - v2.x;
float dy = v1.y - v2.y;
float dz = v1.z - v2.z;

float dist = std::sqrt(dx * dx + dy * dy + dz * dz);

Historical difference with C language In C, there was no concept of classes, and struct was the primary way to define user-defined data types. In C++, the struct keyword was retained to maintain compatibility with C, but it gained additional features and behavior, such as the ability to have member functions and access specifiers.

In modern C++, the distinction between class and struct has become more a matter of convention and coding style rather than a strict rule. Many developers prefer to use struct for simple data containers with public data members and class for more complex objects with private data members and member functions. However, you can use either class or struct based on your design preferences.

class MyClass
{
public:
    int publicVar; // Public member variable

    // Public member function
    void publicFunction()
    {
        // ...
    }

protected:
    int protectedVar; // Protected member variable

    // Protected member function
    void protectedFunction()
    {
        // ...
    }

private:
    int privateVar; // Private member variable

    // Private member function
    void privateFunction()
    {
        // ...
    }

    mutable int mutableVar; // Mutable member variable

    friend void friendFunction(MyClass& obj); // Friend function declaration
};

void friendFunction(MyClass& obj)
{
    obj.privateVar = 42; // Friend function can access private member variable
}

MyClass obj;

// Accessing public members
obj.publicVar = 10; // Compiled!
obj.publicFunction(); // Compiled!

// Accessing private members via friend function
friendFunction(obj); // Compiled!

// Accessing private members directly (only possible within the class)
obj.privateVar = 20; // Error!
obj.privateFunction(); // Error!

If-statement is a fundamental control structure that allows you to conditionally execute a block of code based on a specified condition. It provides a way to control the flow of execution in your program.

if (condition)
{
    // Code to be executed if the condition is true
}
else if (secondCondition)
{
    // Code to be executed if the secondCondition is true, but condition was false
}
else
{
    // Code to be executed if the condition and secondCondition is both false
}

Here are some operations for creating conditions:

• == - Equality check
• != - Inequality check
• > - Check for greater
• < - Check for less
• >= - Check for greater or equal
• <= - Check for less or equal
• && - Expression A && B is evaluated by first evaluating A. A has value 0, then A && B also has value 0, and B is not evaluated. Otherwise, B is evaluated; if B has value 0, then A && B has the same value 0, and otherwise has value 1. Also called AND operator.
• || - Expression A || B is evaluated by first evaluating A. If A has a nonzero value, then A || B has value 1, and B is not evaluated. Otherwise, A || B has value 1 if B is nonzero and value 0 if B is zero. Also called OR operator.
• ! - Expression !A is 0 if A is nonzero, and is 1 if A is 0. Also called NOT operator.

Conditional expressions in C++ are statements that evaluate a condition and return a value based on the result of the condition. They provide a concise way to express simple conditions and perform different actions or assignments based on the outcome.

The basic syntax of a conditional expression in C++ is as follows:

int value = isDead ? 100 : -100; // condition ? value_if_true : value_if_false;

• 1. The condition within the parentheses is evaluated.

• 2. If the condition is true, the value or expression before the colon (:) is returned as the result of the conditional expression.

• 3. If the condition is false, the value or expression after the colon is returned as the result.

In C++, a switch statement is a control flow construct used to select one of many possible execution paths based on the value of a given expression. It provides an alternative to using multiple if-else statements when checking a variable against different values.

The basic syntax of a switch statement in C++ is as follows:

switch (expression)
{
    case value1:
        // Code to be executed if expression matches value1
        break;
    case value2:
        // Code to be executed if expression matches value2
        break;
    // Add more case statements as needed
    default:
        // Code to be executed if none of the cases match
        break;
}

• 1. The expression is evaluated, and its value is compared against the cases specified in the switch statement.

• 2. If a case matches the value of the expression, the code block associated with that case is executed. The execution then continues until a break statement is encountered, which exits the switch statement.

• 3. If none of the cases match the expression's value, the code block associated with the default case (optional) is executed. The default case serves as a fallback option when no matching cases are found.

Loops are essential constructs in programming languages that allow repetitive execution of a block of code based on a specified condition. They provide a way to automate tasks, process collections of data, and iterate over a sequence of elements.

While loop are used when the number of iterations is uncertain but depends on a condition. The loop continues as long as the specified condition remains true. It evaluates the condition before each iteration, and if it becomes false, the loop terminates.

Here's an example of finding the first power of 2 greater than 100:

int num = 1;

while (num <= 100)
{
    num *= 2;
}

std::cout << "First power of 2 greater than 100: " << num << std::endl;

// Output: First power of 2 greater than 100: 128

A do-while loop is a control flow structure in programming that executes a block of code at least once, and then repeats the execution as long as a specified condition remains true. It is similar to the while loop, but with the condition checked at the end of each iteration.

Here's an example of printing numbers from 1 to 5 using a do-while loop:

int i = 1;

do
{
    std::cout << i << " ";
    i++;
} while (i <= 5);

// Output: 1 2 3 4 5

For loop are used when you know the number of iterations in advance. They consist of an initialization, a condition for continuation, and an iteration statement. The loop iterates over a range of values or a collection, incrementing or decrementing a counter variable with each iteration.

Here's an example of printing numbers from 1 to 5:

for (int i = 1; i <= 5; i++)
{
    std::cout << i << " ";
}

// Output: 1 2 3 4 5

Foreach loop are designed to iterate over collections or sequences of elements. They automatically handle the iteration logic, allowing you to process each element without managing an explicit index or counter. The loop iterates over each element in the collection until all elements have been processed.

Here's an example of printing each character of a string:

std::string message = "Hello";

for (char c : message)
{
    std::cout << c << " ";
}

// Output: H e l l o

In summary:

The terms immutable and mutable refer to the state of an object or variable and whether it can be changed after its creation. Understanding the difference between immutable and mutable objects is essential in programming as it affects how data is manipulated and shared within the code.

In C++, the mutable keyword is used to modify the behavior of a class member when the class itself is declared as const. When a class member is marked as mutable, it can be modified even when the object is considered constant.

When you declare a class member as const, it means that the member cannot be modified once the object is created. However, there are scenarios where you may want to allow certain members to be modified even in a const object. This is where the mutable keyword comes into play. By using mutable keyword, you can change a const class member and alter the value.

Usage of mutable for variables:

class MyClass
{
public:
    MyClass(int value) : constantValue(value) {}

    void IncrementValue() const
    {
        mutableValue++; // Modifying the mutable member inside a const member function
    }

    // This function is const and cannot modify constantValue
    int GetConstantValue() const { return constantValue; }

    // This function is const, but mutableValue can still be modified.
    int GetMutableValue() const { return mutableValue; }

private:
    const int constantValue; // Regular constant member
    mutable int mutableValue; // Mutable member
};

When to use mutable keyword:

The mutable keyword is used in situations where a class member maintains a state that should be allowed to change even in a const object. Common use cases for mutable include caching and lazily initializing data. By making certain members mutable, you can improve performance in specific scenarios without sacrificing the const-correctness of your class.

[!WARNING] While mutable can be useful, it should be used judiciously. Modifying mutable members inside const functions can lead to unexpected behavior and make the code harder to reason about. Ensure that the state being modified using mutable doesn't affect the logical constness of the class or lead to thread-safety issues.

When a member variable is declared as const, it means that its value cannot be changed after it is initialized. This makes the member immutable, and any attempt to modify its value will result in a compilation error.

The const keyword is used in C++ to declare a constant variable, which means its value cannot be changed once it is assigned. When applied to member functions, it indicates that the function will not modify the state of the object it is called on (i.e., it won't modify member variables unless they are explicitly marked as mutable). This allows the compiler to enforce immutability and provides additional safety guarantees in the code.

Usage of const for variables:

const int immutableValue = 10; // Immutable variable
// immutableValue = 20; // Error: Cannot modify an immutable variable

In programming, try-catch is a mechanism used for error handling and exception handling. It allows you to write code that can handle potential errors or exceptions that may occur during the program's execution, preventing crashes or data corruption.

In C++, the try and catch blocks are used for implementing this mechanism. Here's how it works:

1. try: You place the code that might throw an exception inside a try block. If an exception occurs within this block, the program will immediately jump to the nearest matching catch block.

2. catch: The catch block is used to catch and handle the exceptions thrown in the try block. It specifies the type of exception it can catch. If an exception of that type is thrown, the code within the catch block will be executed.

Here's a simple example in C++:

try
{
    int numA = 5;
    int numB = 0;
    int result = numA / numB;
}
catch (const char* errorMessage)
{
    // Caught "Floating point exception"
}

Using try-catch blocks allows you to handle exceptional situations gracefully, providing error messages to users or logging errors for debugging, instead of crashing or corrupting the program's data. It helps in making your programs more robust and user-friendly.

Casting, in the context of programming languages, refers to the conversion of one data type into another. It allows you to change the interpretation or representation of a variable or object, which can be useful in various situations.

This is the most basic and straightforward form of casting. It is performed using the (type) syntax and works for converting between related types, like integer to float or vice versa. However, it may not be safe in some situations, so you need to be cautious when using it.

Example:

int num1 = 10;
double num2 = static_cast<double>(num1); // Static cast from int to double

This is used to add or remove the const qualifier from a variable. It allows you to modify the constness of a variable.

Example:

const int x = 5;
const_cast<int&>(x) = 10; // Const cast to remove const and modify the value of x

This is primarily used for casting pointers or references to objects in a class hierarchy. It is particularly useful when working with polymorphic classes. Dynamic casting checks the validity of the cast at runtime and returns a null pointer if the cast is not valid.

Example:

class BaseClass { /* ... */ };
class DerivedClass : public BaseClass { /* ... */ };

BaseClass* basePtr = new DerivedClass;
DerivedClass* derivedPtr = dynamic_cast<DerivedClass*>(basePtr); // Dynamic cast from BaseClass to DerivedClass

This is primarily used to convert one pointer or reference type to another, regardless of their unrelated types. It is a low-level and potentially unsafe casting operation that allows developers to treat the underlying binary representation of a pointer as a different type. Unlike static_cast, reinterpret_cast doesn't perform any type checking or conversions, and it's up to the programmer to ensure the correctness of the cast.

Example:

result_type = reinterpret_cast<result_type>(expression);

Inlining is a compiler optimization technique used to improve the performance of code by inserting the body of a function directly at the call site, eliminating the overhead of function calls. It reduces the execution time by avoiding the function call stack setup and cleanup.

In C++, you can use the inline keyword to suggest to the compiler that a function should be inlined. For example:

inline int Add(int a, int b) { return a + b; }

The inline keyword is a hint to the compiler, and the actual decision of whether to inline a function is made by the compiler. It might choose not to inline a function if it is too large or too complex.

The __forceinline keyword is used to force the compiler to inline a function, regardless of its size or complexity. It overrides the compiler's normal inlining heuristics and ensures that the function is always inlined wherever it is called.

Here's an example of how __forceinline can be used:

__forceinline int Multiply(int a, int b) { return a * b; }

When choosing between using a macro or a function for inlining, it is generally recommended to use functions with the inline keyword. Functions are more type-safe and have better debugging support compared to macros. Macros are simple textual replacements and can lead to unexpected behavior or issues if not used carefully.

Using inline functions offers a good balance between performance and maintainability. They provide the benefits of inlining without sacrificing the advantages of type-checking and debugging support that functions offer. However, keep in mind that the inline keyword is just a hint to the compiler, and it may or may not inline the function depending on the specific context and compiler optimizations.

In programming languages, a namespace is a feature that allows you to organize code elements (such as variables, functions, classes) into distinct named scopes to avoid name collisions and improve code organization.

In C++, you can use namespaces to group related code together and avoid naming conflicts. Here's how you can define and use a namespace in C++:

// Defining a namespace
namespace MyNamespace
{
    int add(int a, int b) { return a + b; }
}

int result = MyNamespace::add(3, 5);

Namespaces are particularly helpful when you are working with multiple libraries or modules, each with its own set of classes and functions. By placing them in separate namespaces, you can avoid naming conflicts when using elements from different libraries.

For example, consider two libraries that both define a class called Vector. Without namespaces, including both libraries in the same project could lead to naming conflicts. However, by placing each Vector class in its own namespace, such as Library1::Vector and Library2::Vector, you can use them without conflicts.

#include <Library1/Vector.h>
#include <Library2/Vector.h>

Library1::Vector vec1;
Library2::Vector vec2;
// Use vec1 and vec2 without conflicts

[!WARNING] Unreal Engine doesn't support namespaces with UHT⁶.

In programming languages, static members are class members (variables or functions) that belong to the class itself rather than individual objects of the class. They are shared among all instances (objects) of the class and are independent of any specific object's state.

In C++, you can use the static keyword to define static members in a class. Here's how you can use static members in C++ code:

class MyClass
{
public:
    static int staticVariable; // Declaration of a static variable
    static void staticFunction(); // Declaration of a static function
};

// Definition of the static variable
int MyClass::staticVariable = 0;

// Definition of the static function
void MyClass::staticFunction()
{
    // Function implementation
}

Static variables and functions are accessed using the class name followed by the scope resolution operator ::. Since static members are shared across all instances of the class, they do not require an object to be accessed.

Here's how you can use static members in your code:

MyClass::staticVariable = 10; // Accessing static variable
MyClass::staticFunction(); // Calling static function

Static members are commonly used for class-level data and utility functions that do not rely on object-specific state. They are particularly useful when you want to maintain a single instance of a variable shared among all objects of the class, or when you need a common function that does not depend on the specific object's data.

In C++, the auto keyword is used for type inference, allowing the compiler to deduce the data type of a variable automatically based on its initialization value (similar to var keyword in C#⁴). It was introduced in C++11 as part of the modern C++ features.

Here's how you can use the auto keyword:

auto variable = 42; // Compiler will deduce the type of 'variable' as int
auto name = "John"; // Compiler will deduce the type of 'name' as const char*
auto pi = 3.14; // Compiler will deduce the type of 'pi' as double

The auto keyword is especially useful when dealing with complex data types or when the type is long and cumbersome to write explicitly. It can also simplify code maintenance since you don't need to update the type declaration if the initialization value changes.

Using the auto keyword for return function values can be a double-edged sword. While it can make the code more concise and reduce the need to explicitly specify return types, it can also make the code less readable and harder to understand, especially when the function's logic is complex.

auto player = GetPlayer(); // Bad

Player* player = GetPlayer(); // Good

The power of polymorphism lies in the ability to use a base class pointer or reference to refer to objects of derived classes. This allows you to write code that operates on the base class, without needing to know the specific derived class. During runtime, the appropriate version of the overridden method in the derived class will be invoked, based on the actual type of the object being referred to.

Polymorphism allows you to write more flexible and reusable code by treating objects based on their common behavior, rather than their specific type. It promotes code extensibility and enhances the ability to work with a variety of objects in a unified way.

In C++, operators are symbols or keywords² used to perform various operations on data, such as arithmetic operations, logical operations, assignment, comparison, and more. They enable concise and expressive manipulation of variables and values.

Operator Overloading is a feature in C++ that allows you to redefine the behavior of an operator for user-defined types. It enables you to provide a specific implementation for an operator based on the operands' types, allowing custom operations to be performed.

Here's an example of overloading the greater-than-or-equal-to >= operator in C++:

class MyClass
{
public:
    int value;

    MyClass(int val) : value(val) {}

    bool operator>=(const MyClass& other) const
    {
        return value >= other.value;
    }
};

By overloading operators, you can define custom behavior for how objects of a class interact with the corresponding operator. This provides flexibility and allows you to use familiar syntax and semantics for user-defined types, making the code more intuitive and expressive.

Operator overloading is not limited to comparison operators; you can also overload arithmetic operators +, -, * and / assignment operators =, logical operators &&, ||, and more. Overloading operators helps create more natural and concise code, improves code readability, and enhances the usability of user-defined types.

Function overloading is a feature in C++ that allows you to define multiple functions with the same name but different parameters.

It enables you to create functions that perform similar operations but on different data types or with different parameter sets.

void TakeDamage(int DamageAmount)
{
    // Logic...
}

void TakeDamage(float DamageAmount)
{
    // Logic...
}

void TakeDamage(double DamageAmount)
{
    // Logic...
}

When you call an overloaded function, the compiler determines the appropriate function to invoke based on the arguments passed.

TakeDamage(10); // Calling function with integer parameter
TakeDamage(11.1f); // Calling function with float parameter
TakeDamage(12.25052651); // Calling function with double parameter

With function overloading, it provides several benefits, including:

[!WARNING] Unreal Engine doesn't support function overloading with UHT⁷. Meaning, you can't expose to Blueprint.

In object-oriented programming (OOP), a virtual function is a function declared in a base class that can be overridden in derived classes. It allows you to provide a common interface in the base class while allowing different implementations in the derived classes.

When a function is declared as virtual in the base class, it indicates that the function can be overridden by derived classes. This means that the derived class can provide its own implementation of the function, tailored to its specific needs.

Here's an example in C++ to illustrate the concept of virtual functions:

class Shape
{
public:
    virtual void Draw()
    {
        // Common implementation for all shapes
    }
};

class Circle : public Shape
{
public:
    void Draw() override
    {
        // Override implementation
    }
};

class Rectangle : public Shape
{
public:
    void Draw() override
    {
        // Override implementation
    }
};

The key aspect of the virtual function is that the appropriate implementation to be executed is determined at runtime, based on the actual type of the object being referred to. This is called dynamic dispatch or late binding.

Virtual functions are useful when you want to define a common interface in a base class but allow derived classes to provide their own implementations based on their specific behaviors. It enables polymorphism, allowing objects of different derived classes to be treated uniformly through a base class pointer or reference.

Using virtual functions, you can write code that works with objects based on their common interface, without needing to know their specific types. This promotes code extensibility and flexibility, as new derived classes can be added without modifying the existing code that uses the base class interface.

Generic Programming is a programming paradigm that focuses on writing reusable code by abstracting away specific types and working with generic types that can be instantiated with various concrete types. It allows programmers to create functions, classes, and algorithms that can operate on different data types without requiring code duplication.

In C++, the template keyword² is used to implement generic programming through templates. Templates allow you to define functions or classes that can be instantiated with different types. They provide a powerful mechanism for code reuse and flexibility.

Here is a video about templates in C++ by Cazz

Here is an example:

template <typename T>
T add(T a, T b)
{
    return a + b;
}

int result1 = add(5, 10);        // Instantiated as add<int>(5, 10)
double result2 = add(3.5, 2.7);  // Instantiated as add<double>(3.5, 2.7)

Recursion is a programming technique where a function calls itself to solve a problem. In simpler terms, it's a process of solving a larger problem by breaking it down into smaller, more manageable subproblems.

Here's an example:

int factorial(int n)
{
    if (n == 0 || n == 1)
        return 1;
    else
        return n * factorial(n - 1); // Calling the function again (recursion)
}

[!WARNING] While recursion can be powerful, it's essential to use it judiciously. Recursive solutions may consume more memory and time compared to iterative solutions for certain problems. Additionally, recursive functions can lead to stack overflow errors if not implemented correctly or when dealing with very large inputs.

The linker is a program that makes executable files for your project, in order to run the .exe file.

The linker's job is to resolve undefined symbols. If the linker cannot resolve the issue, it then gives you a linkage error, and you have to resolve it instead.

You can also flag the linker to export some extra debugging files or so called .pdb (Program Debug Database) file. These files can be helpful for other programmers, as they contain extra information (such as comments and other debugging information).

The linker can be configured to accept either static library or dynamic library when creating your project.

When you compile, you have the options to compile the source code into a .lib file. The .lib file can then be read by the linker, which include all files, when executing a compilation.

[!NOTE] Because static library is merged into .exe file, it increases the final size of .exe file.

Use static library if you want to access content statically and have compiling errors to ensure that the code can be executed.

When you compile, you have the options to compile the source code into a .dll file. The .dll file can then be read by the .exe file at runtime.

There are major problems when developing a project that uses .dll files. Not only, do you have to make sure that all the files are correct versions but also exists and can be executed correctly.

To access contents of .dll file, you have to use either __declspec(dllimport) or __declspec(dllexport).

• Use dllimport for importing functions and variables.
• Use dllexport for exporting functions and variables.

[!IMPORTANT] __declspec(dllimport) is required for data imports (such as member variables).

// Example of the dllimport and dllexport class attributes
__declspec( dllimport ) int i;
__declspec( dllexport ) void func();

// To make the code more readable, use macro definitions!
#define DllImport   __declspec( dllimport )
#define DllExport   __declspec( dllexport )

DllExport void func();
DllExport int i = 10;
DllImport int j;
DllExport int n;

You can read more about it from Microsoft Learn.

[!NOTE] Because the dynamic library is loaded at runtime, it's then loaded into RAM memory, instead of being statically compiled into the .exe file. This can take up more memory space. However, if the code use repeatably, throughout other programs, then memory space is greatly improved.

[!WARNING] Using .dll also means that the library stores compiled code directly into the file. It also may contain small extra metadata about the code (debugging symbols, comments and etc). This means, the code is unsecure and more accessible for a reverse engineer to use it and modify it. C# require storing debug symbol information (for the reflection system), hence why it is easier to reverse engineer than C++ code. While you have the options to enable debug symbol information in C++. But is not automatically turn on by default.

[!IMPORTANT] There is no way to guarantee to stop a reverse engineer to look at the compiled code or modify the game unless you run a program, which check the game's content as a hash data and compare to cloud stored version (this would take long time, but would be a safe approach).

When calling a function, you can trace the code execution in .dll file (with the assembly language viewer), thus understanding the function intention and then either replicated the function or modify it.

Most devs are most likely to focusing on the multiplayer aspect. Such as client/server prediction and assumptions. My suggestion, is to never store any password, API keys or any important information inside the game's source code.

If you need to store important information, use strip functionality. To make sure the final product of your game, doesn't contain any secret information. Also, hash your password and keys (MD5 and SHA2 methods).

Use dynamic library if you want to access content at runtime and share the code between different programs.

In C++, a lambda expression, often referred to as a lambda function or lambda, is an anonymous function that you can define inline. It provides a convenient way to create small, inline functions without the need for explicitly declaring a separate function.

Here is a video by The Cherno about Lambdas in C++.

The basic syntax of a lambda expression in C++ is as follows:

[capture_list](parameters) -> return_type
{
    // Function body
    // Statements
    // Return statement
};

Here's how a lambda expression works:

• 1. Capture List: The capture list, denoted by [ ], specifies variables from the enclosing scope that the lambda function can access. It can capture variables by value ([=]) or by reference ([&]). You can also specify individual variables to capture explicitly.

• 2. Parameters: The parameters represent the input arguments to the lambda function, similar to regular function parameters.

• 3. Return Type: The return type, denoted by ->, specifies the type of the value returned by the lambda function. If the return type is omitted, it is deduced by the compiler.

• 4. Function Body: The function body contains the statements and logic of the lambda function. It can include any valid C++ code, such as variable declarations, control flow statements, and computations.

Here's an example of how to use lambda in action:

// Lambda function that takes two integers as parameters and returns their sum.
auto sum = [](int a, int b) { return a + b; };

int num1 = 5;
int num2 = 10;

// Using the lambda to calculate the sum of num1 and num2.
int result = sum(num1, num2);

Binary code is a system of representing data and instructions using a two-symbol system, typically 0 and 1. It is the fundamental language that computers understand and use internally to process information. Each 0 or 1 is called a "bit" (short for binary digit), and a group of 8 bits is called a "byte".

Logic gates are fundamental building blocks of digital circuits, responsible for performing logical operations on binary inputs to produce binary outputs. These gates form the basis of digital systems, including computers and other electronic devices. Each logic gate implements a specific Boolean function, which takes one or more binary inputs and produces an output based on a defined truth table.

There are several types of logic gates, each representing a different fundamental logical operation:

1. AND Gate: This gate produces an output of 1 (or "high") only when both of its input signals are 1. Otherwise, the output is 0 (or "low"). It behaves like the logical "AND" operation.

2. OR Gate: The OR gate produces an output of 1 if at least one of its input signals is 1. It produces an output of 0 only when both inputs are 0. It behaves like the logical "OR" operation.

3. NOT Gate: Also known as an inverter, this gate has a single input and produces the opposite value as its output. If the input is 1, the output is 0, and vice versa. It behaves like the logical "NOT" operation.

4. NAND Gate: The NAND gate is a combination of an AND gate followed by a NOT gate. It produces the opposite output of an AND gate: it gives a 0 output when both inputs are 1, and a 1 output otherwise.

5. NOR Gate: Similar to the NAND gate, the NOR gate combines an OR gate with a NOT gate. It produces the opposite output of an OR gate: it gives a 1 output only when both inputs are 0.

6. XOR Gate: The XOR (exclusive OR) gate produces a 1 output when the number of 1 inputs is odd. If the number of 1 inputs is even, the output is 0.

7. XNOR Gate: The XNOR (exclusive NOR) gate is the complement of the XOR gate. It produces a 1 output when the number of 1 inputs is even, and a 0 output otherwise.

Hexadecimal (hex) is a base-16 numbering system that is commonly used in computers to represent and manipulate binary data in a more human-readable and compact format. In the hexadecimal system, each digit represents a value from 0 to 15, making it a convenient way to represent binary data.

In the decimal (base-10) numbering system, we use ten symbols (0 to 9) to represent numbers. Similarly, in hexadecimal, we use sixteen symbols (0 to 9 and A to F) to represent values. The symbols A to F represent the decimal values 10 to 15, respectively.

Here is a comparison of decimal and hexadecimal representations:

As an example, 255 in hexadecimal would be FF.

Bitwise Operators in C++ are used to perform bitwise operations on individual bits of data type. These operators directly manipulate the binary representation of data type at the bit level.

Bitwise operations can bring performance benefits in certain situations because they operate at a low level, dealing directly with binary representations. This can make certain operations faster and more memory-efficient compared to other higher-level approaches.

Here's a table listing all the bitwise operators in C++ and their functionality:

Here's an example:

int a = 5;    // Binary representation: 0000 0101
int b = 3;    // Binary representation: 0000 0011

int bitwiseAnd = a & b;     // Binary representation: 0000 0001 (1 in decimal)
int bitwiseOr = a | b;      // Binary representation: 0000 0111 (7 in decimal)
int bitwiseXor = a ^ b;     // Binary representation: 0000 0110 (6 in decimal)
int bitwiseNotA = ~a;       // Binary representation: 1111 1010 (-6 in decimal)
int leftShift = a << 2;     // Binary representation: 0001 0100 (20 in decimal)
int rightShift = a >> 1;    // Binary representation: 0000 0010 (2 in decimal)

In programming languages, stack and heap are two different areas of memory used for memory allocation. They serve distinct purposes and have different characteristics.

In C++, you have the flexibility to choose between stack and heap memory allocation based on your program's requirements. Stack memory is typically used for most local variables and function calls, providing automatic memory management and efficient access. On the other hand, heap memory is used when dynamic memory allocation is needed, allowing you to control the lifetime of objects and manage more extensive data structures.

C++ provides features like dynamic memory allocation with new and delete operators, allowing you to allocate memory on the heap explicitly. However, it is important to manage heap memory carefully to avoid memory leaks and unnecessary memory consumption.

• Stack memory is a region of memory used for automatic memory allocation.
• It is managed by the compiler and follows a "last-in, first-out" (LIFO) data structure.
• Stack memory is typically used for storing local variables, function call frames, and other short-lived data.
• Memory allocation and deallocation in the stack are handled implicitly by the compiler.
• Stack memory is fast and efficient but limited in size.
• Variables allocated on the stack have automatic storage duration and are deallocated automatically when they go out of scope.

• Heap memory is a region of memory used for dynamic memory allocation.
• It allows for manual control over memory allocation and deallocation.
• Memory on the heap can be allocated and deallocated at runtime using functions like new and delete in C++.
• Heap memory is typically used for storing objects with longer lifetimes or for data structures that need dynamic resizing.
• Memory allocated on the heap needs to be explicitly deallocated to avoid memory leaks.
• Heap memory is slower than stack memory due to dynamic allocation and deallocation operations.
• The size of heap memory is typically much larger than the stack, but its allocation and deallocation require manual management.

[!WARNING] Don't use new and delete operators on UObject classes, as this would interfere with Unreal's garbage collection system.

Design patterns are reusable solutions to common programming problems that have been proven effective over time. They provide guidelines and templates for structuring code, promoting best practices, and improving software design.

Here are a few notable design patterns:

SOLID or Single responsibility principle, Open-closed principle, Liskov substitution principle, Interface segregation principle, and Dependency inversion principle. SOLID is a mnemonic acronym for five design principles designed to make software designs more flexible, understandable, and maintainable.

The KISS principle emphasizes simplicity and avoiding unnecessary complexity in software design. It encourages keeping code, algorithms, and systems as simple as possible to enhance readability, maintainability, and reduce the likelihood of errors.

The Singleton pattern ensures that only one instance of a class is created and provides a global point of access to that instance. It is useful in scenarios where you need to control access to a shared resource or want to limit the instantiation of a class to a single object.

The Observer pattern establishes a one-to-many dependency between objects. It allows multiple observer objects (listeners) to be notified and updated automatically when the observed object (subject) undergoes a change in state. This pattern is widely used in event-driven systems or scenarios requiring loose coupling between objects.

The Factory pattern provides an interface for creating objects without exposing the creation logic to the client. It centralizes object creation, allowing clients to use the factory interface to create objects based on specific criteria or conditions. This pattern promotes flexibility, decoupling, and abstraction in object creation.

The Strategy pattern defines a family of algorithms and encapsulates each algorithm as a separate class. It allows clients to dynamically choose and switch between different algorithms at runtime. This pattern enables code reuse, promotes separation of concerns, and facilitates the "Open-Closed Principle" by allowing new algorithms to be added without modifying existing code.

MVC is an architectural design pattern commonly used in user interface development. It separates an application into three interconnected components: the Model (data and business logic), the View (presentation and user interface), and the Controller (handles user input and updates the model). MVC promotes code organization, maintainability, and modularity.

An array is a collection of elements stored in contiguous memory locations. It allows accessing elements using an index, making it efficient for random access. However, its size is fixed during initialization.

Here's an example:

#include <array>

// Defining an array
std::array<int, 5> myArray = {1, 2, 3, 4, 5};

A list is a linear data structure that supports fast insertion and deletion at any position. It does not provide random access but is efficient for frequent insertions and removals.

Here's an example:

#include <list>

// Defining an list
std::list<int> myList = {1, 2, 3, 4, 5};

myList.push_back(6);
myList.push_front(0);

A queue is a linear data structure that follows the First-In-First-Out (FIFO) principle. Elements are added to the back (enqueue) and removed from the front (dequeue).

Here's an example:

#include <queue>

// Defining an list
std::queue<int> myQueue;

myQueue.push(1);
myQueue.push(2);
myQueue.push(3);

A hash set is a collection of unique elements, and it uses hashing to achieve fast insertion, deletion, and lookup operations.

Here's an example:

#include <unordered_set>

// Defining an list
std::unordered_set<int> myHashSet = {1, 2, 3, 4, 5};

myHashSet.insert(6);

A dictionary, also known as a map, is a collection of key-value pairs, where each key is unique. It provides fast access to values based on their keys.

Here's an example:

#include <map>

// Defining an list
std::map<std::string, int> myDictionary;

myDictionary["apple"] = 5;
myDictionary["banana"] = 3;
myDictionary["orange"] = 8;

A linked list is a linear data structure where elements (nodes) are connected via pointers. It supports efficient insertion and deletion but requires more memory compared to arrays.

[!NOTE] Linked list structure doesn't exist in C++ standard library.

Here's an example:

struct Node
{
    int data;
    Node* next;
};

int main()
{
    Node* head = nullptr;
    Node* second = nullptr;
    Node* third = nullptr;

    head = new Node();
    second = new Node();
    third = new Node();

    head->data = 1;
    head->next = second;

    second->data = 2;
    second->next = third;

    third->data = 3;
    third->next = nullptr;

    Node* current = head;

    while (current != nullptr)
    {
        std::cout << current->data << " ";
        current = current->next;
    }

    std::cout << std::endl;

    delete head;
    delete second;
    delete third;

    return 0;
}

Time complexity is a measure of how the runtime of an algorithm grows with the size of the input data. It helps us understand how efficient an algorithm is and how it will scale when dealing with larger datasets.

Here is a graph of Time Complexity:

An algorithm has constant time complexity if its runtime does not depend on the size of the input data. It performs the same number of operations regardless of the input size.

Here's an example:

#include <iostream>

void constantTimeExample(int num)
{
    std::cout << "This is a constant time example: " << num << std::endl;
}

int main()
{
    int num = 42;

    constantTimeExample(num);

    return 0;
}

An algorithm has logarithmic time complexity if its runtime grows logarithmically with the size of the input. It divides the input data into smaller portions and discards a significant portion at each step.

Here's an example:

#include <iostream>

int binarySearch(int arr[], int size, int target)
{
    int left = 0;
    int right = size - 1;

    while (left <= right)
    {
        int mid = left + (right - left) / 2;

        if (arr[mid] == target)
            return mid;
        else if (arr[mid] < target)
            left = mid + 1;
        else
            right = mid - 1;
    }

    return -1;
}

int main()
{
    int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int target = 7;
    int size = sizeof(arr) / sizeof(arr[0]);

    int result = binarySearch(arr, size, target);
    std::cout << "Element found at index: " << result << std::endl;

    return 0;
}

An algorithm has linear time complexity if its runtime grows linearly with the size of the input data. It performs an operation for each element in the input.

Here's an example:

#include <iostream>

void linearTimeExample(int arr[], int size)
{
    for (int i = 0; i < size; i++)
    {
        std::cout << arr[i] << " ";
    }

    std::cout << std::endl;
}

int main()
{
    int arr[] = {1, 2, 3, 4, 5};
    int size = sizeof(arr) / sizeof(arr[0]);

    linearTimeExample(arr, size);

    return 0;
}

An algorithm has quadratic time complexity if its runtime grows with the square of the input size. It often involves nested loops, leading to multiple iterations over the input data.

Here's an example:

#include <iostream>

void quadraticTimeExample(int arr[], int size)
{
    for (int i = 0; i < size; i++)
    {
        for (int j = 0; j < size; j++)
        {
            std::cout << arr[i] * arr[j] << " ";
        }
    }

    std::cout << std::endl;
}

int main()
{
    int arr[] = {1, 2, 3, 4, 5};
    int size = sizeof(arr) / sizeof(arr[0]);

    quadraticTimeExample(arr, size);

    return 0;
}

An algorithm has exponential time complexity if its runtime grows exponentially with the size of the input data. It performs repeated operations that double with each increase in input size.

Here's an example:

#include <iostream>

int fibonacci(int n)
{
    if (n <= 1)
        return n;

    return fibonacci(n - 1) + fibonacci(n - 2);
}

int main()
{
    int n = 5;

    std::cout << "Fibonacci of " << n << " is: " << fibonacci(n) << std::endl;

    return 0;
}

An algorithm has factorial time complexity if its runtime grows with the factorial of the input size. It is one of the slowest-growing time complexities and should be avoided for larger datasets.

Here's an example:

#include <iostream>

int factorial(int n)
{
    if (n == 0)
        return 1;

    return n * factorial(n - 1);
}

int main()
{
    int n = 5;

    std::cout << "Factorial of " << n << " is: " << factorial(n) << std::endl;

    return 0;
}

• AActor

  • A base class for the every object placed in the world. It's an UObject that usually contains other UObjects specialized to be part of an actor - this what we call components.
  • This class contains a basic functionality to operate on the "object placed in the world".
  • AActor itself doesn't have a transform (i.e. position in the world), it depends on the transform of the root component.
  • Functions:
    • BeginPlay() - Called when the level starts ticking, only during actual gameplay.
    • Tick(float DeltaSeconds) - Update function, called every frame on Actor.
    • EndPlay(const EEndPlayReason::Type EndPlayReason) - Whenever actor is being removed from a level
    • SetLifeSpan(float InLifespan) - Set the lifespan of actor.
    • Destroy(bool bNetForce, bool bShouldModifyLevel) - Destroy actor.

• APawn

  • Represents a pawn in the game world. A pawn is an entity that can be controlled by the player or by AI, and can move and interact with the game world.
  • APawn provides basic movement and input handling functionality, as well as collision detection and physics simulation.

• AHUD

  • Represents the heads-up display (HUD) in the game. The HUD displays important information to the player, such as health and ammunition levels, as well as providing visual feedback for game events such as damage or power-up pickups.
  • AHUD can be customized to display different types of information and to use different visual styles.

• ACharacter

  • Represents a playable character in the game world. ACharacter is a subclass of APawn and provides additional functionality specific to player-controlled characters, such as animation and movement controls, camera handling, and input management.
  • ACharacter can be used as a base class for player characters, enemies, and other types of characters in the game.

• AController

  • Represents a controller in the game, which can be used to control a APawn or ACharacter.
  • AController provides input handling and navigation functionality, allowing players or AI to move and interact with the game world. AController can be used to implement different types of control schemes, such as first-person or third-person controls, and can be customized to support different input devices and control configurations.

• UActorComponent

  • A base class for every object placed inside AActor.
  • Used for components contains only the logic, i.e. UMovementComponent or USceneComponent.
  • UActorComponent doesn't appear in the world.
  • Functions:
    • BeginPlay() - Begins Play for component.
    • TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction) - Function called every frame on ActorComponent.
    • EndPlay(const EEndPlayReason::Type EndPlayReason) - Ends gameplay for component.

• UMovementComponent

  • Provides movement functionality to an actor in the game world. UMovementComponent can be used to implement a variety of movement types, such as flying, walking, swimming, or sliding.
  • UMovementComponent handles physics simulation and collision detection for the actor, and can be customized to provide different movement behaviors.

• USceneComponent

  • A base class for every component which actually appears in the world, it has a transform evaluated every frame.
  • It's used by components that need to know its place in the world to run the logic, i.e. UAudioComponnent, UCameraComponent.
  • Component of this class isn't rendered or doesn't collide with anything.

• UPrimitiveComponent

  • And this finally the base class for all components representing any sort of geometry.
  • These components are rendered and tested for collision.

• USubsystem

  • Provide services or functionality that can be used by other parts of the engine or by games built with the engine.
  • Examples of subsystems in Unreal Engine include the rendering subsystem, the physics subsystem, and the input subsystem.
  • Subsystems are responsible for initializing, updating, and shutting down their associated services, and can be used to customize or extend engine functionality as needed.
  • 4 types of subsystems
    • Engine (Engine lifetime)
    • Editor (Editor lifetime)
    • GameInstance (Game instance lifetime)
    • LocalPlayer (share lifetime of local players)

• UBlueprintFunctionLibrary

  • Allows you to create custom static functions that can be used in Blueprint graphs. These functions can be called from any Blueprint and can perform complex calculations or operations that are not easily achievable with standard Blueprint nodes.

• UEngine, UEditorEngine and UGameEngine

  • Manages the main loop of the engine, handles rendering, input, audio, networking, and more.
  • UEditorEngine is used to manage the editor, which includes all of the tools and systems needed to create and edit levels, assets, and other game content.
  • UGameEngine is used to manage the game itself, which includes gameplay mechanics, AI, physics, rendering, and so on.

• UGameViewportClient

  • Manages the viewport and input handling for the game. It is responsible for rendering the game's output to the screen, handling user input, and managing the game's display settings.

• ULocalPlayer

  • Manages the player's input, screen rendering, and other local gameplay-related tasks. ULocalPlayer is often used in conjunction with other classes, such as APlayerController, to manage local player interactions with the game.

• UWorld

  • Represents a single instance of a level or map. It contains all the actors, components, and other objects that are present in the level, as well as information about the level's environment and physics settings.
  • Functions:
    • SpawnActor() and SpawnActorDeferred() (deferred allow you to set actor properties before it's spawned into the world.)

• ULevel

  • Represents a level in the game world that contains actors, geometry, lighting, and other assets.

• UGameInstance

  • Represents the game instance, which is created when the game starts up and persists for the duration of the game.
  • The game instance can be used to manage persistent data and game state across levels, as well as to perform global game operations such as handling networking, input, and other system-level tasks.

• AGameMode

  • Defines the rules and mechanics of a particular game mode, such as deathmatch or capture the flag.
  • Can be used to control game behavior, spawn actors, manage player input and game state, and perform other game-specific tasks.
  • Each level in a game can have its own AGameMode, allowing for different game modes to be used in different levels.

• AGameState

  • Represents the state of the game during play. AGameState can be used to store and manage data that is specific to a particular game, such as player scores, game timers, and other game state information.
  • AGameState can also be used to synchronize game state across multiple clients in a networked game, ensuring that all players have an accurate view of the game world.

• UUserWidget

  • Represents a user interface (UI) widget in the game. UUserWidget provides a flexible framework for creating UI elements such as buttons, text fields, and images, and can be customized to implement complex UI behaviors such as animations, transitions, and data binding.
  • UUserWidget can be used to create menus, health bars, inventory screens, and other UI elements in the game.

• UPrimaryDataAsset

  • Represents a primary data asset in the engine. A primary data asset is a piece of game content that is created in the Unreal Editor, such as a mesh, texture, sound, or level. UPrimaryDataAsset provides a base class for creating custom data assets that can be loaded and used by the game at runtime.
  • UPrimaryDataAsset can be used to manage and organize game content, and can be customized to provide additional functionality such as data validation and metadata management.

• USoundBase

  • Represents a sound or audio asset in the engine. ASoundBase can be used to play sound effects, music, and other audio in the game world. ASoundBase provides a number of features for controlling the playback of audio, including volume, pitch, and spatialization effects such as 3D sound and reverb.

• UMaterial

  • Represents a material which defines the visual appearance of objects in the game world.

• UTexture

  • Represents an image or texture that can be used in the engine for various purposes such as materials or user interface elements.

In C++ native, you write a character by using char data type:

char myChar = 'a';

In Unreal, there are couples or char data types:

• ANSICHAR - An ANSI character. Normally a signed type.
• WIDECHAR - A wide character. Normally a signed type.
• TCHAR - Either ANSICHAR or WIDECHAR, depending on whether the platform supports wide characters or the requirements of the licensee.
• UTF8CHAR - An 8-bit character containing a UTF8 (Unicode, 8-bit, variable-width) code unit.
• UTF16CHAR - An 16-bit character containing a UTF16 (Unicode, 16-bit, variable-width) code unit.
• UTF32CHAR - An 32-bit character containing a UTF32 (Unicode, 32-bit, fixed-width) code unit.

When working with Unreal, you are typical going to work with TCHAR data type as a char type.

Define TCHAR:

TCHAR MyChar = 'A';

And to use the extra functions for these data types, you must use:

• FChar for TCHAR
• FCharWide for WIDECHAR
• FCharAnsi for ANSICHAR

Here's a list of functions, you can access from FChar:

• ToUpper() - Only converts ASCII characters.
• ToLower() - Only converts ASCII characters.
• IsUpper() - Returns a boolean if the character is an uppercase letter.
• IsLower() - Returns a boolean if the character is a lowercase letter.
• IsAlpha() - Returns a boolean if the character is an alphabetic letter.
• IsGraph() - Returns a boolean if the character is a graphic character (printable and not a space).
• IsPrint() - Returns a boolean if the character is a printable character (including whitespace).
• IsPunct() - Returns a boolean if the character is a punctuation character (neither alphanumeric nor a whitespace).
• IsAlnum() - Returns a boolean if the character is an alphanumeric character (a letter or a digit).
• IsDigit() - Returns a boolean if the character is a hexadecimal digit (0-9, a-f or A-f).
• IsHexDigit() - Returns a boolean if the character is a decimal digit (0-9).
• IsWhitespace() - Returns a boolean if the character is a whitespace character (space, tab, newline, carriage return, vertical tab or form feed).
• IsControl() - Returns a boolean if the character is a control character (non-printing).
• IsOctDigit() - Returns a boolean if the character is an octal digit (0-7).
• ConvertCharDigitToInt() - Converts a character representing a decimal digit to an integer.
• IsIdentifier() - Returns a boolean if the character is an alphanumeric or underscore character.
• IsUnderscore() - Returns a boolean if the character is an underscore.
• ToUnsigned() - Convert a character to an unsigned integer to avoid sign extension problems with signed characters smaller than int.

Include the header file:

#include "Misc/Char.h"

Here's an example, of using these functions from FChar:

TCHAR MyChar = 'a';

MyChar = FChar::ToUpper(MyChar); // MyChar: A

bool bIsDigit = FChar::IsDigit(MyChar); // false
bool bIsDigit = FChar::IsAlpha(MyChar); // true

You can read more about TCHAR on Unreal's docs.

// Unreal uses a 'b' prefix for booleans (always in lowercase).
bool bIsDead = true;

In C++ native, you write a integer by using int data type:

int health = 10;

In Unreal, you write a integer by using int32:

int32 Health = 10;

In Unreal, the availability of different integer types such as int8, int16, and int64 alongside the standard int32 provides developers with a range of options tailored to specific needs in terms of both data size and numerical range.

int8 NumberA = 0;       // -128                             ->      127
int16 NumberB = 0;      // -32,768                           ->      32,767
int32 NumberC = 0;      // -2,147,483,648                   ->      2,147,483,647
int64 NumberD = 0;      // 9,223,372,036,854,775,808        ->      9,223,372,036,854,775,807

You also have unsigned (positive-only) integers as well:

uint8 NumberA = 0;      // 0    ->      255
uint16 NumberB = 0;     // 0    ->      65,535
uint32 NumberC = 0;     // 0    ->      4,294,967,295
uint64 NumberD = 0;     // 0    ->      18,446,744,073,709,551,615

// C++ always uses 'f' or 'F' literal for defining a float variable.
float SpeedInMetersPerSecond = 5.5f;

// C++ never uses a literal for defining a double variable.
double SpeedInMetersPerSecond = 5.5;

It is generally recommended to use Unreal's typedefs, such as int32 instead of int for representing 32-bit signed integers. This is because the exact size of int is not defined by the C++ standard.

C++ implementation can define the size of a data type in bytes (sizeof(type)) to be any value, as long as:

• The expression sizeof(type) * CHAR_BIT evaluates to a number of bits high enough to contain required ranges.
• And the ordering of type is still valid (e.g. sizeof(int) <= sizeof(long)).

The CHAR_BIT is the number of bits in char. It is declared in “limits.h” header file in C++ language. It is of 8-bits per byte.

You can read more about data ranges in this section.

So, the summary data sizes would be:

You can read more in-depth about this from Alex on Stack Overflow.

Here's a full list of Unreal's data type sizes:

In Unreal Engine, instead of writing signed long long for a 64-bit integer, you can now write int64 instead. These aliases are called typedefs, which you can read more about typedef keyword in C++ docs.

You can read more about C++ typedefs in this section.

Here is a full list of Unreal Engine's typedefs:

//~ Unsigned base types.
/// An 8-bit unsigned integer.
typedef FPlatformTypes::uint8		uint8;
/// A 16-bit unsigned integer.
typedef FPlatformTypes::uint16		uint16;
/// A 32-bit unsigned integer.
typedef FPlatformTypes::uint32		uint32;
/// A 64-bit unsigned integer.
typedef FPlatformTypes::uint64		uint64;

//~ Signed base types.
/// An 8-bit signed integer.
typedef	FPlatformTypes::int8		int8;
/// A 16-bit signed integer.
typedef FPlatformTypes::int16		int16;
/// A 32-bit signed integer.
typedef FPlatformTypes::int32		int32;
/// A 64-bit signed integer.
typedef FPlatformTypes::int64		int64;

//~ Character types.
/// An ANSI character. Normally a signed type.
typedef FPlatformTypes::ANSICHAR	ANSICHAR;
/// A wide character. Normally a signed type.
typedef FPlatformTypes::WIDECHAR	WIDECHAR;
/// Either ANSICHAR or WIDECHAR, depending on whether the platform supports wide characters or the requirements of the licensee.
typedef FPlatformTypes::TCHAR		TCHAR;
/// An 8-bit character containing a UTF8 (Unicode, 8-bit, variable-width) code unit.
typedef FPlatformTypes::UTF8CHAR	UTF8CHAR;
/// A 16-bit character containing a UCS2 (Unicode, 16-bit, fixed-width) code unit, used for compatibility with 'Windows TCHAR' across multiple platforms.
typedef FPlatformTypes::CHAR16		UCS2CHAR;
/// A 16-bit character containing a UTF16 (Unicode, 16-bit, variable-width) code unit.
typedef FPlatformTypes::CHAR16		UTF16CHAR;
/// A 32-bit character containing a UTF32 (Unicode, 32-bit, fixed-width) code unit.
typedef FPlatformTypes::CHAR32		UTF32CHAR;

/// An unsigned integer the same size as a pointer
typedef FPlatformTypes::UPTRINT UPTRINT;
/// A signed integer the same size as a pointer
typedef FPlatformTypes::PTRINT PTRINT;
/// An unsigned integer the same size as a pointer, the same as UPTRINT
typedef FPlatformTypes::SIZE_T SIZE_T;
/// An integer the same size as a pointer, the same as PTRINT
typedef FPlatformTypes::SSIZE_T SSIZE_T;

/// The type of the NULL constant.
typedef FPlatformTypes::TYPE_OF_NULL	TYPE_OF_NULL;
/// The type of the C++ nullptr keyword.
typedef FPlatformTypes::TYPE_OF_NULLPTR	TYPE_OF_NULLPTR;

[!WARNING] uint16, uint32, uint64, int8, int16 and double are not supported with UHT⁶. Meaning, can't expose to Blueprint.

String in programming languages are fundamental data types used to represent and manipulate sequences of characters, such as words, sentences, or even binary data. They are extensively used in various programming tasks, including input/output operations, text processing, data serialization, and more.

In Unreal Engine, strings play a crucial role in handling text-based information within the game or application. Unreal Engine provides several string-related classes to cater to different use cases and requirements.

You can read more about string handling from the docs.

In Unreal Engine, FName is a specialized type used for identifying objects within the Unreal Engine object system. It is optimized for fast comparison and storage and is commonly used for referencing actors, components, or assets in a performance-efficient manner.

The FName class stores strings as hashed indices, making it a lightweight and fast alternative to regular strings. Because of this, FName are immutable string class.

Here's an example:

Include the header file:

#include "UObject/NameTypes.h"

Declare FName:

FName MyName = FName(TEXT("PlayerName"));

FText is a specialized string class designed for localization support in Unreal Engine. Because of this, FText are immutable string class. FText provides the ability to represent text in different languages and cultures, making it a crucial component for building multi-language games or applications.

You can read more about it on Unreal's docs.

Here's an example:

Include the header file:

#include "Internationalization/Text.h"

Declare FText from a string literal (non-localized):

// Avoid this! Since this cost more performance than initializing directly as FText.
FText NewGameText = FText::FromString(TEXT("New Game"));

To use a multi-line FText inside Unreal Editor, you can specify UPROPERTY with meta tag of Multiline:

UPROPERTY(EditAnywhere, Category = "Details", meta = (MultiLine = "true"))
FText Description;

Declare FText from INVTEXT() macro. Which creates a culture invariant FText from a string literal:

FText TooltipText = INVTEXT("Tooltip Text");

/*
    Inside Unreal Engine source code:

    // Creates a culture invariant FText from the given string literal.
    #define INVTEXT(InTextLiteral) FText::AsCultureInvariant(TEXT(InTextLiteral))
*/

// So, FText::AsCultureInvariant does the same thing as INVTEXT() macro.
FText NewTooltipText = FText::AsCultureInvariant(TEXT("This is another tooltip text"));

// Define the namespace to use with LOCTEXT
// This is only valid within a single file, and must be undefined before the end of the file
#define LOCTEXT_NAMESPACE "MyNamespace"
// Create text literals
FText PlayGameText = LOCTEXT("PlayGame", "Spiel beginnen"); // German langauge

// Helpful in the editor to localize the text into another language.
FText QuitGameText = NSLOCTEXT("StartMenu", "QuitGame", "Avsluta spelet"); // Swedish language

uint32 VersionNumber = 1405476850;
FText MachineOS = INVTEXT("Windows 11 Pro, 22H2, 22621.2215");
FText UserName = INVTEXT("MrRobin");
int32 UserAge = 22;
int32 SpeedInKph = 30;
int32 FuelInPercentage = 80;

// Formatting with FText. The supported types is: int32, uint32, float, double, FText, ETextGender.
FText VersionMessageText = FText::Format(
    LOCTEXT("VersionMessage", "You current version is {0} and is running on {1}"),
    VersionNumber,
    MachineOS
);

// FString also has FString::Prinf() function for formatting. FString::Prinf() is also similar to the native C++ sprintf() function.

// Use FFormatNamedArguments for organizing the FText::Format function.
FFormatNamedArguments Args;
Args.Add(TEXT("Name"), UserName);
Args.Add(TEXT("Age"), UserAge);
FText UserText = FText::Format(LOCTEXT("UserData", "User's name is {UserName} and is {Age} years old."), Args);

// You can also use FText::FormatNamed() function for formatting as well. Great for inlining the code.
FText CarMessageText = FText::FormatNamed(
    LOCTEXT("VehicleMessage", "You current speed is {Speed} and the fuel is at {Fuel}%"),
    TEXT("Speed"), SpeedInKph,
    TEXT("Fuel"), FuelInPercentage
);

#undef LOCTEXT_NAMESPACE // Undefine the current namespace

You can convert specific data type into FText format. For an example, can you use FText::AsNumber() to convert a number into FText with specific FNumberFormattingOptions formatting options.

Here's an example:

float Health = 99.8999f; // We want to round this up, like this: 100.00

bool bIncludeLeadingZero = true;
int32 Precision = 2; // Number of decimals after decimal point. (0.00)

FNumberFormattingOptions NumberFormat;
NumberFormat.MinimumIntegralDigits = (bIncludeLeadingZero) ? 1 : 0;
NumberFormat.MaximumIntegralDigits = 10000;
NumberFormat.MinimumFractionalDigits = Precision;
NumberFormat.MaximumFractionalDigits = Precision;

FText NumberText = FText::AsNumber(Health, &NumberFormat);
NumberText = FText::AsCultureInvariant(NumberText); // Disable the culture formatting

[!NOTE] By default, Unreal will use local culture when doing this format. If you wish to disable culture formatting, use FText::AsCultureInvariant function.

FString is a dynamic, mutable string type in Unreal Engine, which provides a more flexible approach to string manipulation. Unlike FName, FString allows for modifications, such as appending, inserting, or removing characters, making it suitable for general string operations. It is widely used for various tasks, such as displaying messages, concatenating text, or formatting output strings.

Example usage:

#include "Containers/UnrealString.h"

FString MyString = FString("Hello, World!");

Replace a substring with another in a FString:

FString OriginalString = FString("Hello, my friend.");
OriginalString.ReplaceInline(TEXT("friend"), TEXT("buddy")); // Output: "Hello, my buddy."

Split a FString into an array of substrings using a delimiter:

FString Sentence = FString("This is a sentence.");
TArray<FString> Words;
Sentence.ParseIntoArray(Words, TEXT(" "), true); // Output: ["This", "is", "a", "sentence."]

Reverse a FString:

FString Text = FString("abcde");
Text.ReverseString(); // Output: "edcba"

[!NOTE] In Unreal Engine 5.0+, by default, all math related data types are using double as backend data type. This allows Unreal to support large world coordinates (LWC).

A struct representing a 4D vector, consisting of four float values for the X, Y, Z, and W components.

Declare and initialize a FVector4:

FVector4 MyVector = FVector(1.0f, 2.0f, 3.0f, 4.0f);

You can also initalize by an pre-made vector:

FVector4 OldLocation = FVector4::ZeroVector; // (0, 0, 0)
FVector4 NewLocation = FVector4::OneVector; // (1, 1, 1)

![NOTE] Use FVector4f for float and FVector4d for double, as explicit data type for the backend conversion.

To use the integer version of FVector4:

FIntVector4 IntVector4; // Default to 32-bit
FInt32Vector4 Int32Vector4; // 32-bit
FInt64Vector4 Int64Vector4; // 64-bit

FUintVector4 UintVector4; // Default to unsigned 32-bit
FUint32Vector4 Uint32Vector4; // Unsigned 32-bit
FUint64Vector4 FUint64Vector4; // Unsigned 64-bit

A struct representing a 3D vector, consisting of three float values for the X, Y, and Z components. It is often used to represent position or direction in 3D space, and provides many useful functions such as vector addition, subtraction, normalization, and dot and cross products.

Declare and initialize a FVector:

FVector MyVector = FVector(1.0f, 2.0f, 3.0f);

You can also initalize by an pre-made vector:

FVector OldLocation = FVector::ZeroVector; // (0, 0, 0)
FVector NewLocation = FVector::OneVector; // (1, 1, 1)

You can select each component separately:

FVector Vec = FVector::OneVector;

double X = Vec.X;
double Y = Vec.Y;
double Z = Vec.Z;

// or

double& X = Vec[0];
double& Y = Vec[1];
double& Z = Vec[2];

![NOTE] Use FVector3f for float and FVector3d for double, as explicit data type for the backend conversion.

Common static functions to use:

• FVector::Cross() - Calculate cross product this and another vector.
• FVector::CrossProduct() - Calculate the cross product of two vectors.
• FVector::Dot() - Calculate the dot product between this and another vector.
• FVector::DotProduct() - Calculate the dot product of two vectors.
• FVector::Dist() or FVector::Distance() - Euclidean distance between two points.
• FVector::Dist2D() or FVector::DistXY() - Euclidean distance between two points in the XY plane (ignoring Z).
• FVector::DistSquared() - Squared distance between two points.
• FVector::DistSquared2D() or FVector::DistSquaredXY() - Squared distance between two points in the XY plane only.
• FVector::AllComponentsEqual() - Check whether all components of this vector are the same, within a tolerance.

[!TIP] You can use | operator for calling the dot product.

[!TIP] You can use ^ operator for calling the cross product.

Common local functions to use:

• GetComponentForAxis() - Get a specific component of the vector, given a specific axis by enum.
• SetGetComponentForAxis() - Set a specified component of the vector, given a specific axis by enum.
• Set() - Set the values of the vector directly.
• GetMax() - Get the maximum value of the vector's components.
• GetAbsMax() - Get the maximum absolute value of the vector's components.
• GetMin() - Get the minimum absolute value of the vector's components.
• GetAbsMin() - Get the minimum absolute value of the vector's components.
• GetAbs() - Get a copy of this vector with absolute value of each component.
• Size() or Length() - Get the length (magnitude) of this vector.
• SizeSquared() or SquaredLength() - Get the squared length of this vector.
• Size2D() - Get the length of the 2D components of this vector.
• SizeSquared2D() - Get the squared length of the 2D components of this vector.
• HeadingAngle() - Convert a direction vector into a 'heading' angle.
• IsNearlyZero() - Check whether vector is near to zero within a specified tolerance.
• IsZero() - Check whether all components of the vector are exactly zero.
• IsUnit() - Check if the vector is of unit length, with specified tolerance.
• IsNormalized() - Checks whether vector is normalized.
• Normalize() - Normalize this vector in-place if it is larger than a given tolerance. Leaves it unchanged, if not.
• GetSignVector() - Get a copy of the vector as sign only. Each component is set to +1 or -1, with the sign of zero treated as +1.
• Projection() - Projects 2D components of vector based Z.
• GridSnap() - Get a copy of this vector snapped to a grid.
• IsUniform() - Check whether X, Y and Z are nearly equal.
• ConstainsNaN() - Utility to check if there are any non-finite values (NaN or Inf) in this vector.
• ToString() - Get a textural representation of this vector.
• ToCompactString() - Get a short textural representation of this vector, for compact, readable logging.
• ToText() - Get a locale aware textural representation of this vector.
• ToCompactText() - Get a short locale aware textural representation of this vector, for compact, readable logging.

To use the integer version of FVector:

FIntVector IntVector = FIntVector(5, 10, -25); // Default to 32-bit
FUintVector UintVector = FUintVector(5, 10, 25); // Default to unsigned 32-bit

Here's the more explicit versions:

FIntVector3 IntVector3; // Default to 32-bit
FInt32Vector3 Int32Vector3; // 32-bit
FInt64Vector3 Int64Vector3; // 64-bit

FUintVector3 UintVector3; // Default to unsigned 32-bit
FUint32Vector3 Uint32Vector3; // Unsigned 32-bit
FUint64Vector3 FUint64Vector3; // Unsigned 64-bit

A struct representing a 2D vector, consisting of two float values for the X and Y components.

Declare and initialize a FVector2D:

FVector2D MyVector = FVector2D(1.0f, 2.0f, 3.0f);

You can also initalize by an pre-made vector:

FVector2D OldLocation = FVector2D::ZeroVector; // (0, 0, 0)
FVector2D NewLocation = FVector2D::OneVector; // (1, 1, 1)

![NOTE] Use FVector2f for float and FVector2d for double, as explicit data type for the backend conversion.

To use the integer version of FVector2D:

FIntVector2 IntVector2; // Default to 32-bit
FInt32Vector2 Int32Vector2; // 32-bit
FInt64Vector2 Int64Vector2; // 64-bit

FUintVector2 UintVector2; // Default to unsigned 32-bit
FUint32Vector2 Uint32Vector2; // Unsigned 32-bit
FUint64Vector2 FUint64Vector2; // Unsigned 64-bit

A struct representing a 2D integer points, consisting of two int values for the X and Y components.

Declare and initialize a FIntPoint:

FIntPoint MinPoint = FIntPoint(-127, -127);
FIntPoint MaxPoint = FIntPoint(128, 128);

Declare and initialize a FUIntPoint:

FUIntPoint UnsignedMinPoint = FUIntPoint(0, 0);
FUIntPoint UnsignedMaxPoint = FUIntPoint(255, 255);

![NOTE] Use FInt32Point for int32, FUint32Point for uint32, FInt64Point for int64 and FUint64Point for uint64, as explicit data type for the backend conversion.

A struct representing a 2D integer rectangles, consisting of two IntPoint values for the Min and Max components.

Declare and initialize a FIntRect:

FIntPoint MinPoint = FIntPoint(-127, -127);
FIntPoint MaxPoint = FIntPoint(128, 128);
FIntReact Rect = FIntRect(MinPoint, MaxPoint);

Declare and initialize a FUIntReact:

FUIntPoint UnsignedMinPoint = FUIntPoint(0, 0);
FUIntPoint UnsignedMaxPoint = FUIntPoint(255, 255);
FUIntReact UnsignedRect = FIntRect(UnsignedMinPoint, UnsignedMaxPoint);

![NOTE] Use FInt32Rect for int32, FUint32Rect for uint32, FInt64Rect for int64 and FUint64Rect for uint64, as explicit data type for the backend conversion.

A struct representing a rotation in 3D space, consisting of three float values for the Pitch, Yaw, and Roll angles. It is often used to represent the orientation of an object, and provides many useful functions such as conversion to and from quaternions, and rotation of other vectors and rotators.

Declare and initialize a FRotator:

FRotator MyRotator = FRotator(0.0f, 90.0f, 0.0f);

You can also initalize by an pre-made rotator:

FRotator MyRotator = FRotator::ZeroRotator; // (0, 0, 0)

![NOTE] Use FRotator3f for float and FRotator3d for double, as explicit data type for the backend conversion.

Common static functions to use:

• FRotator::Vector() - Convert a rotation into a unit vector facing in its direction.

Common local functions to use:

• GetInverse() - Returns the inverse of the rotator.
• GridSnap() - Get the rotation, snapped to specified degree segments.

A struct representing a quaternion in 3D space, consisting of three float values for the X, Y, Z, and W components. Quaternion a mathematical concept used to represent 3D rotations. It is commonly used in conjunction with FVector to represent orientations and rotations in 3D space.

Declare and initialize a FQuat:

FQuat MyQuaternion = FQuat(0.0f, 90.0f, 0.0f, 0.0f);

You can also initalize by an pre-made quaternion:

FQuat MyQuaternion = FQuat::Identify; // (0, 0, 0, 0)

![NOTE] Use FQuat4f for float and FQuat4d for double, as explicit data type for the backend conversion.

A struct representing a 3D transformation, consisting of a FVector for translation, a FQuat for rotation, and a FVector for scale. It is often used to represent the position, orientation, and size of an object in 3D space, and provides many useful functions for transforming other vectors and transforms.

Declare and initialize a FTransform:

FVector Location = FVector::ZeroVector;
FRotator Rotation = FRotator::ZeroRotator;
FVector Scale = FVector::OneVector;

// Note! Unreal will convert FRotator into FQuat in the backend.
FTransform MyTransform = FTransform(Rotation, Location, Scale);

You can also initalize by an pre-made transform:

FTransform MyTransform = FTransform::Identify; // NaN

![NOTE] Use FTransform3f for float and FTransform3d for double, as explicit data type for the backend conversion.

A struct representing a 3D plane.

Here's an example:

float X = 0.0f;
float Y = 0.0f;
float X = 0.0f;

FPlane Plane = FVector(X, Y, Z);

Here's another way to initialize FPlane:

FPlane Plane = FVector(FVector(0.0f, 0.0f, 0.0f));

![NOTE] Use FPlane4f for float and FPlane4d for double, as explicit data type for the backend conversion.

A struct representing a 4x4 matrix of loating point values.

Here's an example:

FPlane XPlane = FPlane(1.0f, 0.0f, 0.0f, 0.0f);
FPlane YPlane = FPlane(0.0f, 1.0f, 0.0f, 0.0f);
FPlane ZPlane = FPlane(0.0f, 0.0f, 1.0f, 0.0f);
FPlane WPlane = FPlane(0.0f, 0.0f, 0.0f, 1.0f);

FMatrix Matrix = FMatrix(XPlane, YPlane, ZPlane, WPlane);

FVector XVector = FVector(1.0f, 0.0f, 0.0f);
FVector YVector = FVector(0.0f, 1.0f, 0.0f);
FVector ZVector = FVector(0.0f, 0.0f, 1.0f);
FVector WVector = FVector(0.0f, 0.0f, 0.0f);

FMatrix Matrix = FMatrix(XVector, YVector, ZVector, WVector);

FMatrix Matrix;

int32 RowIndex = 0;
int32 ColumnIndex = 0;

double Element = Matrix[RowIndex][ColumnIndex];

![NOTE] Use FMatrix44f for float and FMatrix44d for double, as explicit data type for the backend conversion.

A struct representing a 3D sphere.

Here's an example:

FVector Center = FVector::ZeroVector;
float Radius = 500.0f;

FSphere Sphere = FSphere(Center, Radius);

![NOTE] Use FSphere3f for float and FSphere3d for double, as explicit data type for the backend conversion.

A struct representing a 3D box.

Here's an example:

FVector MinPoint = FVector(15.5f, 15.5f);
FVector MaxPoint = FVector(25.0f, 25.0f);

FBox Box2D = FBox(MinPoint, MaxPoint);

![NOTE] Use FBox3f for float and FBox3d for double, as explicit data type for the backend conversion.

A struct representing a 2D box.

Here's an example:

FVector2D MinPoint = FVector2D(10, 10);
FVector2D MaxPoint = FVector2D(20, 20);

FBox2D Box2D = FBox2D(MinPoint, MaxPoint);

![NOTE] Use FBox2f for float and FBox2d for double, as explicit data type for the backend conversion.

A struct representing a 3D ray, consisting of two vector values for the Origin and Direction components.

Here's an example:

FVector Origin = FVector::ZeroVector;
FVector Direction = FVector::ForwardVector;
bool bDirectionIsNormalized = false;

FRay Ray = FRay(Origin, Direction, bDirectionIsNormalized);

Functions to use with FRay:

FVector Point = FVector::ZeroVector;

FVector ClosestPoint = Ray.ClosestPoint(Point);
double MinDistance = Ray.Dist(Point);
double MinSqrtDistance = Ray.DistSquared(Point);

double ScalarDistance = 0.5; // Along the ray
FVector PointAt = Ray.PointAt(ScalarDistance);
double CalcScalarDistance = Ray.GetParameter(PointAt); // Will convert back to 'ScalarDistance'

![NOTE] Use FRay3f for float and FRay3d for double, as explicit data type for the backend conversion.

FColor stores a color with 8 bits (byte) of precision per channel.

FLinearColor stores a linear color with 32-bit/component floating point RGBA color.

Here's an example, how to initialize them:

FLinearColor LinearColor = FLinearColor(0.5f, 1.0f, 0.3f);

FColor Color = FColor(150, 200, 50);

// or

// Supported formats are: RGB, RRGGBB, RRGGBBAA, RGB, #RRGGBB, #RRGGBBAA
FColor HexColor = FColor::FromHex(TEXT("#9fd99e"));
FString HexString = HexColor.ToHex(); // Convert it back to a string. The format of the string is RRGGBBAA.

List of common colors of ´FLinearColor´:

• FLinearColor::White
• FLinearColor::Gray
• FLinearColor::Black
• FLinearColor::Transparent
• FLinearColor::Red
• FLinearColor::Green
• FLinearColor::Blue
• FLinearColor::Yellow

List of common colors of FColor:

• FColor::White
• FColor::Black
• FColor::Transparent
• FColor::Red
• FColor::Green
• FColor::Blue
• FColor::Yellow
• FColor::Cyan
• FColor::Magenta
• FColor::Orange
• FColor::Purple
• FColor::Turquoise
• FColor::Silver
• FColor::Emerald

You can read more about linear color at Unreal's docs.

You can also read more about color at Unreal's docs.

A dynamic array that can store a variable number of elements of the same type. It provides many useful functions, such as adding, removing, sorting, and searching for elements, as well as iterating over them.

Here's an example:

Include the header file:

#include "Containers/Array.h"

Declare a TArray of int32 (integers)

TArray<int32> MyArray { 1, 2, 3 };

Add an element to the array:

MyArray.Add(4);

// MyArray: { 1, 2, 3, 4 }

Add multiple elements to the array:

MyArray.Append({10, 15, 20});

// MyArray: { 1, 2, 3, 4, 10, 15, 20 }

Remove elements from the array:

MyArray.RemoveAt(0);
MyArray.RemoveAt(0);

// MyArray: { 3, 4, 10, 15, 20 }

Get the number of elements from the array:

int32 NumOfElements = MyArray.Num(); // 5

Loop through the array and log each element:

for (const int32& Element : MyArray)
{
    UE_LOG(LogTemp, Log, TEXT("Element: %i"), Element);
}

You can either allocate an array on the stack or on the heap. Without specifying, you are creating the array allocation on the heap, while the array returns a data container on the stack.

If you don't know about what the difference between stack and heap allocation, highly suggest reading upon the subject in this section.

Here is a way to allocate an array on the stack:

TArray<int32, TInlineAllocator<4>> StackArray; // Allocate 4 elements on the stack

StackArray.Add(1);
StackArray.Add(2);
StackArray.Add(3);
StackArray.Add(4);

// Now we added the same amount of elements, to our buffer size (which has been allocated on the stack).
// If we try to add more elements than allocated, Unreal will default TArray to use heap allocation for the rest of elements.

StackArray.Add(5); // Will be allocated on the heap!

[!WARNING] If you're trying to allocate a heap object on the stack with TInlineAllocator, Unreal will default to a heap allocation.

[!WARNING] If you add more elements than have been allocated for, Unreal will default to a heap allocation instead.

[!NOTE] Unreal will treat as stack allocated array as a different data type, compare to a regular array. To accommodate this, use TArrayView instead.

If you want to avoid filling up the rest of elements with heap allocation, then use TFixedAllocator:

TArray<int32, TFixedAllocator<4>> StackArray; // Allocate 4 elements on the stack

StackArray.Add(1);
StackArray.Add(2);
StackArray.Add(3);
StackArray.Add(4);

StackArray.Add(5); // Unreal calls an assertion, which will CRASH Unreal in runtime mode!

// If you're continuing on with the assertion, using Visual Studio Debugger, Unreal will call Reset() function.
// Clearing out all elements, but keeping the current allocation size.

// Same thing happens with brace initialization.
TArray<int32, TFixedAllocator<4>> StackArray{ 1, 2, 3, 4, 5 }; // Allocate 4 elements on the stack, but we got 5 elements!

A set of unique elements of a single type, implemented as a hash table. It provides many of the same functions as TArray, but with faster lookup times for large collections of elements.

Here's an example:

Include the header file:

#include "Containers/Set.h"

Declare a TSet of FName (names):

TSet<FName> MySet;

Add elements to the set:

// Add single element to the set
MySet.Add(TEXT("hello"));

// Add multiple elements to the set
MySet.Append({TEXT("cruel"), TEXT("world"), TEXT("hello")});

// MySet: { "hello", "curel", "world" }

Get number of elements from the set:

int32 NumOfElements = MySet.Num(); // 4

Check if an element exists in the set:

if (MySet.Contains(TEXT("cruel")))
{
    UE_LOG(LogTemp, Log, TEXT("'Cruel' element is in the set"));
}

Remove an element from the set:

MySet.Remove(TEXT("cruel"));

// MySet: { "hello", "world" }

Iterate through the set and log each element:

for (const FName& Name : MySet)
{
    UE_LOG(LogTemp, Log, TEXT("Name: %s"), *Name.ToString());
}

Convert the set to an array:

TArray<FName> CopyOfSet = MySet.Array();
CopyOfSet[0] = TEXT("goodbye");

// CopyOfSet: { "goodbye", "world" }

A map of key-value pairs, implemented as a hash table. It allows fast lookup of a value given a key, and supports adding, removing, and iterating over key-value pairs.

Here's an example:

Include the header file:

#include "Containers/Map.h"

Declare a TMap of FName (names) to int32 (integers):

TMap<FName, int32> MyMap = { { TEXT("player_id"), 457865 }, { TEXT("player_age"), 35 } };

// MyMap: { { "player_id", 457865 }, { "player_age", 35 } }

Add elements to the map:

int32& PlayerRankRef = MyMap.Add(TEXT("player_rank"));
PlayerRankRef = 420;

MyMap.Add(TEXT("player_speed"), 15);

// MyMap: { { "player_id", 457865 }, { "player_age", 35 }, { "player_rank", 420 }, { "player_speed", 15 } }

Finds the value in the map from the key. Otherwise, create and add the key to the map (with default value):

int32& PlayerIDRef = MyMap.FindOrAdd(TEXT("player_id"));
PlayerIDRef = 001100;

// MyMap: { { "player_id", 001100 }, { "player_age", 35 }, { "player_rank", 420 }, { "player_speed", 15 } }

Get number of elements from the map:

int32 NumOfElements = MyMap.Num(); // 4

Iterate through the map and log key-value pairs:

for (const TPair<FName, int32>& KeyValuePair : MyMap)
{
    UE_LOG(LogTemp, Log, TEXT("Key: %s, Value: %i"), *KeyValuePair.Key.ToString(), KeyValuePair.Value);
}

Check if "player_rank" exists in the map and log its value if found:

if (int32* PlayerRankPtr = MyMap.Find(TEXT("player_rank")))
{
    UE_LOG(LogTemp, Log, TEXT("Player rank is: %i"), *PlayerRankPtr);
}

Access an element in the map:

int32 OutSpeed;

if (MyMap.TryGetValue(TEXT("player_speed"), OutSpeed))
{
    UE_LOG(LogTemp, Log, TEXT("Player's speed: %i [m/s]"), OutSpeed);
}

Modify an element in the map:

MyMap[TEXT("player_age")] = -1;

// MyMap: { { "player_id", 001100 }, { "player_age", -1 }, { "player_rank", 420 }, { "player_speed", 15 } }

Remove an element from the map:

MyMap.Remove(TEXT("player_age")); // Reference variables (such as PlayerRankRef and PlayerIDRef) become unsafe since the map size and elements have changed.

// MyMap: { { "player_id", 001100 }, { "player_rank", 420 }, { "player_speed", 15 } }

Convert the map to an array of key-value pairs:

TArray<TPair<FName, int32>> KeyValueArray = MyMap.Array();
int32 PlayerID = KeyValueArray[0].Value; // 001100

With these containers, you can use a couple of helpful functions.

• Empty() - Clears out the store elements (as well as resizing the buffer to zero).
• Reset() - Clears out the store elements (without resizing the buffer).
• GetSlack() - Gets the number of store elements minus it's buffer size. Slack = NumOfElements - BufferCapacity.
• GetAllocationSize() - Gets the buffer capacity.
• Shrink() - It will reset the buffer size to the number of elements, currently being stored.
• Reserve() - It will expand buffer size to that amount. Note, buffer size can change later on.
• RemoveAll - Will remove all elements with prediction as an argument.
• RemoveAllSwap - Same as RemoveAll() function, but doesn't preserve the order.

Here's an example:

#include "Containers/Array.h"

TArray<int32> Array = { 1, 2, 2, 3, 4, 4, 5 };

// Create a lamba function (which is a temporary function, which takes this class as reference parameter)
Array.RemoveAll([&](const int32& Item)
{
    // Removes all item, if the item is equal to: 2
    return Item == 2;
});

// Current elements: { 1, 3, 4, 4, 5 }

Array.RemoveAllSwap([&](const int32& Item)
{
    // Removes all item, if the item is equal to: 2
    return Item == 4;
});

// Current elements: { 5, 3, 1 }

#include "Containers/Array.h"

TArray<int32> Array;
Array.Add(1);
Array.Add(2);

// Current element count: 2
// Current buffer size: 4

Array.Empty();

// Current element count: 0
// Current buffer size: 0

Array.Add(1);
Array.Add(2);

// Current element count: 2
// Current buffer size: 4

Array.Reset();

// Current element count: 0
// Current buffer size: 4

TArray<int32> Array;
Array.Add(1);
Array.Add(2);
Array.Add(3);
Array.Add(4);
Array.Add(5);

// Current element count: 5
// Current buffer size: 22

int32 SlackAmount = Array.GetSlack(); // 22 - 5 = 17 (Slack = BufferCapacity - NumOfElements)

Array.RemoveAt(0);
Array.RemoveAt(1);

// Current element count: 3
// Current buffer size: 22

Array.Shrink();

// Current element count: 3
// Current buffer size: 4

In order to remove an element without allowing the container to shrink, you can use these arguments:

#include "Containers/Array.h"

TArray<int32> Array { 1, 2, 3 };

// Removes the last element, without enable the container to shrink itself.
int32 LastElementIndex = Array.Num() - 1;
int32 NumToRemove = 1;
bool bAllowShrinking = false;
Array.RemoveAt(LastElementIndex, NumToRemove, bAllowShrinking)

When and how much does the container allocated memory for future use cases?

If you run a for-loop and running the debugger, we can analyze the allocation size and where the container has its breakpoints for requesting more memory.

#include "Containers/Array.h"

void UpdatingAllocationSize()
{
    TArray<int32> Array;

    int32 PreviousAllocatedSize = Array.GetAllocatedSize();

    for (int32 i = 0; i < 100; ++i)
    {
        Array.Add(69);

        int32 NewAllocatedSize = Array.GetAllocatedSize();

        if (PreviousAllocatedSize != NewAllocatedSize)
        {
            UE_LOG(LogTemp, Log, TEXT("[%s - %s]: Allocation size has changed from: %i to: %i. Current number of elements: %i and current max size: %i"), ANSI_TO_TCHAR(__FUNCTION__), TEXT("Adding"), PreviousAllocatedSize, NewAllocatedSize, Array.Num(), NewAllocatedSize / sizeof(int32));

            PreviousAllocatedSize = NewAllocatedSize;
        }
    }

    // Allocation size is data size times buffer size.

    // Int32 is 4 bytes in size
    // And the buffer size is currently at 4.

    // Allocation size = 4 * 4 = 16 bytes

    /*
        LogTemp: Allocation size has changed from: 0 to: 16. Current number of elements: 1 and current max size: 4
        LogTemp: Allocation size has changed from: 16 to: 88. Current number of elements: 5 and current max size: 22
        LogTemp: Allocation size has changed from: 88 to: 188. Current number of elements: 23 and current max size: 47
        LogTemp: Allocation size has changed from: 188 to: 328. Current number of elements: 48 and current max size: 82
        LogTemp: Allocation size has changed from: 328 to: 520. Current number of elements: 83 and current max size: 130
    */

    for (int32 i = 0; Array.Num() != 0; ++i)
    {
        Array.RemoveAt(Array.Num() - 1);

        int32 NewAllocatedSize = Array.GetAllocatedSize();

        if (PreviousAllocatedSize != NewAllocatedSize)
        {
            UE_LOG(LogTemp, Log, TEXT("[%s - %s]: Allocation size has changed from: %i to: %i. Current number of elements: %i and current max size: %i"), ANSI_TO_TCHAR(__FUNCTION__), TEXT("Removing"), PreviousAllocatedSize, NewAllocatedSize, Array.Num(), NewAllocatedSize / sizeof(int32));

            PreviousAllocatedSize = NewAllocatedSize;
        }
    }

    /*
        LogTemp: Allocation size has changed from: 520 to: 260. Current number of elements: 65 and current max size: 65
        LogTemp: Allocation size has changed from: 260 to: 0. Current number of elements: 0 and current max size: 0
    */
}

Algo is a namespace containing a lot of helper functions for container.

Here is common functions:

• Algo::Accumulate() - Sums a range.
• Algo::AllOf() - Checks if every projection of the elements in the range is truthy.
• Algo::AnyOf() - Checks if any projection of the elements in the range is truthy.
• Algo::BinarySearch() - Returns index to the first found element matching a value in a range, the range must be sorted by <
• Algo::BinarySearchBy() - Same as Algo::BinarySearch(), but with custom logic.
• Algo::Compare() - Compares two contiguous containers using operator== to compare pairs of elements.
• Algo::CompareByPredicate() - Compares two contiguous containers using a predicate to compare pairs of elements.
• Algo::Copy() - Copies a range into a container.
• Algo::CopyIf() - Conditionally copies a range into a container.
• Algo::Count() - Counts elements of a range that equal the supplied value.
• Algo::CountBy() - Counts elements of a range whose projection equals the supplied value.
• Algo::CountIf() - Counts elements of a range that match a given predicate.
• Algo::Find() - Returns a pointer to the first element in the range which is equal to the given value.
• Algo::FindBy() - Returns a pointer to the first element in the range whose projection is equal to the given value.
• Algo::FindLast() - Returns a pointer to the last element in the range which is equal to the given value.
• Algo::FindLastBy() - Returns a pointer to the last element in the range whose projection is equal to the given value.
• Algo::FindSequence() - Searches for the first occurrence of a sequence of elements in another sequence.
• Algo::ForEach() - Invokes a callable to each element in a range.
• Algo::Includes() - Checks if one sorted contiguous container is a subsequence of another sorted contiguous container by comparing pairs of elements.
• Algo::IndexOf() - Returns the index of the first element in the range which is equal to the given value.
• Algo::IndexOfByPredicate() - Returns the index of the first element in the range which matches the predicate.
• Algo::IsSorted() - Tests if a range is sorted by its element type's operator <.
• Algo::MaxElement() - Returns a pointer to the maximum element in a range.
• Algo::MinElement() - Returns a pointer to the minimum element in a range.
• Algo::NoneOf() - Checks if no element in the range is truthy.
• Algo::Sort() - Sort the range. It will default to < operator (ascending order). However, custom logic can be added.
• Algo::SortBy() - Same as Algo::Sort, but uses a projection method. Projections are transformations but for values.
• Algo::RandomShuffle() - Randomly shuffle a range of elements.
• Algo::RemoveIf() - Moves all elements which do not match the predicate to the front of the range, while leaving all other elements is a constructed but unspecified state.
• Algo::Replace() - Replaces all elements that compare equal to one value with a new value.
• Algo::ReplaceIf() - Replaces all elements that satisfy the predicate with the given value.
• Algo::Reverse() - Reverses a range.
• Algo::Transform() - Applies a transform to a range and stores the results into a container.

You can read more about Algo on Unreal's docs.

Here's an example of using them:

#include "Algo/ForEach.h"
#include "Algo/Accumulate.h"
#include "Algo/IndexOf.h"

TArray<FString> Array;
Array.Add(TEXT("hello"));
Array.Add(TEXT("cRuEL"));
Array.Add(TEXT("WORLD"));

const int32 FoundIndex = Algo::IndexOf(Array, FString(TEXT("cRuEL")));

if (FoundIndex != INDEX_NONE)
{
    // Successfully found the index
}

const int32 FoundIndexPred = Algo::IndexOfByPredicate(Array,
    [&](const FString& Arg)
    {
        return TEXT("hello") == Arg.ToLower();
    });

if (FoundIndexPred != INDEX_NONE)
{
    // Successfully found the index with prediction
}

TArray<FString> TransformArray;

Algo::Transform(Array, TransformArray, [](const FString& Item) { return Item.ToUpper(); });

// { "HELLO", "CRUEL", "WORLD" }

Algo::Reverse(TransformArray);

// { "WORLD", "CRUEL", "HELLO" }

TArray<int32> SortArray { 1, 5, 3, -4, 2, -1 };
Algo::Sort(SortArray);

// { -4, -1, 1, 2, 3, 5 }

// Create a lambda function for this projection
auto AbsProjection = [](int32 Value) { return FMath::Abs(Value); };

// Will sort based on this projection. But will still reserve the original values.
Algo::SortBy(SortArray, AbsProjection);

// { -1, 1, 2, 3, -4, 5 }

Algo::ForEach(SortArray, [](int32& Value)
{
    Value *= 2;
});

// { -2, 2, 4, 6, -8, 10 }

// Will sort based on descending order
auto ReverseSortPredicate = [](int32 A, int32 B) { return A > B; };
Algo::SortBy(SortArray, AbsProjection, ReverseSortPredicate);

// { 10, -8, 6, 4, 2, -2 }

Similar to TMap, but allows multiple values to be associated with the same key. It also provides functions for iterating over all the values associated with a particular key.

Here's an example:

Include the header file:

#include "Containers/Map.h"

Declare a TMultiMap of FName (names) to floats:

TMultiMap<FName, float> MyMultiMap = { { TEXT("X"), 10.0f }, { TEXT("Y"), 69.0f }, { TEXT("Z"), 0.0f } }

Add elements to the map:

MyMultiMap.Add(TEXT("X"), -10.0f);
MyMultiMap.Add(TEXT("Y"), 69.0f);
MyMultiMap.AddUnique(TEXT("Y"), 69.0f); // Will not add if both key and value match an existing association in the map!

// MyMultiMap: { { TEXT("X"), 10.0f }, { TEXT("Y"), 69.0f }, { TEXT("Z"), 0.0f }, { TEXT("Y"), 69.0f }, { TEXT("X"), -10.0f } }

Get all values for a key in the map:

TArray<float> OutValues;
MyMultiMap.MultiFind(TEXT("Y"), OutValues);

// OutValues: { 69.0f, 69.0f }

Get number of elements from the multi-map:

int32 NumOfElements = MyMultiMap.Num(); // 5

Loop through the values and log each one:

for (const float& Value : OutValues)
{
    UE_LOG(LogTemp, Log, TEXT("Value: %f"), Value);
}

Remove all values for a key in the map:

MyMultiMap.Remove(TEXT("Y"));

// MyMultiMap: { { TEXT("X"), 10.0f }, { TEXT("Z"), 0.0f }, { TEXT("X"), -10.0f } }

Remove the first association between the specified key and value from the map:

MyMultiMap.RemoveSingle(TEXT("X"), 10.0f);

// MyMultiMap: { { TEXT("Z"), 0.0f }, { TEXT("X"), -10.0f } }

You can read more about it on Unreal's docs.

[!WARNING] Unreal doesn't support TMultiMap with UHT⁶. Meaning, you can't expose to Blueprint.

An array with a static number of elements.

You cannot add or remove any of the entries of the static array. But you can still alter each element's data.

Here's an example:

Include the header file:

#include "Containers/StaticArray.h"

Declare a TStaticArray of int32 (integers) with 4 elements pre-allocated:

// Allocate 4 elements of type 'FVector'
TStaticArray<FVector, 4> StaticArray;

// StaticArray: { (0, 0, 0), (0, 0, 0), (0, 0, 0), (0, 0, 0) }

You CANNOT use brace initialization with TStaticArray:

TStaticArray<int32, 4> StaticArray { 1, 2, 3, 4 }; // Won't compile!

Update each element's value:

StaticArray[0] = FVector::OneVector;
StaticArray[1] = FVector::ZeroVector;
StaticArray[2] = FVector::OneVector;
StaticArray[3] = FVector::ZeroVector;

// StaticArray: { (1, 1, 1), (0, 0, 0), (1, 1, 1), (0, 0, 0) }

Get number of elements from the static array:

int32 NumOfElements = StaticArray.Num(); // 4

Loop through the values and log each one:

for (const FVector& Vec : StaticArray)
{
    UE_LOG(LogTemp, Log, TEXT("Value: %s"), *Vec.ToString());
}

You can read more about it on Unreal's docs.

[!WARNING] Unreal Engine doesn't support TStaticArray with UHT⁶. Meaning, you can't expose to Blueprint. To use a static array with Blueprint, use FixedSized specifier for UPROPERTY on TArray property.

Dynamically sized hash table, used to index another data structure. Vastly simpler and faster than TMap.

Here's an example:

Include the header file:

#include "Containers/HashTable.h"

Define a FHashTable:

FHashTable HashTable;

Add a new hash element to the table:

const uint16 Hash = 50u;
const uint16 Index = 10u;

HashTable.Add(Hash, Index);

You can read more about it on Unreal's docs.

Statically sized hash table, used to index another data structure. Vastly simpler and faster than TMap.

Here's an example:

Include the header file:

#include "Containers/HashTable.h"

Define a TStaticHashTable:

static const uint32 Capacity = 16u;
TStaticHashTable<1024u, Capacity> StaticHashTable;

Add a new hash element to the table:

const uint16 Hash = 50u;
const uint16 Index = 10u;

StaticHashTable.Add(Hash, Index);

You can read more about it on Unreal's docs.

A Map of keys to value, implemented as a sorted TArray of TPairs.

It has a mostly identical interface to TMap and is designed as a drop in replacement. Keys must be unique, there is no equivalent sorted version of TMultiMap. It uses half as much memory as TMap, but adding and removing elements is O(n), and finding is O(Log n). In practice it is faster than TMap for low element counts, and slower as n increases, This map is always kept sorted by the key type so cannot be sorted manually.

Here's an example:

Include the header file:

#include "Containers/SortedMap.h"

Create a TSortedMap of FName (names) to int32 (integers):

TSortedMap<FName, int32> MyMap;

Add some elements to the map:

MyMap.Add(TEXT("One"), 1);
MyMap.Add(TEXT("Two"), 2);
MyMap.Add(TEXT("Three"), 3);

Get the value associated with a key:

int32 Value = MyMap[TEXT("One")];

Check if a key exists in the map:

bool Exists = MyMap.Contains(TEXT("One"));

Iterate over the map and log each one:

for (const TPair<FName, int32>& Element : MyMap)
{
    UE_LOG(LogTemp, Log, TEXT("Key: %s, Value: %i"), *Element.Key.ToString(), Element.Value);
}

You can read more about it on Unreal's docs.

Simple single-linked list template.

It only stores two things:

ElementType			Element; // Value
TList<ElementType>* Next; // Pointer to the next node

Helpful for scenarios like: Pathfinding, binary tree searching or dialogue tree system.

A linked list have some benefits compare to TArray, mainly it has O(1) in time complexity, for adding and removing elements in the list. This is because, every node has a pointer to the next node in the list. Thus giving TList a time complexity to O(1).

You can read more about time complexity by Joel Olawanle.

There is a couple of downsides of using TList compare to TArray:

Cache misses When the computer reads the memory, it reads from RAM (Random-access memory). Hence, the name it will access the memory at random location. With TArray, your memory allocation contiguous. Meaning, that TArray will ask for a big spot to have its memory block. However, if TArray cannot find nor fit a specific spot (as the TArray can grow and shrink), it needs to recalculate and find a new spot. Thus making it annoying to add or to remove elements. But what TArray have which a linked list lacks is cache hits. Cache hits is a terminology, where the CPU can preload an array into CPU cached memory. Because an array stores in contiguous, allows the CPU to preload the whole array without jumping back and forth in memory location. With linked lists, there is no contiguous memory. Meaning, the CPU needs to find each node in different location. Which doesn't allow the CPU to cache previous result into its memory. And this called a cache miss. Image from Dhathri Vupparapalli's blog. Here is a video from SimonDev about cache misses and hits. You can also read more about the CPU's cache on Wikipedia. Memory space TList takes up more memory space per each node. Since every node needs to keep track of the next node in the list. And the next variable is a pointer, which takes up 4 bytes in 32-bit and 8 bytes in 64-bit computers. And if you just want to use primary data types, such as (int, float, double, bool or char), then you can just use TArray instead. Whilst a TArray stores some overhead, it's very minimal overhead. No helper functions TList only offers the data element and the next node (as a pointer variable). TList does NOT offer any helper functions for adding or removing a node in the list. If you wish to have these functions, then you can just use TLinkedList instead. Only goes forward With TList, you can only forwards. This is becuase there is no previous node per node. Meaning, you cannot go backwards in the list. If you wish to go backwards, then you can just use TDoubleLinkedList instead.

Here's an example:

Include the header file:

#include "Containers/List.h"

// Create the head of the list with data value of 69
TList<int32> Head(69);

// Create a new node with data 1337 and link it to the head
Head.Next = new TList<int32>(1337);

// Create another node with data 3 and link it to the previous node
Head.Next->Next = new TList<int32>(3);

// Re-assign the data value
Head.Next->Next->Next.Element = 420;

// Print the elements in the linked list
TList<int32>* CurrentNode = &Head;

while (CurrentNode != nullptr)
{
    UE_LOG(LogTemp, Log, TEXT("Element: %i"), CurrentNode->Element);
    CurrentNode = CurrentNode->Next;
}

[!NOTE] TList doesn't offer an insert nor a remove function for each node. If you wish to use those function, then use TLinkedList.

[!NOTE] As a rule of thumb, you should almost always use TArray, unless you have specific reasons to use a linked list.

You can read more about it on Unreal's docs.

Encapsulates a link in a single linked list with constant access time.

This linked list is non-intrusive, i.e. it stores a copy of the element passed to it (typically a pointer)

Here's an example:

Include the header file:

#include "Containers/List.h"

Define a TLinkedList of int32 (integer):

TLinkedList<int32> HeadNode;

Iterate over the linked list using TIterator:

for (TLinkedList<int32>::TIterator It(&HeadNode); It; It.Next())
{
    // Get the value at the current position of the iterator
    int32 Value = *It;

    // Log the value.
    UE_LOG(LogTemp, Log, TEXT("Value: %i"), Value);
}

You can read more about it on Unreal's docs.

It only stores three things:

ElementType            Value;
TDoubleLinkedListNode* NextNode;
TDoubleLinkedListNode* PrevNode;

Here's an example:

Include the header file:

#include "Containers/List.h"

Define a TDoubleLinkedList of int32 (integers):

TDoubleLinkedList<int32> A;

Add node to the head/tail of the list:

A.AddHead(69);
A.AddTail(1337);

Get the number of elements in the list:

int32 NumOfElements = A.Num();

Check if the list contains the value 5:

bool bContains = A.Contains(5);

Find a node with value 1 in the list:

TDoubleLinkedList<int32>::TDoubleLinkedListNode* Node = A.FindNode(1);

// Log the value of the found node
if (Node != nullptr)
{
    UE_LOG(LogTemp, Log, TEXT("Value of the node: %i"), Node->GetValue());
}
else
{
    UE_LOG(LogTemp, Log, TEXT("Node with value 1 not found."));
}

Get the next node and previous node in the list:

TDoubleLinkedList<int32>::TDoubleLinkedListNode* NextNode = Node->GetNextNode();
TDoubleLinkedList<int32>::TDoubleLinkedListNode* PrevNode = Node->GetPrevNode();

// Log the values of the next and previous nodes
if (NextNode != nullptr)
{
    UE_LOG(LogTemp, Log, TEXT("Value of the next node: %i"), NextNode->GetValue());
}
else
{
    UE_LOG(LogTemp, Log, TEXT("Next node is null."));
}

if (PrevNode != nullptr)
{
    UE_LOG(LogTemp, Log, TEXT("Value of the previous node: %i"), PrevNode->GetValue());
}
else
{
    UE_LOG(LogTemp, Log, TEXT("Previous node is null."));
}

You can read more about it on Unreal's docs.

This template implements an unbounded non-intrusive queue using a lock-free linked list that stores copies of the queued items. The template can operate in two modes: Multiple-producers single-consumer (MPSC) and Single-producer single-consumer (SPSC).

The queue is thread-safe in both modes. The Dequeue() method ensures thread-safety by writing it in a way that does not depend on possible instruction reordering on the CPU. The Enqueue() method uses an atomic compare-and-swap in multiple-producers scenarios.

Here's an example:

Include the header file:

#include "Containers/Queue.h"

Define a TQueue of FHitResult (hit results):

TQueue<FHitResult> MyQueue;

Add some elements to the queue:

AActor* TargetActor = this;
UPrimitiveComponent* TargetComponent = this;
FVector HitLocation = FVector(900.0f, 0.0f, 500.0f);
FVector HitNormal = FVector(0.0f, 0.0f, 1.0f);

MyQueue.Enqueue(FHitResult(TargetActor, TargetComponent, HitLocation, HitNormal));
MyQueue.Enqueue(FHitResult(nullptr, nullptr, FVector::ZeroVector, FVector::OneVector.GetSafeNormal()));

Dequeue the first element in the queue:

FHitResult DequeuedElement = MyQueue.Dequeue();

Check if the queue is empty:

bool IsEmpty = MyQueue.IsEmpty();

Iterate over the queue:

while (!MyQueue.IsEmpty())
{
    FHitResult HitResult = MyQueue.Dequeue();

    UE_LOG(LogTemp, Log, TEXT("Hit Target: %s"), *HitResult.GetActor()->GetName());
}

You can read more about it on Unreal's docs.

When you want to reuse an array without copying or referencing the base class, you can use TArrayView.

A statically sized view of an array of typed elements. Designed to allow functions to take either a fixed C-style array or a TArray with an arbitrary allocator as an argument when the function neither adds nor removes elements.

You can read more about from Unreal's docs.

Here's an example:

#include "Containers/Array.h"
#include "Containers/ArrayView.h"

#include "Algo/ForEach.h"
#include "Algo/Accumulate.h"

int32 SumArray(TArrayView<const int32> ArrayView)
{
    // Sum the array
    return Algo::Accumulate(ArrayView, 0);
}

// Allocates on heap, but returns an array on the stack
TArray<int32> RegularArray = { 1, 2, 3 };

 // Allocates on the stack
TArray<int32, TInlineAllocator<4>> StackAllocatedArray = { 1, 2, 3 };

 // Allocates on the stack
int32 CArray[4] = { 1, 2, 3 };

UE_LOG(LogTemp, Log, TEXT("Sum=%i"), SumArray(RegularArray));

UE_LOG(LogTemp, Log, TEXT("Sum=%i"), SumArray(StackAllocatedArray));

UE_LOG(LogTemp, Log, TEXT("Sum=%i"), SumArray(CArray));

[!WARNING] TArrayView is a fixed size and independent array. Meaning, it will not affect from its original assignment, nor does it support Add() or Remove() functions.

[!NOTE] It's still possible to use Algo library, which offers functions to use for TArrayView and TArray. Such as Algo::Reverse() and Algo::ForEach().

[!CAUTION] Avoid using TArrayView with a temporary array variable. Since, the array can go out of scope and corrupt TArrayView. Since the view is relying on the array's memory block.

#include "Containers/ArrayView.h"

// Note how to mark an ArrayView const!
void ConstArrayView()
{
    TArray<int32> MutableArray;
    TArrayView<int32> ArrayView = MutableArray;
    TArrayView<const int32> ConstArrayView = MutableArray;

    ArrayView[0] = 1337; // Allowed!
    ConstArrayView[0] = 69; // Compiling error!
}

// Do not create an array view to a temporary variable, as this can cause issues!
void UnsafeArrayView()
{
    // Create Array view with temporary TArray
    TArrayView<const int32> UnsafeArray = TArray<int32> { 1, 2, 3 };

    // This memory block has likely been freed, but the array view doesn't know about it!
    int32 Value = UnsafeArray[0]; // This will cause a crash!
}

// Do not modify the array while the array view is in scope! Array view is independent from the array.
void ModifyArrayView()
{
    TArray<int32> Array { 1, 2, 3 };
    TArrayView<int32> ArrayView = Array;

    int32 PreviousValue = ArrayView[0];

    Array.RemoveAt(0); // Will not update array view!

    int32 NewValue = ArrayView[0];

    bool bIsSame = PreviousValue == NewValue; // Will return true!
}

FStringView is a lightweight, non-owning view of the string data, and copying the view itself is efficient and does not affect the underlying data. However, when you copy the FStringView, the new instance of the view still refers to the same original string data.

Same concept with TArrayView but with FString instead.

Here's an example:

#include "Containers/UnrealString.h"

void ProcessString(FStringView StringView)
{
    // Use FStringView to read the string data without copying it.
    UE_LOG(LogTemp, Log, TEXT("String: %s"), *StringView);
}

FString MyString = TEXT("Hello, FStringView!");

// Pass FString as FStringView to the function without copying the data.
ProcessString(MyString);

// Copy FStringView to another variable.
FStringView CopiedStringView = MyString;

// Modifying the original FString does not affect the copied FStringView.
MyString = TEXT("Modified String");

// Print the contents of the copied FStringView.
UE_LOG(LogTemp, Log, TEXT("Copied StringView: %s"), *CopiedStringView);

You can read more about it on Unreal's docs.

When working strings, you might have to concatenate a lot of string together. Sometimes, this can create complex and messy code to read. Whilst, FString is mutable and allows the developer to alter its data without copy a new instance. A string builder can still be a very helpful tool.

The string builder allocates a buffer space which is used to hold the constructed string. The intent is that the builder is allocated on the stack as a function local variable to avoid heap allocations.

The buffer is always contiguous, and the class is not intended to be used to construct extremely large strings.

This is not intended to be used as a mechanism for holding on to strings for a long time. The use case is explicitly to aid in constructing strings on the stack and subsequently passing the string into a function call or a more permanent string storage mechanism like FString et al.

The amount of buffer space to allocate is specified via a template parameter and if the constructed string should overflow this initial buffer, a new buffer will be allocated using regular dynamic memory allocations.

There are two ways to construct a string builder. Either with initialize buffer size or with unknown buffer size.

Here's an example:

Include the header file:

#include "Containers/StringFwd.h"

To create a string builder with an unknown buffer size:

FStringBuilderBase StringBuilder; // Note! This is using a regular dynamic memory allocation.

To create a string builder with initialize buffer size:

int32 BufferSize = 12; // 12 characters of TCHAR
TStringBuilder<BufferSize> StringBuilder;

Append characters to the string builder:

StringBuilder.Appendchar('H');
StringBuilder.Appendchar('e');
StringBuilder.Appendchar('l');
StringBuilder.Appendchar('l');
StringBuilder.Appendchar('o');
StringBuilder.Appendchar(',');
StringBuilder.Appendchar(' ');
StringBuilder.Appendchar('W');
StringBuilder.Appendchar('o');
StringBuilder.Appendchar('r');
StringBuilder.Appendchar('l');
StringBuilder.Appendchar('d');

// StringBuilder: { 'H', 'e', 'l', 'l', 'o', ',', ' ', 'W', 'o', 'r', 'l', 'd' }

In order to get the string either call ToString() or ToView() functions:

FString Str = StringBuilder.ToString();
FStringView StrView = StringBuilder.ToView();

You can also append a string as well:

// Note! The string builder will allocate more memory, if necessary.

// We only allocated 12 characters, and this call will make it go over bound.
// Causing to allocate more memory on heap.
StringBuilder.Append(TEXT(" and welcome!"));

// StringBuilder: { 'H', 'e', 'l', 'l', 'o', ',', ' ', 'W', 'o', 'r', 'l', 'd', ' ', 'a', 'n', 'd', ' ', 'w', 'e', 'l', 'c', 'o', 'm', 'e', '!' }

[!WARNING] The string builder will allocate more memory, if necessary.

Here's an another example:

TStringBuilder<256> MessageBuilder;

float PlayerHealth = 110.5285f;
MessageBuilder << TEXTVIEW("Player's health: ") << FString::SanitizeFloat(PlayerHealth);

return FString { MessageBuilder };

You can read more about it on Unreal's docs.

Template to store enumeration values as bytes in a type-safe way.

Here's an example:

Include the header file:

#include "Containers/EnumAsByte.h"

Declare a TEnumAsByte with the enumeration type ECollisionChannel:

TEnumAsByte<ECollisionChannel> Channel;

Get the value of the TEnumAsByte:

ECollisionChannel Val = Channel.GetValue();

Get the integer value of the TEnumAsByte:

int32 IntVal = Channel.GetIntValue();

Assign a new value to the TEnumAsByte

Channel = ECollisionChannel::ECC_Camera;

Log the values:

UE_LOG(LogTemp, Log, TEXT("Value of the: %i"), UEnum::GetValueAsName(Val));
UE_LOG(LogTemp, Log, TEXT("Integer value of the: %i"), IntVal);

[!NOTE] That regular enums are supported by UPROPERTY and replaces the need of using TEnumAsByte anymore.

You can read more about it on Unreal's docs.

Let's talk about what value type and reference types.

In various programming languages like Python³, Java⁵, and C#⁴, you may have encountered both value types and reference types.

A value type creates a copy when initialized from another variable. For instance, let's consider variable A, and when we initialize variable B with the value of A, a separate copy of the value is created in B. Essentially, B is an independent entity that holds its own value.

int A = 69;
int B = A; // A copy

On the other hand, a reference type directly references the memory location of the variable. In this case, when variable B is initialized by variable A, B becomes a reference to the same memory location as A. Consequently, any changes made to B will also affect A since B essentially points to the same underlying value as A.

int A = 69;
int& B = A; // A reference

Everything in C++ is value type by default. Even classes, which differ from C#⁴.

You can watch this video about references in C++ from Low Level Learning.

Here's an example:

#include <iostream>
#include <string>

struct Coords // Test struct and class
{
public:
    Coords(int x, int y)
        : X(x)
        , Y(y) {}

public:
    int X;
    int Y;

public:
    std::string toString() const
    {
        return "(" + std::to_string(X) +  ", " + std::to_string(Y) + ")";
    }
};

int main()
{
    Coords A(1, 2);
    Coords& B = A; // Test value type and reference type
    Coords* C = &B;
    Coords* D = new Coords(5, 10);
    Coords* E = &(*C); // Or &*C;

    B.X = 69;
    C->Y = 1337;
    D->Y = D->Y * 2;

    E = &*D;
    E->X = 10;

    std::cout << A.toString() << std::endl;
    std::cout << B.toString() << std::endl;
    std::cout << C->toString() << std::endl;
    std::cout << D->toString() << std::endl;
    std::cout << E->toString() << std::endl;

    delete D; // Remember: Delete raw pointers

    return 0;
}

With references, you can only assign them once, and they cannot be changed throughout the code. For example, you can have a direct reference to an argument passed into a function. This argument can then be modified within the function, similar to how an out parameter works in C#⁴.

Here's an example:

bool DamageHealth(int& Health)
{
   Health -= 100; // Modifying the value through the reference
   return Health <= 0;
}

int PlayerHealth = 100;

if (DamageHealth(PlayerHealth)) // Passing the `PlayerHealth` as a direct reference
{
   // Player just died!
}

And lastly, we have pointers. This section, will go over about raw pointers and smart pointers. If you have no clue about pointers, highly recommend watching Cherno about pointers.

Pointers and references are similar in that they both refer to variables, but there's one key difference. Pointers are indirect references, meaning they can change throughout the code, pointing to different variables. On the other hand, regular references are direct and can only refer to the specific variable they were initialized with.

In a short summary, a pointer is like writing down the address of a building on a piece of paper. The address on the paper tells you where the building is located, just as the memory address stored in the pointer variable tells you where a variable is located in memory. Similarly, you can also pass the address on the paper to someone else, allowing them to find the building too, just as you can pass a pointer variable to a function or another part of your code, allowing it to access the variable in memory.

Pointers are valuable tools in programming as they allow us to store memory addresses, enabling dynamic memory allocation and manipulation of data structures. By using pointers, we can create more flexible and efficient code that can adapt to changing data requirements during program execution.

Additionally, pointers are essential in scenarios like data structures, linked lists, and passing data to functions by reference, providing a level of control and precision that enhances the capabilities of the program. However, it's important to handle pointers with care, as incorrect usage can lead to memory leaks or segmentation faults.

A raw pointer can be sometime dangerous, because there is no validation when accessing this pointer. And when the pointer is pointing to nothing (meaning, the pointer is a nullptr). The program will throw a null pointer exception, also known as a segmentation fault (segfault).

A segmentation fault occurs when a program tries to access a memory location that it does not have permission to access, which can happen when the program tries to dereference a null pointer. When this happens, the operating system will usually terminate the program and generate an error message.

You can read more about raw pointers from Microsoft Learn.

To avoid this, you must check before if the pointer is valid, before using it.

Use the function called IsValid() for raw pointers.

Here's an example:

UPROPERTY()
AActor* ActorPtr = nullptr;

// Use UPROPERTY() macro, in order to tell the UHT (Unreal Header Tool), this pointer must be release into GC (garbage collector).
// If not, then this will cause a memory leak. Meaning, the pointer is still alive, even tough we are not using this memory block.

void KillActor()
{
  // IsValid() function also check if the pointer is not already destroyed by the GC (garbage collector).

  if (!IsValid(ActorPtr)) // The pointer has value of 'nullptr', therfore is NOT valid!
      return;

  ActorPtr->Destroy();
}

[!NOTE] ActorPtr is marked with UPROPERTY()in order to tell UHT⁶, that this pointer exists. When the pointer is unused, the garbage collector then marks it and deletes its memory. Also note, that this process can take a couple frames and is not instantaneously. Therefore, always use IsValid() function, which also checks if the pointer is not marked for the garbage collector. Avoid using manual checking, like this: PlayerCharacter != nullptr (since it will not work with GC system).

[!WARNING] If something else is referencing ActorPtr, the pointer will not be destroyed via garbage collection (unless if it's a weak pointer).

After Unreal Engine (5.0) version, is now recommending to use TObjectPtr instead of * to mark raw pointers. TObjectPtr class contains some optimization for the editor.

Here is the updated code:

UPROPERTY()
TObjectPtr<AActor> ActorPtr = nullptr;

In Unreal Engine, the Smart Pointer's library provides a set of template classes to manage memory and object ownership more efficiently and safely. These smart pointers automatically handle memory management, such as allocating and deallocating memory, and help prevent memory leaks and null pointer dereferences.

The key smart pointers in Unreal Engine's library include TSharedPtr, TWeakPtr, and TUniquePtr. They are designed to handle various ownership scenarios and provide a safer alternative to raw pointers.