cpp-notes

You can use the -ggdb flag to compile in debug mode and -O2 -DNDEBUG to compile with the best optimizations.

Disable compiler-specific extensions and strictly follow the C++ standard by adding the -pedantic-errors flag.

You should enable warnings for the best learning experience. Enable them using- -Wall -Weffc++ -Wextra -Wconversion -Wsign-conversion To treat warnings as errors, add -Werror flag.

Compiler flags are -std=c++11, -std=c++14, -std=c++17, -std=c++20, -std=c++2b

A statement is an instruction in a computer program that tells the computer to perform an action.

1. Declaration Statements
2. Jump Statements
3. Expression Statements
4. Compound Statements
5. Selection Statements (Conditionals)
6. Iteration Statements
7. Try Blocks

1. Assignment When variables are assigned using the = operator, value on the right hand side is copied to the variable on the left hand side, known as copy assignment.
2. Initialization
   1. Default Initialization No initial value is provided.
   2. Copy Initialization Initializer is provided after equal sign. Use of this is discouraged because it is considered inefficient. int a = 5;
   3. Direct Initialization Initializer is provided inside parenthesis. Use of this is also discouraged, because it is confusing to read and is superseded by list initialization. int a(5);

   4. List Initialization Modern way. It does not allow narrow conversions because narrow conversions can cause data loss. Introduced in C++17.

      int a {5}; // direct list initialization
      int a = {5}; // copy list initialization
      int a{}; // value list initialization
      int a{4.5} // ERROR while a(4.5) or a = 4.5 won't give any error
      

Implementation-defined behavior means the behavior of some syntax is left up to the implementation (the compiler) to define. Such behaviors must be consistent and documented, but different compilers may produce different results. One example of this is using the sizeof operator. It will product different results on different platforms.

1. Variable names should begin with lowercase characters.
2. Function names should begin with lowercase characters.
3. Identifier names starting with capital letters represent user defined types.
4. camelCase or snake_case both are fine but stay consistent.
5. You may mix them like snake_case for variable names and camelCase for function names.
6. Do not start names with underscore _ (bad practice but not impossible).

A literal is a constant value inserted directly in the source code.

int a = 5;
std::cout << a << std::endl;  // a is a variable not a literal constant
std::cout << 10 << std::endl; // 10 is a literal constant

Operators perform operations on its inputs and return an output. The number of inputs an operator can take is called its arity. Some operators like throw and delete do not return any value. Operators which are mainly used for their side effects like x = 5 always return their left operand (x in this case). For example, x = y = 5 is the same as writing x = (y = 5).

Expressions are like phrases in English, they are part of statements just like phrases are part of sentences. Expressions do not end with a semi-colon and they cannot be executed themselves. Some examples of expressions-

a = 5              // has a side-effect of assigning "a" to 5 and evaluates to "a"
5 + 6              // evaluates to 11
"Hello, World!"    // evaluates to itself
std::cout << "Hey" // evaluates to std::cout

Ending an expression with a semi-colon ; will cause the statement to execute properly and such expressions are called Expression Statements. Sub-expressions are expressions used as operands in other expressions. Compound expressions have two or more operators like x = 5 + 3 has two operators, = and +.

The main function can return integers to specify if the program ran successfully or not. Two macros, EXIT_SUCCESS and EXIT_FAILURE are defined in the cstdlib.

#include <cstdlib>

int main() {
  return EXIT_SUCCESS;
}

A value defining function which does not return any value will produce undefined results.

• Parameters are defined in the function header and arguments are passed when calling it.

• If you have a parameter that is no longer used in the body but can't remove the corresponding argument from all function calls, you can just remove the identifier-

  void test(int /*name*/) {
    // indentifier removed from parameter list
    // to avoid breaking previous function calls
    // and prevent unused parameter warning
  }
  

  IMPORTANT! Note that in clang, arguments are parsed from left to right while in g++, arguments are parsed from right to left!

1. Within a file, each function, variable, type or template can only have one definition (except variables in different local scopes) (violation causes compile error)
2. With a program (multiple files), each variable can have only one definition (violation causes linker error)
3. Types, templates, inline functions, and inline variables are allowed to have duplicate definitions in different files, so long as each definition is identical (violation causes undefined behaviour).

• A namespace provides a scope region called the namespace scope which means that any thing defined in that scope won't be mistaken for anything else with the same name defined in some other namespace.
• Only declarations and definitions can appear in a namespace.
• The :: operator is called the scope resolution operator. It's left operand is the namespace name (if blank, global is used) and the right operator is the symbol.
• When an identifier uses the :: operator, it's called a qualified name.
• Using using namespace <name> is considered bad practice since it can lead to many conflicts in the future.

• A preprocessor is a program which makes various changes to the code file before compiling it. For example, stripping out comments, making sure the each file ends with a newline character etc, evaluating the preprocessor directives, etc..
• It does not make changes to the original files, instead it creates temporary files for this called "translation units".
• The translation unit is what is actually compiled by the compiler.

1. Comment out code
2. Use std::cerr instead of std::cout because std::cerr is unbuffered so output is instant.
3. Printing values.

Using debug statements isn't recommended since they can clutter your code.

Since the size of int is different on different compilers on different platforms, standard int was declared in the cstdint library.

#include <cstdint>

int main() {
  std::int8_t one; // 1 byte integer
  std::uint8_t two; // 1 byte unsigned integer
  std::int16_t three; // 2 byte integer
  std::uint16_t four; // 2 byte unsigned integer
  std::int32_t five; // 4 byte integer
  std::uint32_t six; // 4 byte unsigned integer
  std::int64_t seven; // 8 byte integer
  std::uint64_t eight; // 8 byte unsigned integer
  return 0;
}

The above may be slower on some hardware. For example, 32 bit integers may be slower than 64 bit integers on a 64bit CPU so the following types were created:

