Cpp

See plus plus :) .

Refer

1. Introduce
2. Fundamentals
3. String

11. Scope, duration, and linkage summary

A variable’s duration determines when it is created and destroyed. Variables with automatic duration: are created at the point of definition, and destroyed when the block they are part of is exited. This includes: - Local variables - Function parameters Variables with static duration: are created when the program begins and destroyed when the program ends. This includes: - Global variables - Static local variables Variables with dynamic duration: are created and destroyed by programmer request. This includes: - Dynamically allocated variables

extern static (or thread_local) storage duration and external linkage static static (or thread_local) storage duration and internal linkage thread_local thread storage duration mutable object allowed to be modified even if containing class is const auto automatic storage duration Deprecated in C++11 register automatic storage duration and hint to the compiler to place in a register Deprecated in C++17

• When you write an implementation file (.cpp, .cxx, etc) your compiler generates a translation unit. This is the source file from your implementation plus all the headers you #included in it. Internal linkage refers to everything only in scope of a translation unit. External linkage refers to things that exist beyond a particular translation unit. In other words, accessible through the whole program, which is the combination of all translation units (or object files).

11.1. Internal linkage

• An identifier’s linkage determines whether a declaration of that same identifier in a different scope refers to the same entity (object, function, reference, etc…) or not.

• An identifier with no linkage means another declaration of the same identifier refers to a unique entity. Entities whose identifiers have no linkage include: Local variables Program-defined type identifiers (such as enums and classes) declared inside a block

• An identifier with internal linkage means a declaration of the same identifier within the same translation unit refers to the same object or function. Entities whose identifiers have internal linkage include:

  • Static global variables (initialized or uninitialized)
  • Static functions
  • Const global variables
  • Unnamed namespaces and anything defined within them

• To make things to internal linkage, we can:

  • static global variables/functions
  • const and constexpr globals ((and thus don’t need the static keyword – if it is used, it will be ignored)) ## C
  • unnamed namespace { … } (modern C++)

• static <global_variable>: make the global variable to internal linkage

• static <local_variable>: changes its duration from automatic duration to static duration. And its initializer is only executed once.

• static <const/constexpr local_varialbe>: used to avoid expensive local object initialization each time a function is called because it inits once time.

• Internal linkage for const global variables can change to external with the keyword extern. e.g. extern const PI = 3.14;

• e.g.

// a.cpp ============================================================
#include <iostream>

static int g_internal { 42 };    // internal linkage (only in a.cpp)
static void helper() {           // internal function
    std::cout << "Helper in a.cpp\n";
}

int main() {
    std::cout << g_internal << '\n'; // OK
    helper();                         // OK
    return 0;
}

// main.cpp ============================================================
extern int g_internal; //  ERROR: g_internal not visible outside a.cpp
void helper();         //  ERROR: helper not visible outside a.cpp

int main() {
    // g_internal; // linker error if uncommented
    // helper();   // linker error if uncommented
    return 0;
}

11.2. External linkage

• An identifier with external linkage means a declaration of the same identifier within the entire program refers to the same object or function. Entities whose identifiers have external linkage include:

  • Non-static functions
  • Non-const global variables (initialized or uninitialized)
  • Extern const global variables
  • Inline const global variables
  • Namespaces

• functions: default external linkage

• global variables:

  • non-const globals: external by default.
  • const/constexpr globals: internal by default

• To access an external global variable from another file, use extern without initializer (forward declaration).

• e.g.

// a.cpp ============================================================
#include <iostream>

int g_external { 100 };            // external by default
extern const int g_limit { 200 };  // const made external

void sayHello() {                  // external by default
    std::cout << "Hello from a.cpp\n";
}

// main.cpp ============================================================
#include <iostream>

extern int g_external;       // forward declaration 
extern const int g_limit;    // forward declaration > < const int g_limit: definition
void sayHello();             // forward declaration

int main() {
    sayHello();
    std::cout << g_external << " / " << g_limit << '\n';
    return 0;
}

11.3. Inline functions and variables

When a call to min() is encountered, the CPU must store the address of the current instruction it is executing (so it knows where to return to later) along with the values of various CPU registers (so they can be restored upon returning). Then parameters x and y must be instantiated and then initialized. Then the execution path has to jump to the code in the min() function. When the function ends, the program has to jump back to the location of the function call, and the return value has to be copied so it can be output. This has to be done for each function call. All of the extra work that must happen to setup, facilitate, and/or cleanup after some task (in this case, making a function call) is called overhead. #include int min(int x, int y) { return (x < y) ? x : y; } int main() { std::cout « min(5, 6) « ‘\n’; std::cout « min(3, 2) « ‘\n’; return 0; } For functions that are large and/or perform complex tasks, the overhead of the function call is typically insignificant compared to the amount of time the function takes to run. However, for small functions (such as min() above), the overhead costs can be larger than the time needed to actually execute the function’s code! In cases where a small function is called often, using a function can result in a significant performance penalty over writing the same code in-place. However, inline expansion has its own potential cost: if the body of the function being expanded takes more instructions than the function call being replaced, then each inline expansion will cause the executable to grow larger.

• inline-expansion:
  • is a process where a function call is replaced by the code from the called function’s definition.
  • use this to avoid such overhead cost.
  • do not use the inline keyword to request inline expansion for your functions, because optimizing compilers.
• modernly-inline:
  • should not implement functions (with external linkage) in header files because it lead to multiple definitions error.
  • so we can use inline-function, it’s useful for header-only libraries

11.4. Sharing global constants

• 1. global constants as internal variables:
  • Advantages:
    • Works prior to C++16.
    • Can be used in constant expressions in any translation unit that includes them.
  • Downsides:
    • Changing anything in the header file requires recompiling files including the header.
    • Each translation unit including the header gets its own copy of the variable.
• e.g.

// constants.h:============================================================
#ifndef CONSTANTS_H
#define CONSTANTS_H

// Define your own namespace to hold constants
namespace constants
{
    // Global constants have internal linkage by default
    constexpr double pi { 3.14159 };
    constexpr double avogadro { 6.0221413e23 };
    constexpr double myGravity { 9.2 }; // m/s^2 -- gravity is light on this planet
    // ... other related constants
}
#endif

// main.cpp::============================================================
#include "constants.h" // include a copy of each constant in this file
#include <iostream>

int main()
{
    std::cout << "Enter a radius: ";
    double radius{};
    std::cin >> radius;

    std::cout << "The circumference is: " << 2 * radius * constants::pi << '\n';

    return 0;
}

• 2. global constants as external variables:
  • Advantages:
    • Works prior to C++16.
    • Only one copy of each variable is required.
    • Only requires recompilation of one file if the value of a constant changes.
  • Downsides:
    • Forward declarations and variable definitions are in separate files, and must be kept in sync.
    • Variables not usable in constant expressions outside of the file in which they are defined.
• e.g.

// constants.h:============================================================
#ifndef CONSTANTS_H
#define CONSTANTS_H

namespace constants
{
    // Since the actual variables are inside a namespace, the forward declarations need to be inside a namespace as well
    // We can't forward declare variables as constexpr, but we can forward declare them as (runtime) const
    extern const double pi;
    extern const double avogadro;
    extern const double myGravity;
}

#endif

// constants.cpp:============================================================
#include "constants.h"

