learncpp-com

Followed from learncpp-com

Module 1 - C++ Basics

• Preprocessor directive - indicates that we are using a library or utility (#include, #define, #ifdef)
• In C++, direct memory access is discouraged, instead we access memory indirectly through an object.
• There are some flags which the C compiler provides
  • -Werror to convert warnings to errors.
  • -Wall to enable all type of warning triggers.
  • -Wextra enables some extra warning flags that are not enabled by -Wall.
  • -Wsign-conversion warns for implicit conversions that may change the sign of an integer value, like assigning a signed integer expression to an unsigned integer variable.
  • -ggdb for debugging
  • -O2 -DNDEBUG for release builds
• A named object is a variable, and the name of the object is called an identifier.
• Types of Initialization
  • Default
  • Copy (int a = 5)
  • Direct (int a(5))
  • Brace (also called uniform initialization or list initialization) (int a{5} or int a = {5})
• Brace initialization disallows 'narrowing conversions'. int width {4.5}, this returns an error as fractional value can't fit into an int, while copy and direct initialization would simply drop the fractional part.
• Remember that if you have -Wall flag specified as argument, any variable that is declared but not used in the program, will trigger an error. In C++17 standard however, you can use the [[maybe_unused]] attribute to tell the compiler that the variable may not be used.
• std::endl vs '\n'
  • Using std::endl can be inefficient, but it serves to flush the output buffer. However, std::cout often flushes output anyways, so having endl to flush output is rarely important.
  • Using '\n' can be faster, since it doesn't perform a flush operation.
• The C++ I/O library does not provide a way to accept keyboard input without the user having to press enter. For that in console applications, you can use 3rd party libraries like pdcurses, FXTUI, and cpp-terminal.
• Insertion operator (<<) and extraction operator (>>)
• Identifier naming rules:
  • The identifier can not be a keyword. Keywords are reserved.
  • The identifier can only be composed of letters (lower or upper case), numbers, and the underscore character.
  • The identifier must begin with a letter (lower or upper case) or an underscore. It can not start with a number.
  • C++ is case sensitive, and thus distinguishes between lower and upper case letters. nvalue is different than nValue is different than NVALUE.
• The number of operands that an operator takes as input is called the operator's arity (four types of arity - unary, binary, ternary, nullary(the throw operator))
• Operators are executed in order PEMDAS.
• All operators which define some behaviour (and not just return values) return their left operand.
• Statement vs Expression - Statements are used when we want the program to perform an action. Expressions are used when we want the program to calculate a value.

Module 2 - Functions

• main() is the only function that implicitly returns a value.
• forward declaration - tell the compiler about the existence of a function before we define the function's body. For this, use function declaration(also called function prototype).
• What would happen if you forward declare a function, but do not define it later on? - The compiler would function properly, and program compiles. However, the linker will complain that it cannot resolve the function call.
• Declarations that are not definitions are called pure declarations.
• Multiple files can be compiled together using the compiler with g++ <file1> <file2> ... -o main. While compiling, ensure that function declarations are made for each function used not in that particular file and sourced from someplace else.
• The compilation can be in any order for multiple files. The linker is the one which connects the dots.
• Compilation of two files with same function names can cause a naming collision, and thus cause the linker to return an error. For reference, see name_coll1.cpp name_coll2.cpp, compiled with gcc name_coll1.cpp name_coll2.cpp -o name_coll.
• Most naming collisions occur in two cases:
  • Two (or more) identically named functions (or global variables) are introduced into separate files belonging to the same program. This will result in a linker error.
  • Two (or more) identically named functions (or global variables) are introduced into the same file. This will result in a compiler error.
• Solution for naming collisions? Namespaces. A region that allows to declare names inside of it for the purpose of disambiguation.
• In C++, any name not defined inside a class, function or a namespace belongs to the global namespace (sometimes called global scope). Executable statements are not allowed in the global namespace.
• The :: in std::cout is the scope resolution operator.
• The using directive is used to access namespaces without giving a namespace prefix. However, it is discouraged.
• Translation phases
• The most noteworthy phase of translation is preprocessing, which involves the preprocessor. It scans for all preprocessor directives(instructions beginning with #) and perform the particular action.
• Types of preprocessor directives:
  • #include
  • #define - with and without substitution text
  • #ifdef/#if defined(), #endif, #ifndef/#if !defined(), #if 0 - conditional compilation preprocessor
• Directives defined in one code file do not have impact on other code files in the same project.
• Header files allow to put declarations in one location and import them when needed.
• Header files consist of two parts:
  • Header guard
  • Actual content, which comprises of forward declarations for all the identifiers.
• When using angled brackets, the compiler preprocessor searches in the include directories. With double quotes, it first looks in the current directory.
• Duplicate function definitions can lead to compilation error, as there can be no duplicate definition in a file.
• Header guards can be used to deal with duplicate function. For reference, see header guards
• Modern compilers support a simpler, alternate form of header guards using the #pragma directive by using #pragma once. Still, prefer header guards as they are more reliable, and pragma is not officially a part of C++.

Module 3 - Debugging C++ Programs

• When printing info for debugging purposes, use std::cerr instead of std::cout, as std::cerr is unbuffered. This ensures all debug output appears as soon as possible.
• We can enable/disable debugging using preprocessor directives (ifdef ENABLE_DEBUG, endif)
• Another alternative is using a logger.