#include <cstdint>

int main() {
  std::int_fast32_t a; // will give the fastest integer having atleast 32 bits
  std::int_least32_t b; // will give the smallest integer having atleast 32 bits
  return 0;
}

Note that in many compilers, int_fast8_t and int_least8_t behave like char instead of integer values so prefer using the 16bit versions. So, if you try to print a variable of type int_fast8_t with the value 65 (for example), it will print A instead!!

• This type is used to represent size or length of objects.
• The data type of the value returned by the sizeof operator is also std::size_t.
• It is guaranteed to be unsigned and has the size of the largest possible integer the machine can hold.
• Any object with a size larger than the largest value an object of type std::size_t can hold is considered ill-formed.

• By default, std::cout displays only upto 6 significant digits of floating point numbers. You can change the precision by using std::cout << std::setprecision(<any number>).
• Prefer double over float for better precision.

• In binary, a simple decimal number like 0.1 is represented in an infinite sequence 0.00011001100… causing it to be less precise.

  #include <iostream>
  #include <iomanip>
  
  int main() {
    double a{0.1};
    std::cout << std::setprecision(20);
    std::cout << a << std::endl;
  
    double b{};
    b = 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1; // should be equal to 1.0
    std::cout << b << std::endl;
  
    if (a == b) std::cout << "YES";
    else std::cout << "NO";
    return 0;
  }
  

• No need to import stdbool like in C to use true and false.
• Sending true and false values to stdout prints 0 and 1 instead.

• To print true and false instead, do this-

  #include <iostream>
  
  int main() {
    bool a {false};
    bool b {!a};
    std::cout << a << " " << b << std::endl;
    std::cout << std::boolalpha; // causes bools to print as "true" or "false"
    std::cout << a << " " << b << std::endl;
    return 0;
  }
  

• Unlike C, where we convert types using (<type>) variable to cast to different types, in C++, we use static_cast operator.

  #include <iostream>
  
  void print(double x) {
    std::cout << x << std::endl;
  }
  
  int main() {
    int a{5};
    print(static_cast<double>(a));
    return 0;
  }
  

  The static_cast operator will produce undefined behavior if the value being converted doesn’t fit in range of the new type.

You may use these decimals by prefixing the following-

• 0x for hexadecimal, eg- int a{0x1F}
• 0 for octal, eg- int a{012}
• 0b for binary, eg- int a{0b1100011} (c++14 onwards)

By default, std::cout outputs values in decimals. You can specify the output type using-

#include <iostream>
#include <bitset> // for std::bitset

int main() {
  int x{69420};
  // Decimal
  std::cout << x << std::endl;

  // Octal
  std::cout << std::oct;
  std::cout << x << std::endl;

  // Hexadecimal
  std::cout << std::hex;
  std::cout << x << std::endl;

  // Binary
  std::cout << std::bitset<16>{0b10110} << std::endl;
  return 0;
}

In C++20 and C++23, better options are available-

#include <iostream>
#include <format> // C++20
// #include <print> // C++23

int main() {
  std::cout << std::format("{:b}\n", 0b1100101);
  std::cout << std::format("{:#b}\n", 0b1100101);
  // std::print("{:#b}\n", 0b1100101); C++23
  return 0;
}