namespace constants
{
    // We use extern to ensure these have external linkage
    extern constexpr double pi { 3.14159 };
    extern constexpr double avogadro { 6.0221413e23 };
    extern constexpr double myGravity { 9.2 }; // m/s^2 -- gravity is light on this planet
}

// main.cpp::============================================================
#include "constants.h" // include all the forward declarations
#include <iostream>

int main()
{
    std::cout << "Enter a radius: ";
    double radius{};
    std::cin >> radius;

    std::cout << "The circumference is: " << 2 * radius * constants::pi << '\n';

    return 0;
}

• 3. global constants as inline variables:
  • If you need global constants and your compiler is C++17 capable, prefer defining inline constexpr global variables in a header file.
  • Advantages:
    • Can be used in constant expressions in any translation unit that includes them.
    • Only one copy of each variable is required.
  • Downsides:
    • Only works in C++17 onward.
    • Changing anything in the header file requires recompiling files including the header.
• e.g.

// constants.h:============================================================
#ifndef CONSTANTS_H
#define CONSTANTS_H

// define your own namespace to hold constants
namespace constants
{
    inline constexpr double pi { 3.14159 }; // note: now inline constexpr
    inline constexpr double avogadro { 6.0221413e23 };
    inline constexpr double myGravity { 9.2 }; // m/s^2 -- gravity is light on this planet
    // ... other related constants
}
#endif

// main.cpp::============================================================
#include "constants.h"
#include <iostream>

int main()
{
    std::cout << "Enter a radius: ";
    double radius{};
    std::cin >> radius;

    std::cout << "The circumference is: " << 2 * radius * constants::pi << '\n';

    return 0;
}

13. Error Detection and Handling

14. Type Conversion, Type Aliases, and Type Deduction

Type conversions
│
├── Implicit conversions (compiler tự làm)
│   ├── Numeric promotions             ← an toàn, không mất dữ liệu
│   │    ├── char → int
│   │    └── float → double
│   │
│   └── Numeric conversions            ← có thể mất dữ liệu
│        ├── Widening conversions      ← mở rộng, thường an toàn (int → double)
│        └── Narrowing conversions     ← thu hẹp, có thể mất dữ liệu (double → int, int → char)
│
└── Explicit conversions (do lập trình viên ép kiểu)
     ├── static_cast<int>(3.14)
     ├── reinterpret_cast
     ├── const_cast
     └── (int)3.14   // C-style cast

14.1. Implicit type conversion

• Implicit type conversion is performed automatically by the compiler when an expression of some type is supplied in a context where some other type is expected.
• numeric promotion is the conversion of certain smaller numeric types to certain larger numeric types (typically int or double).no data loss.
  • floating point promotion: a value of type float can be converted to a value of type double.
  • integral promotions:
    • signed char or signed short can be converted to int.
    • unsigned char, char8_t, and unsigned short can be converted to int if int can hold the entire range of the type, or unsigned int otherwise.
    • If char is signed by default, it follows the signed char conversion rules above. If it is unsigned by default, it follows the unsigned char conversion rules above.
    • bool can be converted to int, with false becoming 0 and true becoming 1.
• numeric conversion is a type conversion between fundamental types that isn’t a numeric promotion. A narrowing conversion is a numeric conversion that may result in the loss of value or precision.
  • :( https://www.learncpp.com/cpp-tutorial/narrowing-conversions-list-initialization-and-constexpr-initializers/)

14.2. Explicit type conversion

• C++ supports 5 different types of casts: static_cast, dynamic_cast, const_cast, reinterpret_cast, and C-style casts
• 1. C-style casts
  • Using operator(<type>)value. and the value to convert to placed immediately to the right of the closing parenthesis ). e.g. (int)7/3
