Introduction to C++

• C++ benefits from great platform support, enabling code execution on any platform with a compiler.
• C++ compiles directly to machine code, resulting in fast execution speeds.
• Java and other similar languages runs on a virtual machine.

Low-Level Control

• C++'s low-level nature grants control over memory allocation through pointers, making it suitable for applications requiring memory and time optimization.

Error Types

• Compile-time errors occur during the translation of .cpp files into object files.
• Link errors arise when the linker combines object files, often indicated by "LNK" prefixes.
• Runtime errors manifest post-compilation, leading to crashes or unexpected behavior.

Pointers

• Pointers store memory addresses, treating memory as a linear sequence.
• The asterisk * symbolizes a pointer, while & retrieves a variable's address.
• Pointer size is 4 bytes on 32-bit systems, equating to 32 bits, which can address 2^32 memory locations.
• Pointer size is 8 bytes on 64-bit systems.
• Bytes are represented by 2 hexadecimal.

Variables

• Variables are stored in memory, either on the stack or the heap.
• Primitive data types determine variable sizes in bytes.
• Code handles variables based on their declared data types.
• The statement char a = 65; std::cout << a; treats 65 as a character, outputting 'A'.
• int occupies 4 bytes, with one bit indicating the sign.
• unsigned int values are always positive, employing the sign bit to expand the maximum positive range.
• The unsigned keyword can be applied to any data type to remove the sign bit.
• Common data types and their sizes:
• char: 1 byte
• short: 2 bytes
• long: 4 bytes
• long long: 8 bytes
• float: 4 bytes
• double: 8 bytes
• bool: 1 byte
• Although a boolean value could technically be represented by a single bit, the smallest addressable unit in memory is a byte.
• 1 byte can store 8 boolean values.

Deepcopy

• Deepcopy is often used for arrays, sets, strings, in which the instance contains a pointer, requiring instance variables.
• This copies the pointed memory rather than just the pointer itself, preventing issues of "shallow" copies where multiple objects point to the same data, leading to unintended modifications.
• C++ supports copy constructors for creating deep copies.

Memory Segments: Heap, Stack, and Data

• Heap: Variable lifetime extends until the program's completion. Memory is freed upon variable deletion but not zeroed out.
• Stack: Stores variables with lifetimes limited by their scope, along with function calls. Memory is considered unallocated but retains old values.
• Data segment: Stores global and static variables allocated before runtime, persisting until the program ends.

Static Keyword

• Static controls linkage and lifetime, placing variables in the data segment.
• Static variables are initialized only once before program execution begins.
• Inside a function, a static variable belongs to that function as a nonlocal variable.
• Inside a class, it belongs to the class itself.
• A global static variable is confined to the .cpp file it's declared in.
• Static local variables retain assigned memory locations throughout a program's execution.
• Static member variables remain in memory until the program finishes and must be initialized like global variables.
• Static members are shared among all class instances, belonging to the class rather than specific instances.
• Can be accessed even if the class has not been instantiated in main
• They cannot access non-static members because they belong to the class, not the instance.
• Static member functions belong to the class and can only access static variables, callable via the class name.
• Global static variables are visible only within their containing .cpp file.

Preprocessor Directives

• #include <iostream> looks for the iostream file and copies all the content into the current file
• #pragma once includes the this file only once

Pass by Reference

• "address individual bits" cannot be done, only bytes.
• Pass by reference means the function modifies the original variable.

Classes

• Member variables are private by default.
• Structs are the same as Classes, except members are public by default.
• Use structs to only hold and manipulate data. Nothing else.
• Static members are shared among all instances. You must declare it (outside the class) in the .cpp file as int Player::shared_var;

Virtual Functions

• When using inheritance in classes
• Compiler uses V-table to perform dynamic dispatch
• V-Table stores virtual functions of the base/parent class
• Virtual function causes extra memory and extra time (to look up V table)

Pure Virtual Function

• abstract methods within a class
• base class doesn't have full implementation
• enforce subclasses implementation
• cannot instantiate that class
• virtual void anAbstractMethod() = 0;

Member Initializer List

• Use to initialize member variables of a class
• explicit InitializerExample(std::string n) : name(n)

Pointers

• Double Pointer double* points to double values
• For While loops "execute code once no matter what"
• Use preprocessor to replace code before compilation

Stack versus Heap

• Stack: has predefined size and limit. Gives us memory by moving a pointer but we can't change the pointer. (is VERY FAST)
• Heap: new keyword allocates memory on the heap using malloc. (IS MUCH SLOWER)

Macros

• Kinda like find and replace
• Example: #define WAIT std::cin.get()
• But don't do that

Auto

• Type inference
• Compiler infers the type of whatever you initialized something with

Static Array

• Stores size, and throws out of bounds errors, as well, unlike normal arrays

Function Pointers

• Void (*pointerName)(const char*) = &Log;

Lambda Function

• Anonymous function, since they don't have explicit names
• Function that is defined inline
• Use capture to use outside variables inside the lambda function via []
• Everything we captured is in capture scope

Namespace

• Use to avoid naming conflicts

Threads

• To start a Thread you must pass in a void function
• Mutex locks a thread so no other thread can access it at the same time. This must be unlocked as well.
• Compiler transforms C++ code into machine code.
• If you get an error, prints output at compile time
• Then Linker links the code together.
• Converts the cpp into obj files