(set-frame-parameter nil 'alpha-background 10)
(add-to-list 'default-frame-alist '(alpha-background . 10))

An expression that contains only compile time constants.

const int a = { 5 + 7 }; // Will be evaluated at compile-time
int a = { 5 + 7 }; // Might be evaluated at runtime, depends on the compiler

Using const can let the compiler know that the variable will absolutely not change whatsoever, so it can optimize it!

Only const integral variables with a constant expression initializer are compile-time constants. So, doubles or floats do not count. Types like char, bool, int, long, unsigned long etc can be considered.

• It is sometimes very hard to distinguish whether an expression evaluates to a compile-time constant or not, so we can use constexpr keyword to tell the compiler that it's a compile time constant (using const doesn't guarantee it because it just means that the variable's value cannot be changed).

constexpr int a { 5 + 7 }; // Will be evaluated at compile-time instead of run-time

• Every function call has a cost. Whenever a function call is made, the CPU has to save the current state of the program, jump to the function, execute it, and then jump back to the original location and restore the state. This is called function call overhead.
• Inline functions are functions whose definition is expanded in-place instead of being called. This reduces the function call overhead.
• The inline keyword just suggests the compiler to make the function inline, it is not guaranteed to do so.
• Inline functions perform better when they are small and are called frequently.
• Inline functions are allowed to be defined in multiple translation units in modern C++!
• Every inline definition must be identical and are mostly defined in header files.

inline is_even(int x) {
  return x % 2 == 0;
}

• As stated above, constexpr is used to tell the compiler that a variable is a compile-time constant.

• constexpr can be used with functions to tell the compiler that the function is a compile-time function.

  constexpr int greater(int x, int y) {
    return (x > y ? x : y);
  }
  

• If the parameters passed to a constexpr function are not compile-time constants, the function will be evaluated at run-time.
• If the return value is not being used in a context where a compile-time constant is required, the function may or may not be evaluated at run-time.

#include <iostream>
#include <type_traits> // for std::is_constant_evaluated

constexpr int greater(int x, int y) {
  return (x > y ? x : y);
}

int main() {
  constexpr int p {greater(5, 6)}; // always a compile time constant
  std::cout << p << std::endl;

  std::cout << greater(5, 6) << std::endl; // may be a compile time constant
  return 0;
}

• We can force functions which will be used in a context where a compile-time constant is required to be evaluated at compile-time using the consteval keyword.
• Only available in C++20.

#include <iostream>

consteval bool getbigger(int a, int b) {
  return (a > b ? a : b);
}
int main() {
  constexpr int a{getbigger(5, 6)};
  std::cout << a << std::endl; // ok

  std::cout << getbigger(5, 6) << std::endl; // ok

  int x {5}; // not constexpr
  std::cout << getbigger(x, 6) << std::endl; // error
  return 0;
}

• These functions are compile-time functions so they aren't very flexible during run-time.
• consteval and constexpr functions are implicitly inline because the compiler needs to see the full definition at all times where the function is called.

• C like strings are avoided because they are hard to work with and can be unsafe.

#include <iostream>
#include <string>

int main() {
  std::string name {"Prayag"};
  name = "Prayag Jain"; // can be reassigned
  std::cout << name << std::endl;
  return 0;
}

• You can use std::getline() to read strings in C++.

#include <iostream>
#include <string>

int main() {
  std::string str;
  std::cout << "Enter name: ";

  // std::cin >> std::ws is an expression which ultimately returns std::cin
  std::getline(std::cin >> std::ws, str);

  std::cout << "Hi there, " << str << "!" << std::endl;
  return 0;
}

• std::ws is an input manipulator which allows getline to ignore any leading whitespace characters already present in the input buffer.
• std::ws is not preserved across calls so it must be used with every getline call.
• Use str.length() or std::ssize(str) (defined in <string>) to get the length of a string named str.
• Initializing using std::string is expensive, so do not pass them by value in functions.
• Normal string literals with double quotes around them are C-Style string literals, E.g. "hello".
• Using the suffix std::string_literals::s will form an std::string literal, E.g. "hello"std::string_literals::s.

• Whenever an std:string is initialized, the string literal provided is copied into the string object (expensive operation).
• Even in functions, when an std::string is passed by value, it is copied into the function parameter (expensive operation).
• std::string_view is a lightweight alternative to std::string.
• Always prefer std::string_view over std::string unless you need to modify the string.
• It lives under the <string_view> header.
• Assigning a new string to a std::string_view will not change the original string, it will just point to the new string.
• You can use the std::string_view_literals::sv suffix to form a std::string_view literal.
• Unlike std::string, std::string_view can be used in constexpr contexts.
• The remove_prefix(count) and remove_suffix(count) member functions can be used to remove a prefix or suffix from a string view (does NOT modify the referenced string, just the view).

#include <string_view>
#include <iostream>

int main() {
  std::string_view str {"Hello, World!"};
  std::cout << str << std::endl;;

  str.remove_prefix(2); // remove the first two characters
  str.remove_suffix(2); // remove the last two characters
  std::cout << str << std::endl;
  return 0;
}

• It's the / operator we use to divide its two operands.
• If one of the operands is a float, the operator performs floating point division.
• If both operands are integers, the operator performs integer division and removes the fractional part.
• If we want to divide two integers and get a float, we can use the static_cast<type> operator to cast one of the operands to a float/double.

• x,y means first evaluate x, then evaluate y and finally return the value of y

• Floating points are dangerous to compare using the traditional comparison operators like ==, < and > because of rounding errors.
• Use the nearly equal algorithm which makes use of relative epsilons to check if two floating points are nearly equal.

1. >> (right shift) (eg- 0011 >> 1 = 0001, 0011 >> 2 = 0000)
2. << (left shift) (eg- 0011 << 1 = 0110, 0011 << 2 = 1100)
3. & (bitwise and) (eg- 0101 & 0011 = 0001)
4. | (bitwise or) (eg- 0101 | 0011 = 0111) (only one bit should be 1 to be evaluated as true)
5. ^ (bitwise xor) (eg- 0101 ^ 0011 = 0110)
6. ~ (bitwise not) (eg- ~0101 = 1010)

• Used to block bitwise operators from modifying bits we don't want in a bitset, much like we use masking tape to block paint from touching certain parts of the product we're painting.
• We can define bit masks as normal integers using either binary literals (c++14 or above) or by converting binary numbers to other literals such as decimals or hexadecimals.

• Signed integers are typically stored in two's complement format.
• In two's complement, the most significant bit (left most bit) is used to represent the sign of the number.
• 0 means positive and 1 means negative.
• To convert a decimal number to a negative binary number, we invert all the bits and add 1.
• Example, to convert -5 to binary, we first convert 5 to binary (0101) and then invert all the bits (1010) and add 1 (1011).
• We add 1 because we need to represent 0 as 0000 and not 1111.

#include <iostream>

namespace Foo {
  namespace Goo {
    int a {5};
  }
}

int main() {
  namespace fg = Foo::Goo;
  std::cout << fg::a << std::endl;
  return 0;
}

Avoid deeply nested namespaces!

• Whenever a name is defined in a scope, it hides any other name with the same name in the outer scope.
• You should generally avoid variable shadowing.
• In g++, you can use the -Wshadow flag to get warnings about shadowing.

• Linkage is the property of an identifier which specifies whether it can be used in other translation units.
• There are three types of linkages-
  1. External Linkage
  2. Internal Linkage
  3. No Linkage
• Local variables have no linkage.
• Non constant global variables have external linkage by default while constant global variables have internal linkage by default.
• To make global variables have internal linkage, use the static keyword.
• Functions have external linkage by default but can also be made to have internal linkage using the static keyword.

It is recommended to give internal linkage to all global variables and functions that are not used in other translation units.

// Internal global variables definitions:
static int g_x;          // defines non-initialized internal global variable (zero initialized by default)
static int g_x{ 1 };     // defines initialized internal global variable

const int g_y { 2 };     // defines initialized internal global const variable
constexpr int g_y { 3 }; // defines initialized internal global constexpr variable

// Internal function definitions:
static int foo() {};     // defines internal function

• To make a variable or function have external linkage, use the extern keyword.
• Global variables and functions have external linkage by default so you don't need to use the extern keyword.

If you want to define an uninitialized non-const global variable, do not use the extern keyword, otherwise C++ will think you’re trying to make a forward declaration for the variable

• constexpr can be made to have external linkage by using the extern keyword however they can not be forward declared.

// External global variable definitions:
int g_x;                       // defines non-initialized external global variable (zero initialized by default)
extern const int g_x{ 1 };     // defines initialized const external global variable
extern constexpr int g_x{ 2 }; // defines initialized constexpr external global variable

// Forward declarations
extern int g_y;                // forward declaration for non-constant global variable
extern const int g_y;          // forward declaration for const global variable
extern constexpr int g_y;      // not allowed: constexpr variables can't be forward declared

• They can be changed from anywhere in the program.

Dynamic initialization of global variables causes a lot of problems in C++. Avoid dynamic initialization whenever possible.

• Prefer using namespaces to avoid name collisions.
• In functions, prefer passing variables as parameters instead of using global variables.

• You can create header files, define a namespace, define the constants as constexpr and then include the header file in all files where you want to use the constants.
• This approach has some downsides-
  1. If the header file is used in 20 files, the definitions will be duplicated 20 times and each file will have to be recompiled if the header file is changed.
  2. If the constants are large, it will increase memory usage because of duplication!
• Another approach is to define a namespace in a .cpp file, define the constants using extern const in the namespace, forward declare the constants in a .h header file and then include the header file in all files where you want to use the constants.
• This approach also has some downsides-
  1. These constants will now be considered compile-time only in the .cpp file in which they are defined because the linker will only see the forward declaration from the header file.

• For C++17 and above, you can use inline variables to define global constants.
• These variables are better than macros because they are type safe and can be debugged.
• They are better than global constants because they are not duplicated across files.

• Prefer using them over the above two methods of sharing global variables across files.

  constants.h

  #IFNDEF CONSTANTS_H
  #DEFINE CONSTANTS_H
  namespace constants {
    inline constexpr double pi {3.14159};
  }
  #ENDIF
  

• Using the static keyword on local variables changes its duration to be created at the start of the program and destroyed at the end.
• It is common to use the s_ prefix on static variable identifiers.
• You should avoid static local variables unless the variable never needs to be reset as this can cause confusion.

A qualified name is one which has been resolved using the namespace operator (::) or the member selection operators (., ->). For example, std::cout, std::pow(5, 3), student.name etc..

#include <iostream>

int main() {
  using namespace std; // importing the entire namespace into the current scope
  return 0;
}

Prefer explicit namespaces over using-statements. Avoid using-directives whenever possible. Using-declarations are okay to use inside blocks.

• Statements that just contain the semicolon ;.

#include <iostream>

int main() {
  if (1)
    ;
  return 0;
}

• Consider the following code-

  #include <iostream>
  
  int main() {
    constexpr double pi {3.14};
    if (pi == 3.14) {
      std::cout << ("Hello World") << std::endl;
    } else {
      std::cout << ("Goodbye World") << std::endl; // This will never be printed
    }
    return 0;
  }
  

• The condition above is always true.

• This is wasteful at runtime so C++17 introduced constexpr if statements-

  #include <iostream>
  
  int main() {
    constexpr double pi {3.14};
    if constexpr (pi == 3.14)
      std::cout << "pi is 3.14" << std::endl;
    else
      std::cout << "pi is not 3.14" << std::endl;
    return 0;
  }
  

• When using switch statements, if we do not use the break or return keyword, the cases following the matched case will also be executed which is known as a fallthrough.
• This is not desired mostly but when it is, we can tell the compiler to avoid giving a warning by using the [[fallthrough]] attribute.

#include <iostream>

int main() {
  switch (2) {
  case 1:
    std::cout << "1" << std::endl;
    break;
  case 2:
    std::cout << "2" << std::endl;
    [[fallthrough]];
  case 3:
    std::cout << "3" << std::endl;
    break;
  }
  return 0;
}

Note that the semicolon used along with the [[fallthrough]] attribute is a null statement.

• You can halt a program using std::exit() from cstdlib.
• This function does not, however, clean up memory reserved for the local variables.
• Always use the std::atexit(callback) function which runs the callback function provided to it whenever std::exit() has been called.

You should never use halt functions explicitly unless there's no safe way to exit the program.

• In the <random> library, there are 6 PRNGs available for use (as of C++20).

• We should only use the Mersenne twister PRNG out of all the other built-in methods (if you don't have the choice to use third party libraries).
• mt19937 generates 32 bit unsigned integers while mt19937_64 generates 64 bit unsigned integers.

#include <iostream>
#include <random>

int main() {
  std::mt19937 mt{}; // initializing
  std::cout << mt() << std::endl; // using mt() is the preferred way to call the mt.operator() method
  return 0;
}

• To generate numbers within a range with unbiased results (i.e. each number has an equal chance of being generated), we can use the std::uniform_int_distribution class.

#include <iostream>
#include <random>

int main() {
  std::mt19937 mt{};

  std::uniform_int_distribution dice{1,6};

  // printing a bunch of random numbers
  for (int count {1}; count <= 40; count++) {
    std::cout << dice(mt) << ' ';
  }
  return 0;
}

• We can use std::chrono to seed the PRNG with the current time (it stores the time in "ticks" which is usually in nanoseconds or microseconds!).

#include <iostream>
#include <random>
#include <chrono>

int main() {
  std::mt19937 mt{static_cast<std::mt19937::result_type>(std::chrono::steady_clock::now().time_since_epoch().count())};

  std::uniform_int_distribution dice{1,6};

  for (int i {1}; i <= 40; i++) {
    std::cout << dice(mt) << ' ';
  }
}

• You can also seed using the system's random device (recommended over system time)-

#include <iostream>
#include <random>

int main() {
  std::mt19937 mt{std::random_device{}()};

  std::uniform_int_distribution dice{1,6};
  for (int i {0}; i < 40; i++)
    std::cout << dice(mt) << ' ';
  return 0;
}

std::random_device also generates random numbers but should not be used as a PRNG because it is implementation defined, may not be available on all platforms, and might produce low quality results on different compilers.

• The internal state of Mersenne twister is 624 bytes in size.
• The seeds we provided above were only 4 bytes in size causing the PRNG to be heavily underseeded.
• std::seed_seq can be used to provide a seed sequence to the PRNG.
• We can provide as many random values to std::seed_seq as we want and it generate unbiased seed values with the required size for the PRNG.

#include <iostream>
#include <random>

int main() {
  std::random_device rd{};
  std::seed_seq ss{rd(), rd(), rd(), rd(), rd(), rd(), rd(), rd()}; // 8 random integers
  std::mt19937 mt{ss}; // initializing using the seed sequence

  std::uniform_int_distribution dice{1,6};

  for(int i {0}; i < 40; i++)
    std::cout << dice(mt) << ' ';

  return 0;
}

• Informal testing is the process of testing a program by running it and observing its behaviour.
• After writing a program, you just run it with a few different inputs and see if it works as expected.
• We can write functions that test's the program's functions by comparing their outputs with expected results.
• You can also use assert to check if a condition is true and if it isn't, the program will halt.

• Code coverage is a measure of how much of the code is executed when the program is executed while testing.
• Similarly, the term statement coverage refers to the percentage of statements that are executed during testing.
• Branch coverage refers to the percentage of branches that are executed during testing.
• Loop coverage says that if you have a loop, you should test it with 0, 1, and 2 iterations. If it works for the second iteration, it will work for all other iterations.

• Errors that occur when the program is running and are not caught by the compiler (logical type of errors).
• Some semantic errors include:
  • Division by zero
  • Precision errors
  • Comparison logical errors
  • Not using blocks for if statements

• Most of the time, errors are caused because the programmer made some faulty assumptions like the user will always enter a number when the program asks for a number, the student being look up will always be in the database, etc.

• Preconditions are the conditions that must be true before a function is called.
• An invariant is a condition that must be true while some section of code is executing. This is often used with loops, where the loop body will only execute so long as the invariant is true.
• Postconditions are the conditions that must be true after a function is called.

• Performed automatically by the compiler.
• If the conversion can not be performed, the compiler will throw an error.

• From a floating point type to an integer type (unless it's constexpr or decimal places are zero).
• From an integral type to a floating type.
• From an integral type to a narrower integral type (unless it's constexpr or in range).
• These are unsafe and should be avoided.
• In some cases, you may want to explicitly do a narrowing conversion. You can do this using the static_cast operator.

• We use the using keyword to define type aliases.

using Distance = double;
Distance homeToSchool {3.55};

• It's a convention to name aliases starting with a capital letter.
• We can also use typedef from C in C++ (but it's only present for backwards compatibility and its syntax can get very confusing).
• The std::int8_t type is just an alias to char which is exactly why we get a character value when using it.

• We defining a variable, for example double distance {5.76};, the literal 5.76 has the type double and we have explicitly mentioned double as the data type of distance, providing the same information twice.
• The compiler can deduce the type automatically in such cases using- auto distance {5.76};

• Type deduction doesn't work if the return value of a function is void, for example-

  #include <iostream>
  
  void test() {
    // test
  }
  
  int main() {
    auto a {test()}; // Not valid
    return 0;
  }
  

• Using auto will drop const and constexpr from the type.

constexpr int num {5};
auto a {num}; // a is of type int, not constexpr int

constexpr auto b {num}; // b is of type constexpr int

• Normal string literals default to the type const char*, so to use std::string or std::string_view, use literal suffixes- "hello"std::literals::s or "hello"std::literals::sv.
• In such cases, it may be better to not use auto and just use the type explicitly.

• You can also use auto with functions, however this is NOT recommended.

  auto add(int a, int b) {
    return a + b;
  }
  

• The following is also valid

  auto add(int a, int b) -> int {
    return a + b;
  }
  

• Type deductions can't be used for function parameters, like int add(auto a, autob); is not valid.

• The compiler differentiates between functions by looking at the number of parameters and their types.
• The return type of a function is not considered when differentiating between functions.
• Qualifiers like const are also not considered when differentiating between functions.

• Resolving overloaded function calls is the process of the compiler choosing which function to call when an overloaded function is called.
• It goes through these steps-
  1. The compiler will look for an exact match for the function call.
  2. If step 1 fails, the compiler will perform numeric promotions and look for a match.
  3. If step 2 fails, the compiler will perform numeric conversions and look for a match.
  4. If step 3 fails, the compiler will look for a match using the user-defined conversions.
  5. If step 4 fails, the compiler will look for a matching function that uses ellipsis.
  6. If step 5 fails, the compiler will throw an error.

• You can prohibit certain function calls by using the delete keyword.

#include <iostream>
int add(int a, int b) {
  return a + b;
}

void add(char a, char b) = delete; // if called, the program will not compile
void add(double a, double b) = delete; // if called, the program will not compile

int main() {
  add(5, 3);
  add('a', 'b'); // will not compile
  add(5.5, 3.3); // will not compile
  return 0;
}

• Default arguments are used to provide a default value for a function parameter.
• The default arguments should be specified in forward declarations (function prototype) and not in the function definition.
• Example: int add(int a, int b = 0);

BEST PRACTICE: If the function has a forward declaration (especially one in a header file), put the default argument there. Otherwise, put the default argument in the function definition. For example, in the forward declaration do this int add(int x=5, int y=7) and in the definition, do this int add(int x, int y).

• You can define function templates inside header files since they are exempted from the one definition rule.
• This allows the compiler to see the full definition of the template and instantiate functions whenever needed.
• Using forward declarations won't work for function templates.

• For C++20 and above only.

• Defines a simple shorthand to create function templates-

  // This is a shorthand to the template definition below
  auto add(auto a, auto b) {
    return a + b;
  }
  
  // The above is the shorthand to this
  template <typename T, typename U>
  audo add(T a, U b) {
          return a + b;
  }
  

• A template parameter used to represent a constexpr value.
• The following types are accepted as template parameters-
  1. Integral types
  2. Enumeration type
  3. Floating Point type (since C++20)
  4. Literal class types (since C++20)
  5. Etc…
• From C++17 onwards, you can use the auto keyword to automatically let the compiler deduce the non-type template parameter from the template argument.

#include <iostream>
template <int N>
void print() {
  std::cout << N << std::endl;
}

int main() {
  print<5>();
  return 0;
}

• Rvalue expressions are expressions which evaluate to a value.
• Lvalue expressions are expressions which evaluate to identifiable objects.

If you're not sure if an expression is an lvalue or not, remember that all lvalues can be referenced using the & operator while rvalues can not. For example, &x, where x is a variable (something like &5 won't work since 5 is an rvalue expression).

• Lvalue expressions are implicitly converted to rvalue expressions when they are provided in places where rvalues were expected.
• Lvalues are of two types, modifiable (non-const) and non-modifiable (const).
• C-style string literalls are rvalues.

• An lvalue reference acts as an alias for an existing lvalue.

• It is declared using the & operator

  int // int type
  int& // lvalue reference to an int
  double& // lvalue reference to a double
  

• We can create lvalue reference variables like this

int age {10};
int& referenceToAge {age};

• References must always be initialized.
• Once initialized, a reference can not be changed to refer to another object.
• References are not objects in C++. They aren't required to be stored in memory. The compiler might also replace all occurances of the reference with the referent to optimize.
• The above point is the reason why you can not have references to references in C++.

int x {10};
int& ref {x}; // reference to x
int& ref2 {ref}; // this will work because it's NOT a reference to ref, it's a reference to x

• Lvalue references can not bind to non-modifiable lvalues (non-const).

const int x {10};
int& ref {x}; // not allowed

• Type deductions using the auto keyword will drop references.

int x {10};
int& y {x}; // reference to x

auto z {y}; // z is of type int, not int&
auto& z2 {y}; // z2 is of type int&

• Type deductions using auto will drop references first and only then it will drop top-level consts.

#include <string>
const std::string& getConstRef(); // some function that returns a const reference
int main() {
    auto ref1{ getConstRef() };        // std::string (reference and top-level const dropped)
    const auto ref2{ getConstRef() };  // const std::string (reference dropped, const reapplied)
    auto& ref3{ getConstRef() };       // const std::string& (reference reapplied, low-level const not dropped)
    const auto& ref4{ getConstRef() }; // const std::string& (reference and const reapplied)
    return 0;
}

• When the object that a reference refers to is destroyed, the reference becomes a dangling reference.

• To make lvalue references bind to non-modifiable lvalues, use the const keyword.

const int x {10};
const int& ref {x}; // allowed

int y {20};
const int& ref2 {y}; // allowed, but ref2 can not be used to modify y

Always use lvalue references to const when you don't need to modify the referent.

• Lvalue references to const can also bind to rvalues.

  const int& ref {5}; // allowed
  

• In the above example, a temporary object will be created to store the value 5 and the reference will bind to that temporary object.
• This will increase the lifetime of the temporary object to the lifetime of the reference.

• Reduces the overhead of copying large objects.

#include <iostream>

void hello(std::string& name) {
  std::cout << name << std::endl;
}

int main() {
  std::string text {"Hello World"};
  hello(text);
  return 0;
}

As a rule of thumb, pass fundamental types by value and class (or struct) types by references. Other common types to pass by value: enumerated types and std::string_view. Other common types to pass by (const) reference: std::string, std::array, and std::vector.

• For objects that are cheap to copy, the cost of copying is similar to the cost of binding, so we favor pass by value so the code generated will be faster.
• For objects that are expensive to copy, the cost of the copy dominates, so we favor pass by (const) reference to avoid making a copy.
• std::string_view is better than std::string& because when passing different types of strings (c-style string literals, string_view, string), the std::string_view will be able to reference all those types easily, while passing types other than std::string to a std::string& will require the compiler to make a temporary std::string object (by implicit conversion or copy).

• When returning values from a function, a copy is returned.
• This may be expensive for class types.

#include <iostream>
// notice the ampersand (&) in the return type
const int& foo() {
  static constexpr int age {20}; // destroyed at the end of the program
  return age;
}
int main() {
  std::cout << foo() << std::endl;
  return 0;
}

Avoid returning non-const static values as references.

• Initializing a reference returned by a function to a non reference variable will make a copy of the return value which defeats the entire purpose of returning a reference.

const int& foo() {
  static const int age {20};
  return age;
}

int main() {
  const int age {foo()}; // BAD: Defeats the purpose of returning reference from foo()
  const int& age2 {foo()}; // GOOD
  return 0;
}

• Parameters which are used to receive input from the function caller are called in parameters.
• Parameters which are used to send output to the function caller are called out parameters (for example, references and pointers which are used to modify the original object from inside the function).

• Pointers which store invalid addresses are called dangling pointers.
• Dereferencing such pointers leads to undefined behaviour.

• Can be initialized using direct list initialization like this- int* ptr {};
• They don't point to any address.
• Can later be assigned an address.
• We can use the nullptr literal to initialize a null pointer explicitly- int* ptr {nullptr};
• nullptr has the type std::nullptr_t. So whenever nullptr is used to initialize a pointer variable, it is implicitly converted from std::nullptr_t to the required type.

int main() {
  int* ptr {nullptr}; // can initialize using nullptr
  int* anotherPtr {};

  anotherPtr = nullptr; // can also assign to nullptr literal later

  foo(nullptr); // can also pass nullptr literal to functions
  if (ptr == nullptr) std::cout << "No";

  // null pointers (nullptr) are implicitly converted to boolean value FALSE and pointers that hold addresses to TRUE
  if (ptr) std::cout << "The pointer, the pointer is real";
  return 0;
}

• Dereferencing a null pointer also results in undefined behaviour.

• You can not assign a non-const pointer to a const variable.

const int age {5};
int* agePtr {&age}; // compile error!!

const int* agePtr2 {&age}; // will work!
agePtr2 = {&someOtherVariable}; // will still work!

• A pointer to a const is not a const itself, so you can change the address it is pointing to.
• A pointer to a const, when pointing to a non-const variable will not allow you to modify the value at the address it is pointing to.

• This is different from a pointer to a const.
• A const pointer is a pointer whose address can not be changed once initialized.

int age {5};
int* const agePtr {&age};

agePtr = {&someOtherVariable}; // NOT ALLOWED

• The combination of both the above!

int age {5};
const int* const agePtr {&age};

• Just like normal pointer to const variables, the referents don't have to be const.

#include <iostream>
void foo(int* num) {
  std::cout << *num << std::endl;
}

int main() {
  int age {5};
  foo(&age);
  return 0;
}

Prefer using references instead of pointers wherever possible.

• Passing by address copies the address from the caller to the function.

• We can use nullptr to set optional parameters in functions.

void foo(const int* bar=nullptr) {
  if(bar) std::cout << *bar;
  else std::cout << "No";
}

• Function overloading is a better way to achive the same result.

void foo(const int& bar) {
  std::cout << bar;
}

void foo() {
  std::cout << "No";
}

• Consts that apply to the object itself are called top level consts. For example, const int x {5};.
• Consts that apply to the reference or pointer to the object are called low level consts. For example, int const* ptr {&x};.

int x {10};
const int* const y {&z}; // the left const is low level, the right const is top level

• Also known as "archives".
• These are compiled and linked directly to our program.
• On Windows, they typically have extension .lib and on Unix they have extension .a.
• One downside is that each executable using a static library has its own version of it, causing wasted space.

• These become part of your program at runtime!
• Many programs can use the same library.
• They remain separate from the compiled binary.
• On Windows, they have extension .dll and on Linux they have extension .so (shared object).

• Every member function has an access to a const pointer named this.
• This pointer points to the address of the current object.

#include <iostream>

class Point {
private:
  int m_x {};
  int m_y {};
public:
  Point(int x = 0, int y = 0) : m_x(x), m_y(y) {}
  int getX() const { return this->m_x; }
};

int main() {
  Point point{};
  std::cout << point.getX() << std::endl;
  return 0;
}

• We can return *this keyword in member functions and achieve function chaining!

#include <iostream>

class Fraction {
private:
  int m_numerator {};
  int m_denominator {};
public:
  Fraction() = default;
  Fraction(int n, int d) : m_numerator(n), m_denominator(d) {};

  void print() const {
    std::cout << m_numerator << "/" << m_denominator << std::endl;
  }

  Fraction& add(const Fraction& f) {
    m_numerator = m_numerator * f.m_denominator + m_denominator * f.m_numerator;
    m_denominator *= f.m_denominator;
    return *this;
  }
  Fraction& multiply(const Fraction& f) {
    m_numerator *= f.m_numerator;
    m_denominator *= f.m_denominator;
    return *this;
  }
  Fraction& subtract(const Fraction& f) {
    m_numerator = m_numerator * f.m_denominator - m_denominator * f.m_numerator;
    m_denominator *= f.m_denominator;
    return *this;
  }
};

int main() {
  Fraction f1{2, 5};
  f1.add(Fraction{3, 8}).multiply(Fraction{2, 3}).print();
  return 0;
}

• We can do something like this to reset class type objects back to their default state-

class Point {
private:
  int m_x{};
  int m_y{};
public:
  // ...
  void reset() {
    // reset the point object
    *this = Point{};
  }
};

• Compilers need to see the full definition of class types in order to use them.
• There's no "forward declaration" for class types.
• Member functions CAN be forward declared like this-

class Test {
public:
  void test() const;
};

void Test::test() const {
  // something
  int x;
}

int main() {
  return 0;
}

• Class types can have nested types like this-

class Fruit {
  public:
    enum Type {
      orange, apple, banana
    };
  private:
    Type m_type {orange};
    bool m_eaten {false};
  public:
    Fruit() = default;
    Fruit(Type t, bool eaten) : m_type{t}, m_eaten{eaten} {};
};

• The enum Type has been made public and can be accessed via Fruit::Type and its enumerators can be accessed like this- Fruit:apple.
• We've used enum instead of enum class because classes have their own scope so we don't need to worry about polluting the global scope.
• You can also use typedef and type aliases in a similar way to the above.

• When an object of a non-aggregated class type is destroyed, a special member function called the destructor is called automatically before hand.
• Destructors, just like constructors, have special rules-
  1. It should have the same name as that of the class but prefixed with a tilde ~.
  2. It cannot take any arguments.
  3. It cannot return anything.

#include <iostream>

class Test {
public:
  Test() {
    std::cout << "Created object" << std::endl;
  }
  ~Test() {
    std::cout << "Destroyed object" << std::endl;
  }
};

int main() {
  Test t;
  return 0;
}

#include <iostream>

template <typename T>
class Pair {
    private:
        T m_first {};
        T m_second {};
    public:
        Pair(T first, T second) : m_first{first}, m_second{second} {};
};

int main() {
    Pair<int> p {1, 2};
    return 0;
}

• Since T might be expensive to copy, it's recommended to use const T& for the constructor parameters.

• Static members of a class type in C++ are shared across all the objects instantiated from that class type.

#include <iostream>

struct Test {
    static int test;
};

// initialize test to 1
// because static members exist independently of the objects instantiated from the class type,
// they can be accessed anytime using the scope resolution operator
int Test::test{1};

int main() {
    Test foo{};
    Test bar{};

    foo.test = 2;

    std::cout << bar.test << std::endl;
    return 0;
}

• Static members can be accessed even before any object is initialized.
• When we declare a static member variable inside a class, it's like forward declaring it (but different).
• You must explicitly define the global variables outside the class just like we're doing in the above example.
• You should not instantiate static members inside header files, only put them in .cpp files, because if the header is included more than once, you'll get multiple definitions of the same variable (violation of ODR, compile error).

You can also initialize static members inside the class definition itself but only if it's one of the following:

1. It is a const variable
2. It is a constexpr variable
3. It is an inline variable

• Member functions can also be defined as static. They can be used to make access functions for private member variables.

#include <iostream>
class Test {
  private:
    static const int m_id{10};
  public:
    static int getID() {return m_id;};
    static void test();
};

// defining static functions outside
// no need to specify "static" here
void Test::test() {
    std::cout << "hey" << std::endl;
}

int main() {
    // the function is being accessed without
    std::cout << Test::getID() << std::endl;
    Test::test();
    return 0;
}

• Static member functions do not have a *this pointer because they're not associated with any object.

• A friend function is a function (may it be a member or a non-member function) that can access all private and protected members of a class as if it was a member of that class.

#include <iostream>

class Point {
    private:
        int m_x {};
        int m_y {};
    public:
        Point (int x, int y) : m_x{x}, m_y{y} {};

        friend void print(const Point& p);
};

// the outsider function which is considered a "friend"
void print(const Point& p) {
    std::cout << p.m_x << "," << p.m_y << std::endl;
}

int main() {
    Point point{4,5};
    print(point);
    return 0;
}

• You should prefer using non-friend functions over friend functions.
• Friend functions don't have a *this pointer.

• Similar to friend functions, a friend class can access private and protected members of another class.

#include <iostream>

class One {
    private:
        int m_x {5};
    public:
        One() = default;

        // making friends with Two :)
        friend class Two;
};

// the friend class
class Two {
    public:
        static void test(const One& o) {
            std::cout << o.m_x << std::endl;
        }
};

int main() {
    One obj{};

    Two::test(obj);
    return 0;
}

• If class A is a friend of B, it doesn't mean that class B is also a friend of A!

• When returning values by reference or by value from member functions, we can get stuck in a difficult situation-
  1. If the function returns by value (rvalue), it can be used safely anywhere but might be inefficient to copy.
  2. If the function returns by reference (lvalue), it's faster but can result in undefined behaviour (if the obj is destroyed).
• We can overload functions in C++ classes to specify different behaviour based on the context (one where implicit object is an lvalue and another one in which the implicit object is an rvalue).

//  & qualifier overloads function to match only lvalue implicit objects, returns by reference
const auto& getName() const & { return m_name; }

// && qualifier overloads function to match only rvalue implicit objects, returns by value
auto getName() const && { return m_name; }

Use of ref qualifiers is not recommended for a few reasons-

1. Most developers don't know about this so this can cause errors or inefficiencies in use.
2. Use of this can be prevented easily by using good practices.

• std::vector has a constructor for this- explicit std::vector<T>(int)

std::vector<int> zeroes(10); // this will create an array of 10 zeroes (value initialized)

• This constructor must be called using direct initialization and not direct-list initialization.

• Vectors can be made const, and such vectors can't be modified later.
• const vectors must be initialized.
• Non-const vectors can NOT contain const values so something like this won't compile: std::vector<const int> nums {1,2,3,4};
• Vectors can not be made constexpr. You can use std::array for that.

• You can get the number of elements in a vector by using the size() member function of the vector object.

#include <vector>
#include <iostream>

int main() {
    std::vector nums {1,2,3,4,5};
    std::cout << nums.size() << std::endl;
    return 0;
}

• You can also use the non-member function std::size to get the size of any type of array: std::size(myArr).
• C++20 introduced a non-member std::ssize function which returns the size of an array as a signed type.

• When we use operator[] to access elements of an array, there's no bound checking. Accessing non existing indices leads to undefined behaviour.
• We can (but should not) use the .at() member function to access elements with runtime bounds checking.
• We can use constexpr int variables to access elements without getting narrowing conversion warnings (because std::size_t is required).
• We should use std::size_t for iterations and accessing elements but this is an unsigned type and might not always be desirable..
• If we want, we can use int or std::ptrdiff_t (when the number of elements is large) to access elements.

• When passing vectors to functions, their full type must be speficied-

void foo(const std::vector<int>& myVector);

• We prefer passing them by reference.

• These are the rules which determine how the data from one object is moved to another object.
• Moving data, i.e., transferring ownership, to other objects is much faster than copying it.
• When move semantics is invoked, any data that can be moved is moved while others are copied.
• std::string and std::vector, both support move semantics, so they can safely be returned by value in functions.
• Move semantics are invoked automatically for supported types.

#include <iostream>
#include <vector>
int main() {
    std::vector nums {1,2,3,4,5}; // CTAD to deduce type of template parameter

    for (const auto& num : nums) {
        std::cout << num << std::endl;
    }
    return 0;
}

• We should use the auto keyword to deduce the type in the loop.

• Vectors are dynamic arrays.
• They can be resized using the resize() member function.

std::vector nums {1,2,3}; // 3 elements
nums.resize(5); // now stores 5 elements

• We can get the capacity of a vector, which is the number of elements it can hold using the capacity() member function.
• Resizing works by first acquiring new memory space, copying existing elements and deleting the old memory.
• The above is the reason that resizing is expensive!

Resizing a vector to be smaller will only decrease its length, and not its capacity.

• Just like stacks of pizzas and books.
• You can add/remove items only from the top.
• Order of insertion/deletion is last-in, first-out (LIFO).
• The last plate added onto the stack will be the first plate that is removed.