• 2. static_cast casts
  • Using `static_cast(value)
  • provides compile-time type checking
  • less powerful than a C-style cast
  • direct-initialized vs list-initialization

14.3. Typedefs and type aliases

• type aliases: use the using keyworld
  • using <NewtypeAlias> = <type>
• typedefs: is an old way of creating an alias for a type. Using typedef keyworld.
  • typedef <type> <NewtypeAlias>
• Prefer type alias over typedef

using MyDouble = double;
typedef double MyDouble;

typedef int (*FcnType)(double, char); // FcnType hard to find
using FcnType = int(*)(double, char); // FcnType easier to find

14.5. Type deduction using auto keyworld

• Type deduction allows the compiler to deduce the type of an object from the object’s initializer.
• using auto keyworld.
• Type deduction must have something to deduce from
• Type deduction drops const from the deduced type
• … (more)
• Use type deduction for your variables when the type of the object doesn’t matter.
• Auto can also be used as a function return type to have the compiler infer the function’s return type from the function’s return statements, though this should be avoided for normal functions.
• The auto keyword can also be used to declare functions using a trailing return syntax, where the return type is specified after the rest of the function prototype.
• e.g.

int add(int x, int y)
{
  return (x + y);
}

// Using the trailing return syntax, this could be equivalently written as:
auto add(int x, int y) -> int
{
  return (x + y);
}

#include <type_traits> // for std::common_type

std::common_type_t<int, double> compare(int, double);         // harder to read (where is the name of the function in this mess?)
auto compare(int, double) -> std::common_type_t<int, double>; // easier to read (we don't have to read the return type unless we care)

15. Function Overloading and Function Templates

15.1. Function overloading

• function overloading allows us to create multiple functions with the same name, so long as each identically named function has different parameter types/numbers. Return types are not considered for
• function delete using delete keywork. delete means “I forbid this”, not “this doesn’t exist”.
• e.g.

#include <iostream>

// This function will take precedence for arguments of type int
void printInt(int x)
{
    std::cout << x << '\n';
}

// This function template will take precedence for arguments of other types
// Since this function template is deleted, calls to it will halt compilation
template <typename T>
void printInt(T x) = delete;

int main()
{
    printInt(97);   // okay
    printInt('a');  // compile error
    printInt(true); // compile error

    return 0;
}

• default-arguments: is a default value provided for a function parameter. Parameters with default arguments must always be the rightmost parameters, and they are not used to differentiate functions when resolving overloaded functions.

15.2. Function Templates

• The template system was designed to simplify the process of creating functions (or classes) that are able to work with different data types (that are compiled and executed).
• template types are sometimes called generic types, and programming using templates is sometimes called generic programming.
• placeholder types use for any parameter types, return types, or types used in the function body that we want to be specified later, by the user of the template.
• template parameter declaration defines any template parameters that will be subsequently used.
• function templates allow us to create a function-like definition that serves as a pattern for creating related functions. In a function template, we use type template parameters as placeholders for any types we want to be specified later. The syntax that tells the compiler we’re defining a template and declares the template types is called a template parameter declaration.
• Using function templates in multiple files. should be defined in a header file, and then #included wherever needed.
• template argument deduction to have the compiler deduce the actual type that should be used from the argument types in the function call.
• e.g.

template <typename T> // this is the template parameter declaration defining T as a type template parameter , `typename` or `class` can be used
T max(T x, T y) // this is the function template definition for max<T>
{
    return (x < y) ? y : x;
}

template<>
int max<int>(int x, int y) // the generated function max<int>(int, int)
{
    return (x < y) ? y : x;
}

template<>
double max<double>(double x, double y) // the generated function max<double>(double, double)
{
    return (x < y) ? y : x;
}

int main()
{
    std::cout << max<int>(1, 2) << '\n'; // calls max<int>(int, int)
    std::cout << max<>(1, 2) << '\n';    // deduces max<int>(int, int) (non-template functions not considered)
    std::cout << max(1, 2) << '\n';      // calls max(int, int)

    return 0;
}

• function templates with multiple template types example:

#include <iostream>

template <typename T, typename U>
auto max(T x, U y) // ask compiler can figure out what the relevant return type is
{
    return (x < y) ? y : x;
}

int main()
{
    std::cout << max(2, 3.5) << '\n';

    return 0;
}

• non-type template parameter is a template parameter with a fixed type that serves as a placeholder for a constexpr value passed in as a template argument.

#include <iostream>

template <int N> // int non-type template parameter
void print()
{
    std::cout << N << '\n';
}

int main()
{
    print<5>();   // no conversion necessary
    print<'c'>(); // 'c' converted to type int, prints 99

    return 0;
}

16. Compound Types: References and Pointers

• Compound data types (also called composite data type) are data types that can be constructed from fundamental data types (or other compound data types).

16.1. lvalues and rvalues

• lvalues is an expression that evaluates to an identifiable object or function (or bit-field). Can be accessed via an identifier, reference, or pointer, and typically have a lifetime longer than a single expression or statement.
• rvalues is an expression that evaluate to a value. Only exist within the scope of the expression in which they are used.
• lvalues can be used anywhere an rvalue is expected.
• An assignment operation requires its left operand to be a modifiable lvalue expression. And its right operand to be a rvalue expression.

16.2. References

• references is an alias for an existing object/function. reference itself is like a const pointer

  • Declared as <type>& reference_name
  • Any operation on the reference is applied to the object being referenced.
  • All references must be initialized.
  • Cannot be reseated.
  • They aren’t objects
  • Can only accept modifiable lvalue arguments (const or non-const)

• pass-by-reference allows us:

  • to pass arguments to a function without making copies of those arguments each time the function is called. (class types)
  • to change the value of an argument

• pass-by-const-reference guaranteeing that the function can not change the value being referenced.

• lvalue-reference just a reference for an existing lvalue.

• lvalue-reference-types determines what type of object it can reference by using a single ampersand  <type>& .

• lvalue-reference-variable is a variable that acts as a reference to an lvalue.

• lvalue-reference-to-const can bind with const or non-const objects. const <type>& name

The const applies to what is immediately to its left, unless there’s nothing to its left, in which case it applies to what’s on the right.

• E.g.

#include <iostream>
#include <string>

// ---------------------------
// Example of references
// ---------------------------
void increment(int& x) {   // pass-by-reference (modifiable lvalue reference)
    x += 1;                // changes original argument
}

void printConstRef(const std::string& s) { // pass-by-const-reference
    // s cannot be modified here
    std::cout << "Const-ref: " << s << "\n";
}

int main() {
    int a = 10;
    
    // ---- Reference basics ----
    int& ref = a;       // reference must be initialized
    ref = 20;           // modifies 'a', since ref is just an alias
    std::cout << "a = " << a << "\n";  // prints 20
    
    // Cannot reseat: once 'ref' is bound to 'a', it cannot be bound to another variable
    int b = 30;
    // ref = &b;   invalid, would assign value instead of rebinding
    
    // ---- Pass by reference ----
    increment(a);  // modifies original 'a'
    std::cout << "a after increment = " << a << "\n"; // prints 21

    // ---- Pass by const reference ----
    std::string text = "Hello";
    printConstRef(text);  // avoids making a copy

    // ---- Lvalue reference variable ----
    int& lref = a;  // lref is an lvalue-reference-variable to 'a'
    lref += 5;      // modifies 'a'
    std::cout << "a after lref += 5: " << a << "\n";

    // ---- Lvalue reference to const ----
    const int x = 100;
    const int& cref1 = x; // bind to const object
    const int& cref2 = a; // also works with non-const object
    std::cout << "cref1 = " << cref1 << ", cref2 = " << cref2 << "\n";
    
    // ---- They aren't objects ----
    // sizeof(ref) == sizeof(a), because ref is just an alias
    std::cout << "sizeof(a) == sizeof(ref): "
              << (sizeof(a) == sizeof(ref)) << "\n";

    return 0;
}

16.3. Pointer

• address-of-operator (&) returns the memory address of its operand, but not as an address literal. Instead, it returns a pointer to the operand. This pointer holds the address value, and when passed to cout, the stream simply prints that value.

• dereference-operator  (*

  ) returns the value at a given memory address as an lvalue, used to access the object being pointed at.

• pointer is an object that holds a memory address as its value:

  • declared as <type>* ptr_name
  • This allows us to store the address of some other object to use later.
  • we should init the pointers.
  • the size of pointer is allways the same (32 or 64-bit architecture)
  • can assign an invalid pointer a new value, such as nullptr
  • wild pointer: pointer that has not been initialized is sometimes called a .
  • dangling pointer: pointer that is holding the address of an object that is no longer valid

• pointer-type is a type that specifies a pointer (like reference-type) by using an asterisk (<type>*).The type of the pointer has to match the type of the object being pointed at.

• null-pointer (its type is std::nullptr_t) means something has no value. It often associated with memory address 0.

• pointer-to-const: that points to a value that cannot be modified through the pointer, but the pointer itself is not const.

  • declared as const <type> ptr_name*.
  • cannot change the value being pointed to, but can make the pointer point to a different address.
  • may also point to non-const variables.

• const-pointer: whose stored address cannot be changed after initialization, but the value at that address can be modified.

  • declared as <type>* const ptr_name.
  • fixed to one address, but we can change the value at that address.

• const-pointer-to-const: cannot be reseated (address fixed) and cannot modify the value it points to.

  • declared as const <type>* const ptr_name.
  • can only be dereferenced to read the value.

pointer-to-pointer void allocateArray(int** ptr, int size) { ptr = new int[size]; // allocate memory and update the original pointer } int myArray = nullptr; allocateArray(&myArray, 5); myArray[0] = 10; // works delete[] myArray;

• e.g.

#include <iostream>
#include <cstdint>  // for uintptr_t

int main() {
    int x = 42;

    // address-of operator (&) returns a pointer to x (not an address literal)
    int* ptr = &x;  
    
    // Printing the pointer: cout prints the stored address value
    std::cout << "Address of x (&x): " << &x << "\n";
    std::cout << "Value stored in pointer (ptr): " << ptr << "\n";

    // dereference operator (*) gives access to the value at the stored address
    std::cout << "Value of x via *ptr: " << *ptr << "\n";

    // a pointer is an object that holds a memory address
    // we can change its value
    ptr = nullptr;  
    std::cout << "Pointer reset to nullptr: " << ptr << "\n";

    // pointer type is declared with '*'
    double d = 3.14;
    double* pd = &d;    // type matches: double* for double
    // uintptr_t lets us see the raw numeric value of the address
    std::cout << "Numeric address of d: " << (uintptr_t)pd << "\n";
    std::cout << "Value of d via *pd: " << *pd << "\n";
    
    // NullPTR =======
    int* myNullPtr {};        // value-initialized to nullptr
    int* myNullPtr2 {nullptr}; // explicitly initialized to nullptr

    // Old C-style (still works, but less safe in C++):
    // int* myNullPtr3 {NULL};   // requires <cstddef>
    
    // Const ptr =======
    int a = 10;
    int b = 20;
    // 1. pointer-to-const (const int*)
    const int* p1 = &a;      // can point to non-const variable
    // *p1 = 15;             //  error: cannot modify value through p1
    p1 = &b;                 //  can point to another address
    std::cout << "p1 points to: " << *p1 << '\n';
    // 2. const-pointer (int* const)
    int* const p2 = &a;      // must be initialized, fixed address
    *p2 = 30;                //  can modify the value at that address
    // p2 = &b;              //  error: cannot change stored address
    std::cout << "p2 points to: " << *p2 << '\n';
    // 3. const-pointer-to-const (const int* const)
    const int* const p3 = &b; // fixed address + read-only value
    // *p3 = 40;             //  error: cannot modify value
    // p3 = &a;              //  error: cannot reseat pointer
    std::cout << "p3 points to: " << *p3 << '\n';
       

    return 0;
}

• pointer-to-pointers:
  • a pointer that holds the address of another pointer.
  • Using two asterisks to declare a pointer to pointer.
  • e.g. int** ptrptr;
  • Usages:
    • Dynamically allocate an array of pointers
    • e.g. int** array { new int*[10] }; // allocate an array of 10 int pointers
    • Two-dimensional dynamically allocated arrays
    • e.g. int x { 7 }; // non-constant int (*array)[5] { new int[x][5] }; // rightmost dimension must be constexpr

• void-pointers: Also known as the generic pointer, is a special type of pointer that can be pointed at objects of any data type
  • Dereferencing a void pointer is illegal. Instead, the void pointer must first be cast to another pointer type before the dereference can be performed.
  • We do not know what type of object it is pointing to, deleting a void pointer will result in undefined behavior.

• function-pointers:

  • e.g.

        // fcnPtr is a pointer to a function that takes no arguments and returns an integer
        int (*fcnPtr)();
    

  • Assigning a function to a function pointer: just like a normal pointer, and the type (parameters and return type) of the function pointer must match the type of the function.

  • e.g.

    // function prototypes
    int foo();
    double goo();
    int hoo(int x);
    
    // function pointer initializers
    int (*fcnPtr1)(){ &foo };    // okay
    int (*fcnPtr2)(){ &goo };    // wrong -- return types don't match!
    double (*fcnPtr4)(){ &goo }; // okay
    fcnPtr1 = &hoo;              // wrong -- fcnPtr1 has no parameters, but hoo() does
    int (*fcnPtr3)(int){ &hoo }; // okay
    

  • Calling a function using function pointer: There are two way to do this

    • Explicitly derefence
    • Implicitly derefence

  • e.g.

    int foo(int x)
    {
        return x;
    }
    
    int main()
    {
        int (*fcnPtr)(int){ &foo }; // Initialize fcnPtr with function foo
        (*fcnPtr)(5); // call function foo(5) through fcnPtr.
    
    	int (*fcnPtr2)(int){ &foo }; // Initialize fcnPtr with function foo
        fcnPtr2(5); // call function foo(5) through fcnPtr2.
    
        return 0;
    }
    

  • Passing functions as arguments to other functions: One of the most useful things to do with function pointers is pass a function as an argument to another function. Functions used as arguments to another function are sometimes called callback functions.

16.4. Pass by value/reference/address

#include <iostream>
#include <string>

void printByValue(std::string val) // The function parameter is a copy of str
{
    std::cout << val << '\n'; // print the value via the copy
}

void printByReference(const std::string& ref) // The function parameter is a reference that binds to str
{
    std::cout << ref << '\n'; // print the value via the reference
}

void printByAddress(const std::string* ptr) // The function parameter is a pointer that holds the address of str
{
    std::cout << *ptr << '\n'; // print the value via the dereferenced pointer
}

int main()
{
    std::string str{ "Hello, world!" };

    printByValue(str); // pass str by value, makes a copy of str
    printByReference(str); // pass str by reference, does not make a copy of str
    printByAddress(&str); // pass str by address, does not make a copy of str

    return 0;
}

• pass-by-address allows us: ~ pass-by-references
  • to pass arguments to a function without making copies of those arguments each time the function is called. (class types)
  • to change the value of an argument
  • #null checking

Pass by reference when you can, pass by address when you must

• !! C++ really passes everything by value

16.5. Return by value/reference/address

• T returnValue(…): returns a copy (or move) of the object. The caller gets its own value.

• T& returnReference(…) returns a reference to an existing object. The caller does not own it, so the object must outlive the reference.

• T * returnAddress(…) returns a pointer (an address) to an object. The caller must handle the pointer carefully (ensure it’s valid and points to a live object).

• return-by-reference:

  • avoids making a copy of the object.
  • the referenced object must live beyond the scope of the function, otherwise the reference will dangle.
  • never return a non-static local variable or temporary by reference.

• return-by-address works almost identically to return-by-reference.

• return-by-value just make a copy

Prefer return by reference over return by address unless the ability to return “no object” (using nullptr) is important.

• e.g.

#include <iostream>

int global = 42;

// Return by value: makes a copy
int returnValue() {
    int x = 10;
    return x; // copy returned
}

// Return by reference: must refer to existing object
int& returnReference() {
    return global; // safe: global outlives the function
}

// Return by address: returns a pointer
int* returnAddress(bool valid) {
    if (valid)
        return &global; // valid pointer
    else
        return nullptr; // no object
}

int main() {
    int a = returnValue();
    std::cout << "By value: " << a << '\n';

    int& b = returnReference();
    std::cout << "By reference: " << b << '\n';
    b = 100; // modifies global
    std::cout << "Global after modification: " << global << '\n';

    int* c = returnAddress(true);
    if (c) std::cout << "By address: " << *c << '\n';

    int* d = returnAddress(false);
    if (!d) std::cout << "By address: got nullptr\n";
}

16.6. In/Out Params

• in-parameters:are typically passed by value or by const reference

• out-parameters:a function parameter that is used only for the purpose of returning information back to the caller.

  • Avoid out-parameters (except in the rare case where no better options exist).
  • Prefer pass by reference for non-optional out-parameters.

• e.g.

#include <iostream>
#include <string>

// In-parameter by value (cheap to copy)
void greet(std::string name) {
    std::cout << "Hello, " << name << "!\n";
}

// In-parameter by const reference (avoid copy for large objects)
int length(const std::string& text) {
    return text.size();
}

// Out-parameter by reference (rare case)
void square(int input, int& output) {
    output = input * input;
}

int main() {
    // in-parameter by value
    greet("Alice");

    // in-parameter by const reference
    std::string msg = "Hello World";
    std::cout << "Length = " << length(msg) << "\n";

    // out-parameter by reference (not preferred, but possible)
    int result;
    square(5, result);
    std::cout << "Square = " << result << "\n";
}

16.7. Type deduction (auto) with pointers, references, and const

https://www.learncpp.com/cpp-tutorial/type-deduction-with-pointers-references-and-const/

16.8. std::optional

https://www.learncpp.com/cpp-tutorial/stdoptional/

18. Compound Types: Enums and Structs

• program-defined-types are types that programmers create themself.

In C++, struct, class, and union automatically create a new type name, so you don’t need to prefix variables with the keywords struct or union as in C.

18.1. Enumerations

• enum is a compound types where every possible value is defined as a symbolic constant.
• Named starting with a capital letter. Named enumerators starting with a lower case letter.
• unscoped-enum: put their enumerator names into the same scope as the enumeration definition itself
• scoped-enum: keep their enumerators inside the enum’s own scope.Using enum class keyworld.
• using enum <EnumName> statement imports all the emnumerators from an enum into the current scope.
• putting your enumerations inside a named scope region (such as a namespace or class) so the enumerators don’t pollute the global namespace.
• Specify the base type of an enumeration only when necessary.
• e.g.

#include <iostream>
#include <cstdint>   // for uint8_t

//  Good naming style:
// Enum name: Capitalized
// Enumerator names: lowercase

enum Color {
    red,
    green,
    blue
};

//  Scoped enum — enumerators are inside the enum’s scope
enum class Shape {
    circle,
    square,
    triangle
};

//  Scoped enum inside a namespace — prevents name pollution
namespace Game {
    enum class Direction {
        up,
        down,
        left,
        right
    };
}

//  Scoped enum with explicit base type
enum class Status : uint8_t {
    ok = 0,
    error = 1,
    unknown = 2
};

int main() {
    // Using unscoped enum
    Color c = red;               //  direct access (same scope)
    std::cout << "Color value: " << c << "\n";

    // Using scoped enum
    Shape s = Shape::circle;     //  must use scope name
    if (s == Shape::circle)
        std::cout << "Shape is circle\n";

    // Scoped enum inside namespace
    Game::Direction dir = Game::Direction::up;
    if (dir == Game::Direction::up)
        std::cout << "Direction is up\n";

    // Scoped enum with base type
    Status st = Status::ok;
    if (st == Status::ok)
        std::cout << "Status OK (base type uint8_t)\n";

    return 0;
}

• Union: https://www.geeksforgeeks.org/cpp/cpp-unions/

18.2. Struct

• A struct is a class type (just like classes or union), allows us to bundle multiple variables together into a single type. As such, anything that applies to class types applies to structs.
• Defining structs using struct keywords.
• Access struct members:
  • Use member selection operator(dot operator) . for reference/object.
  • Use arrow operator -> for pointers. ptr->id = (*ptr).id
• Initialization:
  • using brace-initialization {} or by defining default member values.
  • should provide a default value for all members
  • Struct aggregate initializations:

    Employee frank = { 1, 32, 60000.0 }; // copy-list initialization using braced list
    Employee joe { 2, 28, 45000.0 };     // list initialization using braced list (preferred)

• Passing and returning structs:

  • Passingy reference (efficient and avoids copying)
  • Passing temporary
  • Create a struct variable and return
  • Returning a temporary (unnamed/anonymous) object

• Struct size and data structure alignment:the size of a struct will be at least as large as the size of all the variables it contains. But it could be larger! For performance reasons, the compiler will sometimes add gaps into structures this is called padding. We can minimize padding by defining your members in decreasing order of size.(e.g., double → int → char).

• e.g.

#include <iostream>
#include <string>
using namespace std;

// Define a struct
struct SensorData {
    double voltage{0.0};   // Default initialization
    int id{0};
    char status{'N'};      // 'N' = normal, 'E' = error
    string label{"Unknown"};

    // Member function
    void print() const { // Const class objects and const member functions
        cout << "Sensor " << id 
             << " [" << label << "] "
             << "Voltage: " << voltage 
             << " Status: " << status << endl;
    }
};

// Function that accepts struct by reference
void updateVoltage(SensorData &data, double newV) {
    data.voltage = newV;
}

// Function returning a temporary struct
SensorData makeSensor(int id, double v, const string &label) {
    return {v, id, 'N', label};
}

int main() {
    // Initialization using braces
    SensorData s1{3.3, 1, 'N', "Temperature"};
    s1.print();

    // Pointer access
    SensorData *ptr = &s1;
    ptr->status = 'E';
    ptr->print();

    // Passing by reference
    updateVoltage(s1, 4.8);
    s1.print();

    // Returning temporary struct
    SensorData s2 = makeSensor(2, 5.0, "Pressure");
    s2.print();

    cout << "Size of struct = " << sizeof(SensorData) << " bytes" << endl;
    return 0;
}

18.3. Class template

• a class template is a template definition for instantiating class types (structs, classes, or unions). Class template argument deduction (CTAD) is a C++17 feature that allows the compiler to deduce the template type arguments from an initializer.
• Using class template in a function:
• e.g.

#include <iostream>

template <typename T>
struct Pair
{
    T first{};
    T second{};
};

template <typename T>
constexpr T max(Pair<T> p)
{
    return (p.first < p.second ? p.second : p.first);
}

int main()
{
    Pair<int> p1{ 5, 6 };        // instantiates Pair<int> and creates object p1
    std::cout << p1.first << ' ' << p1.second << '\n';

    Pair<double> p2{ 1.2, 3.4 }; // instantiates Pair<double> and creates object p2
    std::cout << p2.first << ' ' << p2.second << '\n';

    Pair<double> p3{ 7.8, 9.0 }; // creates object p3 using prior definition for Pair<double>
    std::cout << p3.first << ' ' << p3.second << '\n';

    std::cout << max<int>(p1) << " is larger\n"; // explicit call to max<int>

    return 0;
}

// Compiler ===================================================================================
#include <iostream>

// A declaration for our Pair class template
// (we don't need the definition any more since it's not used)
template <typename T>
struct Pair;

// Explicitly define what Pair<int> looks like
template <> // tells the compiler this is a template type with no template parameters
struct Pair<int>
{
    int first{};
    int second{};
};

// Explicitly define what Pair<double> looks like
template <> // tells the compiler this is a template type with no template parameters
struct Pair<double>
{
    double first{};
    double second{};
};

int main()
{
    Pair<int> p1{ 5, 6 };        // instantiates Pair<int> and creates object p1
    std::cout << p1.first << ' ' << p1.second << '\n';

    Pair<double> p2{ 1.2, 3.4 }; // instantiates Pair<double> and creates object p2
    std::cout << p2.first << ' ' << p2.second << '\n';

    Pair<double> p3{ 7.8, 9.0 }; // creates object p3 using prior definition for Pair<double>
    std::cout << p3.first << ' ' << p3.second << '\n';

    return 0;
}

• Using class templates in multiple files:Just like function templates, class templates are typically defined in header files

• Alias templates: is a template that can be used to instantiate type aliases.

• e.g.

// Alias templates must be defined in global scope
template <typename T>
using Coord = Pair<T>; // Coord is an alias for Pair<T>

19. Classes

• A class is a user-defined blueprint used to create objects. It defines the properties and behaviors that all objects of that type share.

• An object is an instance of a class. It represents a real entity and contains actual values for the class’s attributes.

• An instance is a specific object created from a class. (In practice, “object” and “instance” are often used interchangeably.)

• Four Pillars of OOP in C++:

  • Abstraction is the process of hiding the implementation details and only showing the essential details or features to the user. It allows to focus on what an object does rather than how it does it. It is achieved using abstract classes (classes that have at least one pure virtual function).

  • Encapsulation is the process of bundling data and methods into a single unit (class) and restricting direct access to some components. Data is hidden and accessed through public methods. It is achieved using access specifiers like private, protected, and public.

  • Inheritance is a mechanism where a derived class acquires the properties and behaviors of a base class, forming an is-a relationship. It improves code reuse and extensibility. It is implemented using : followed by an access specifier public, private, protected.

  • Polymorphism means many forms. It allows the same interface (function or method) to behave differently depending on the context. It is achieved through: - Compile-time polymorphism: function overloading, operator overloading - Runtime polymorphism: virtual functions

• Overview:

// ===== File: main.cpp =====
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;

// ===== File: Person.h =====
class Person {
private:                       // (14.5) Data hiding and encapsulation
    string name;
    int age;

public:
    // (14.9) Constructor
    Person(string n, int a) : name{std::move(n)}, age{a} {
        cout << "Constructor: " << name << endl;
    }

    // (14.12) Delegating constructor
    Person() : Person("Unknown", 0) {}

    // (14.14) Copy constructor
    Person(const Person& other) : name{other.name}, age{other.age} {
        cout << "Copy constructor called for " << name << endl;
    }

    // (15.4) Destructor
    ~Person() {
        cout << "Destructor: " << name << endl;
    }

    // (14.3) Member function
    void print() const {  // (14.4) const member function
        cout << name << " (" << age << ")\n";
    }

    // (14.6) Access function
    string getName() const { return name; }
    int getAge() const { return age; }

    // (14.7) Return reference to data member
    int& getAgeRef() { return age; }

    // (14.16) Converting constructor (implicit)
    Person(int a) : name{"Anon"}, age{a} {}

    // (14.17) constexpr constructor (simple example)
    constexpr Person(const char* n, int a, bool) : name{n}, age{a} {}

    // (15.1) Function chaining using hidden this pointer
    Person& setName(const string& n) { name = n; return *this; }
    Person& setAge(int a) { age = a; return *this; }

    // (15.7) Static member function
    static void hello() { cout << "Hello from Person class!\n"; }

    // (15.8) Friend non-member function
    friend void showSecret(const Person& p);
};

// ===== File: Person.cpp =====
void showSecret(const Person& p) {   // (15.8) Friend function
    cout << "Friend: " << p.name << " is " << p.age << " years old.\n";
}

// ===== File: Employee.h =====
class Employee : public Person {    // Inheritance for demonstration
private:
    double salary;

public:
    Employee(string n, int a, double s)
        : Person(std::move(n), a), salary{s} {}

    void print() const {            // Override
        cout << "[Employee] ";
        Person::print();
        cout << "Salary: $" << salary << "\n";
    }

    // (15.9) Friend class
    friend class HR;
};

// ===== File: HR.h =====
class HR {
public:
    void adjustSalary(Employee& e, double newSalary) {
        e.salary = newSalary;
        cout << "HR adjusted salary!\n";
    }
};

// ===== File: Counter.h =====
class Counter {
private:
    static int count;   // (15.6) Static member variable

public:
    Counter() { ++count; }
    ~Counter() { --count; }
    static int getCount() { return count; } // (15.7)
};
int Counter::count = 0;

// ===== File: Box.h =====
// (15.5) Class template with member functions
template <typename T>
class Box {
private:
    T value;
public:
    explicit Box(T v) : value{v} {}
    T get() const { return value; }
    void set(T v) { value = v; }
};

// ===== File: main.cpp (continued) =====
int main() {
    cout << "=== OOP Example ===\n";

    // Constructors
    Person p1("Alice", 25);
    Person p2 = p1;              // Copy constructor
    Person p3;                   // Delegating constructor

    p1.print();

    // Function chaining
    p1.setName("Bob").setAge(30).print();

    // Static function
    Person::hello();

    // Friend function
    showSecret(p1);

    // Employee & HR
    Employee e1("Charlie", 35, 50000);
    HR hr;
    e1.print();
    hr.adjustSalary(e1, 60000);
    e1.print();

    // Static member variable usage
    Counter c1, c2;
    cout << "Counter count: " << Counter::getCount() << endl;

    // Template class
    Box<int> intBox(123);
    cout << "Box value: " << intBox.get() << endl;

    // (14.16) Implicit converting constructor
    Person p4 = 42;  // age=42, name="Anon"
    p4.print();

    // (14.17) constexpr example
    constexpr Person p5("ConstExpr", 10, true);
    p5.print();

    cout << "=== End ===\n";
    return 0;
}

19.0. Shallow copying & Deep copying

• Shallow copying:

  • C++ does not know much about our class, so the default copy constructor and default assignment operators use memberwise copy and then copy each member of the class individually.
  • Simple classes => work well.
  • Classes handling dynamically allocated memory => just copy the address of the pointer => does not allocate any memory => causes problems.

• Deep copying:

  • Allocates memory for the copy and then copies the actual values, so that the copy lives in memory distinct from the source.
  • The original and the copy will not affect each other in any way.
  • This requires write our own default copy constructor and default assigment operators

• Role of three:

If a class requires a user-defined destructor, a user-defined copy constructor, or a user-defined copy assignment operator, it almost certainly requires all three.This ensures proper resource management and avoids shallow copy problems.

• Role of five:

Extends the Rule of Three in C++11 and later. In addition to the destructor, copy constructor, and copy assignment operator, it includes the move constructor and move assignment operator. This allows efficient transfer of resources instead of copying.

• Role of zero:

The best practice is to write classes that do not manage resources directly, letting the compiler generate all special member functions automatically. This avoids the need to define destructors or copy/move operations manually.

19.1. Introduce

• A class is a program-defined compound type that can have many member variables with different types (this point is different from structure).

• A class is a program-defined compound type that bundles both data and functions that work on that data.

• Examples:

#include <iostream>
class MyClass{
private:
     int variable1;
     int variable2;
public:
    MyClass(int v1, int v2){
        variable1 = v1;
        variable2 = v2;
    }

    void printVariables(){
        std::cout << variable1 << "-" <<variable2;
    }
};

int main()
{
    std::cout<<"Hello Classes";
    MyClass myObject = MyClass(3,4);
    myObject.printVariables();
    return 0;
}

19.2. Member Variables/ Functions:

• The variable/functions that belong to a class type are called member variables/ functions.
• In C, structs only have data members, not member functions.

19.3. Const class objects and const member functions

• Const class objects: just like with normal variables, we can make our class type objects const or constexpr.
• Const member function: is a member function that guarentees it will not modify the object or call any non-constant member functions.
  • Syntax <returnType> <nameFunction> const(<params>){}

19.4. Temporary class objects

• A temporary object (sometimes called an anonymous object or an unnamed object) is an object that has no name and exists only for the duration of a single expression.
• e.g.

#include <iostream>

class IntPair
{
private:
    int m_x{};
    int m_y{};

public:
    IntPair(int x, int y)
        : m_x { x }, m_y { y }
    {}

    int x() const { return m_x; }
    int y() const{ return m_y; }
};

void print(IntPair p)
{
    std::cout << "(" << p.x() << ", " << p.y() << ")\n";
}

int main()
{
    // Case 1: Pass variable
    IntPair p { 3, 4 };
    print(p);

    // Case 2: Construct temporary IntPair and pass to function
	// When the function call returns, the temporary object is destroyed.
    print(IntPair { 5, 6 } );

    // Case 3: Implicitly convert { 7, 8 } to a temporary Intpair and pass to function
    print( { 7, 8 } );

    return 0;
}

19.5. Public and private members and access specifiers

• By default, all members of a struct are public members.
• By default, the members of a class are private.

19.6. Access functions

TODO:

19.7. Member functions returning references to data members

TODO:

19.8. Encapsulation - The benefits of data hiding

TODO:

19.9. Constructors

• We are normally using the aggregate to initialize the class type(Aggregate initialization means the use of brace-enclosed initializer lists to initialize all members of an aggregate (ie an array or struct)), but it does not work as soon as we make member variables private.
• A constructor is a special member function that is used to initialize class type objects. That is automatically called after a non-aggregate class type object is created.
  • perform initialization of any member variables (via a member initialization list)
  • perform other setup functions (via statements in the body of the constructor). This might include things such as error checking the initialization values, opening a file or database, etc…
• Syntax:
  • Constructors must have the same name as the class (with the same capitalization).
  • For template classes, this name excludes the template parameters.
  • Constructors have no return type (not even void).

19.10. Constructor - member initializer lists

• The member initializer list is defined after the constructor parameters. It begins with a colon (:), and then lists each member to initialize along with the initialization value for that variable, separated by a comma (,). We must use a direct form of initialization here (preferably using braces({}), but parentheses(()) works as well) .Using copy initialization (with an equals(=)) does not work here.

• e.g.:

Foo(int x, int y) : m_x { x }, m_y { y }
{
	// m_x  = x; this is an assignment
}

• Members in the member initializer list should be listed in the order in which they are defined in the class
• Prefer using the member initializer list to initialize your members over assigning values because in case where members are required to be initialized (such as for data members that are const or references) assignment will not work.

19.11. Constructor - Default and default arguments

• A default constructor is a constructor that accepts no arguments.
• Because constructors are functions, we can:
  • Constructors with default arguments
  • Overloaded constructors
• An implicit default constructor is generated by the compiler when the class has no user-declared constructors. This constructor has nothing.
• An explicitly default constructor is used in case we already create the constructor ourselves, but also want the compiler to generate the default constructor. Using keywork default
• e.g.

class Foo
{
private:
    int m_x {};
    int m_y {};

public:
    Foo() = default; // generates an explicitly defaulted default constructor

    Foo(int x, int y)
        : m_x { x }, m_y { y }
    {
        std::cout << "Foo(" << m_x << ", " << m_y << ") constructed\n";
    }
};

int main()
{
    Foo foo{}; // calls Foo() default constructor
		
    return 0;
}

19.12. Constructor - Delegating

• Delegating constructors allow to delegate (transfer responsibility for) initialization to another constructor from the same class type.
• Simply call the constructor in the member initializer list
• Use of the static keyword for the const variables member allows us to have a single member that is shared by all class objects.
• e.g.

#include <iostream>
#include <string>
#include <string_view>

class Employee
{
private:
    std::string m_name { "???" };
    int m_id { 0 };

public:
    Employee(std::string_view name)
        : Employee{ name, 0 } // delegate initialization to Employee(std::string_view, int) constructor
    {
    }

    Employee(std::string_view name, int id)
        : m_name{ name }, m_id { id } // actually initializes the members
    {
        std::cout << "Employee " << m_name << " created\n";
    }

};

int main()
{
    Employee e1{ "James" };
    Employee e2{ "Dave", 42 };
}

19.13. Constructor - Copy

• A copy constructor is a constructor that is used to initialize an object with an existing object of the same type. After the copy constructor executes, the newly created object should be a copy of the object passed in as the initializer.
• An implicit copy constructor: C++ will create a public implicit copy constructor for us if we do not provide a one.
• An explicitly copy constructor: by explicitly define our own copy constructor
• e.g.

    // Copy constructor
    Fraction(const Fraction& fraction)
        // Initialize our members using the corresponding member of the parameter
        : m_numerator{ fraction.m_numerator }
        , m_denominator{ fraction.m_denominator }
    {
        // do other things
    }

• Using = default to generate a default copy constructor.
• Using = delete to prevent copies.

    // Explicitly request default copy constructor
    Fraction(const Fraction& fraction) = default;
    Fraction fCopy { f };
	
    // Delete the copy constructor so no copies can be made
    Fraction(const Fraction& fraction) = delete;
	Fraction f { 5, 3 };
	Fraction fCopy { f }; // compile error: copy constructor has been deleted

The rule of three is a well known C++ principle that states that if a class requires a user-defined copy constructor, destructor, or copy assignment operator, then it probably requires all three. In C++11, this was expanded to the rule of five, which adds the move constructor and move assignment operator to the list. Not following the rule of three/rule of five is likely to lead to malfunctioning code. We’ll revisit the rule of three and rule of five when we cover dynamic memory allocation

19.14. Class initialization and copy elision

• For variables:

int a;         // no initializer (default initialization)
int b = 5;     // initializer after equals sign (copy initialization)
int c( 6 );    // initializer in parentheses (direct initialization)

// List initialization methods (C++11)
int d { 7 };   // initializer in braces (direct list initialization)
int e = { 8 }; // initializer in braces after equals sign (copy list initialization)
int f {};      // initializer is empty braces (value initialization)

• For object with class types:

#include <iostream>

class Foo
{
public:

    // Default constructor
    Foo()
    {
        std::cout << "Foo()\n";
    }

    // Normal constructor
    Foo(int x)
    {
        std::cout << "Foo(int) " << x << '\n';
    }

    // Copy constructor
    Foo(const Foo&)
    {
        std::cout << "Foo(const Foo&)\n";
    }
};

int main()
{
    // Calls Foo() default constructor
    Foo f1;           // default initialization
    Foo f2{};         // value initialization (preferred)

    // Calls foo(int) normal constructor
    Foo f3 = 3;       // copy initialization (non-explicit constructors only)
    Foo f4(4);        // direct initialization
    Foo f5{ 5 };      // direct list initialization (preferred)
    Foo f6 = { 6 };   // copy list initialization (non-explicit constructors only)

    // Calls foo(const Foo&) copy constructor
    Foo f7 = f3;      // copy initialization
    Foo f8(f3);       // direct initialization
    Foo f9{ f3 };     // direct list initialization (preferred)
    Foo f10 = { f3 }; // copy list initialization

    return 0;
}

• For all types of initialization:
  • When initializing a class type, the set of constructors for that class are examined, and overload resolution is used to determine the best matching constructor. This may involve implicit conversion of arguments.
  • When initializing a non-class type, the implicit conversion rules are used to determine whether an implicit conversion exists.
  • List initialization disallows narrowing conversions.
  • Copy initialization only considers non-explicit constructors/conversion functions.
  • List initialization prioritizes matching list constructors over other matching constructors.

19.15. Converting constructors and the explicit keyword

• For example:

#include <iostream>

class Foo
{
private:
    int m_x{};
public:
    Foo(int x)
        : m_x{ x }
    {
    }

    int getX() const { return m_x; }
};

void printFoo(Foo f) // has a Foo parameter
{
    std::cout << f.getX();
}

int main()
{
    printFoo(5); // we're supplying an int argument

    return 0;
}

• The compiler will look to see if there is any constructor that it can be use to perform (5) -> Foo.

• A converting constructor is a constructor that can be used to perform an implicit conversion is called a converting constructor. By default, all constructors are converting constructors.

• Only one user-defined conversion may be applied.

  
  

• The explicit keyword is used to to tell the compiler that a constructor should not be used as a converting constructor.

  • For constructors with a separate declaration (inside the class) and definition (outside the class), the explicit keyword is used only on the declaration.
  • Explicit constructors can be used for direct and direct list initialization
  • Prefer use this key work for constructors that take a single argument.

• e.g.

#include <iostream>

class Dollars
{
private:
    int m_dollars{};

public:
    explicit Dollars(int d) // now explicit
        : m_dollars{ d }
    {
    }

    int getDollars() const { return m_dollars; }
};

void print(Dollars d)
{
    std::cout << "$" << d.getDollars();
}

int main()
{
    print(5); // compilation error because Dollars(int) is explicit
	Dollars d1(5); // ok
    Dollars d2{5}; // ok
    return 0;
}

• Return by value and explicit constructors: when we return a value from a function, if that value does not match the return type of the function, an implicit conversion will occur. Just like with pass by value, such conversions cannot use explicit constructors.
• e.g.

#include <iostream>

class Foo
{
public:
    explicit Foo() // note: explicit (just for sake of example)
    {
    }

    explicit Foo(int x) // note: explicit
    {
    }
};

Foo getFoo()
{
    // explicit Foo() cases
    return Foo{ };   // ok
    return { };      // error: can't implicitly convert initializer list to Foo

    // explicit Foo(int) cases
    return 5;        // error: can't implicitly convert int to Foo
    return Foo{ 5 }; // ok
    return { 5 };    // error: can't implicitly convert initializer list to Foo
}

int main()
{
    return 0;
}

19.16. Constexpr aggregates and classes:

@TODO:

19.17. The hidden “this” pointer and member function chaining

• Cpp utilizes a hidden pointer named this. This is a const pointer that holds the address of the current implicit object.
• e.g.

simple.setID(2); 
Simple::setID(&simple, 2); // note that simple has been changed from an object prefix to a function argument!

// implementation
void setID(int id) { m_id = id; }
static void setID(Simple* const this, int id) { this->m_id = id; }

• Explainations:
  • When we call simple.setID(2), the compiler actually calls Simple::setID(&simple, 2), and simple is passed by address to the function. The function has a hidden parameter named this which receives the address of simple. Member variables inside setID() are prefixed with this->, which points to simple. So when the compiler evaluates this->m_id, it’s actually resolving to simple.m_id.
  • All non-static member functions have a this const pointer that holds the address of the implicit object. this always points to the object being operated on
  • Using this to create a reset function for a class back to default state:create a new object (using the default constructor), and then assign that new object to the current implicit object

void reset()
{
    *this = {}; // value initialize a new object and overwrite the implicit object
}

• this and const objects:

#include <iostream>
using namespace std;

class Something {
private:
    int value;

public:
    Something(int v) : value(v) {}

    // Non-const member function
    void setValue(int v) {
        cout << "Non-const setValue() called" << endl;
        value = v;  // allowed: can modify object
    }

    // Const member function
    int getValue() const {
        cout << "Const getValue() called" << endl;
        // value = 10; //  would be an error: cannot modify inside const function
        return value;
    }

    // Non-const getValue (overload)
    int getValue() {
        cout << "Non-const getValue() called" << endl;
        return value;
    }
};

int main() {
    Something a(5);
    const Something b(10);

    // Non-const object: can call both const and non-const functions
    cout << a.getValue() << endl;  // calls non-const version
    a.setValue(7);                 // OK
    cout << a.getValue() << endl;

    // Const object: can only call const functions
    cout << b.getValue() << endl;  // calls const version
    // b.setValue(20);             // error: cannot call non-const on const object

    return 0;
}

Why this a pointer and not a reference: Since the this pointer always points to the implicit object (and can never be a null pointer unless we’ve done something to cause undefined behavior), you may be wondering why this is a pointer instead of a reference. The answer is simple: when this was added to C++, references didn’t exist yet.

19.18. Classes and header files

• Member functions can be defined outside the class definition just like non-member functions. The only difference is that we must prefix the member function names with the name of the class type so the compiler knows we’re defining a member of that class type rather than a non-member. e.g. void MyClass::myFnc(){//}.
  • Putting class definitions in a header file.
  • Prefer to put your class definitions in a header file with the same name as the class.
  • Trivial member functions (such as access functions, constructors with empty bodies,Default arguments for member functions, etc…) can be defined inside the class definition.
  • Prefer to define non-trivial member functions in a source file with the same name as the class.
• Inline member functions:
  • Member functions defined inside the class definition are implicitly inline.
  • Member functions defined outside the class definition are not implicitly inline (and thus are subject to the one definition per program part of the one-definition rule). This is why such functions are usually defined in a code file (where they will only have one definition across the whole program).
  • Alternatively, member functions defined outside the class definition can be left in the header file if they are made inline.
• e.g.

// Date.h:
#ifndef DATE_H
#define DATE_H

class Date
{
private:
    int m_year{};
    int m_month{};
    int m_day{};

public:
    Date(int year, int month, int day);

    void print() const;

    int getYear() const { return m_year; }
    int getMonth() const { return m_month; }
    int getDay() const { return m_day; }
};

#endif

// Date.cpp
#include "Date.h"

Date::Date(int year, int month, int day) // constructor definition
    : m_year{ year }
    , m_month{ month }
    , m_day{ day }
{
}

void Date::print() const // print function definition
{
    std::cout << "Date(" << m_year << ", " << m_month << ", " << m_day << ")\n";
};

19.19. Nested types (member types)

• Class types support another kind of member: nested types (also called member types). To create a nested type, you simply define the type inside the class, under the appropriate access specifier.
• Define any nested types at the top of your class type.
• Outside the class, we must use the fully qualified name: OuterClass::InerClass p{};
• nested classes are members of the outer class, they can access any private members of the outer class that are in scope.
• A nested type cannot be forward declared prior to the definition of the enclosing class.\ư

19.20. Destructors

• For example, the classes that use a resource (most often memory, but sometimes files, databases, network connections, etc…) often need to be explicitly sent or closed before the class object using them is destroyed. In other cases, we may want to do some record-keeping prior to the destruction of the object, such as writing information to a log file, or sending a piece of telemetry to a server. The term “clean up” is often used to refer to any set of tasks that a class must perform before an object of the class is destroyed in order to behave as expected. If we have to rely on the user of such a class to ensure that the function that performs clean up is called prior to the object being destroyed, we are likely to run into errors somewhere.

• destructor is a special member function that is called automatically when an object of a non-aggregate class type is destroyed.

• Syntax:

  • The destructor must have the same name as the class, preceded by a tilde (~).
  • The destructor can not take arguments.
  • The destructor has no return type.

• A class can only have a single destructor.

• An implicit destructor: If a non-aggregate class type object has no user-declared destructor, the compiler will generate a destructor with an empty body. It is effectively just a placeholder.

• e.g.

class NetworkData
{
private:
    std::string m_serverName{};
    DataStore m_dataQueue{};

public:
	NetworkData(std::string_view serverName)
		: m_serverName { serverName }
	{
	}

	~NetworkData()
	{
		sendData(); // make sure all data is sent before object is destroyed
	}

	void addData(std::string_view data)
	{
		m_dataQueue.add(data);
	}

	void sendData()
	{
		// connect to server
		// send all data
		// clear data
	}
};

int main()
{
    NetworkData n("someipAddress");

    n.addData("somedata1");
    n.addData("somedata2");

    return 0;
}