C++ syntax

List initialization

Advantage: Doesn't allow narrowing, i.e. the following throws an error:

int i {2.0f};

Direct and copy initialization

Advantage: Doesn't create a copy (practical for objects):

T a(b); // direct initialization
T a = b; // copy initialization (temporary object created from b)
T a = T(b); // similar to previous line

Passing arguments by constant reference

Alternative to passing by value because:

Reference => Avoids making a copy, unlike pass by value.
Constant => Cannot by modified, like pass by value.

void foo(const string& s);

Const methods

It guarantees that the object it is being invoked on cannot be changed.

class MyClass {
public:
    int fct(int var) const;
}

Getter and setters

To avoid as much as possible for a better encapsulation.

Declaring a variable inside a loop

It's encouraged for primitive types as it reduces their scope while the variable is only allocated once.
For objects, the constructor and the destructor are called in every iteration.

Functors

Functors (function object) are classes which implement operator().
They operate like functions, but are capable of storing data in member variables.
Used for sorting std::vectors and for calculating the minimum and the maximum.

class Accumulator {
private:
    int m_counter{0};
public:
    Accumulator() {}
    int operator() (int i) {
        return (m_counter += i);
    }
};
 
int main() {
    Accumulator acc;
    std::cout << acc(10) << '\n'; // prints 10
    std::cout << acc(20) << '\n'; // prints 30
 
    return 0;
}

Base constructor in initialization list

The constructor of the base class can be called in a derived class inside the member initialization list.

class Base {
private:
    int m_id;
public:
    Base(int id): m_id{id} {}
}

class Derived: public Base {
private:
    double m_cost;
public:
    Derived(int id, double cost): Base(id), m_cost{cost} {} // note the call to Base's constructor
}

Pointers

int i = 3;
int* p = new int; // dynamic allocation of pointer (on the heap)
p = &i;
delete p; // release storage space allocated with new

Smart pointers

See this introductory youtube video.
Introduced in C++11, and are preferred to raw pointers.
Object that wraps a raw pointer to manage its lifetime (i.e. avoids memory leaks).
The wrapped pointer will be deleted once out of scope.
Unique pointer:
- Cannot be copied.
- Initialize with make_unique() to handle exceptions.

Vectors

std::vector<Type> allocates its Type elements on the heap (like a pointer or an array), and its header on the stack.

Passing functions as arguments

Same as function pointers in C (see example below).
There's a more convenient way to pass functions:

#include <functional>

int operation(int a, int b, std::function<int (int, int)> f) { return f(a, b) }

Inline functions

When the execution time of a small function is less than the switching time, the inline keyword tells the compiler to insert the code of the inline function where it is called.

h4k1m0u/cpp.md