C++

This repository contains my C++ snippets code on C++ concepts/ idioms, optimized C++, modern C++ and advance C++. I have included snippets and sample code for using third-party libs to parse CSV, YAML, and JSON files. An example of code benchmarking with Google Benchmark is available. There is also a tutorial on using CMake to build and export your project.

Building and Installation

if you need to update your CMake:

Navigate to CMake's official website to get the link for the latest source tarball:

./bootstrap
make -j$(nproc)
sudo make install
sudo update-alternatives --install /usr/bin/cmake cmake /usr/local/bin/cmake 1 --force

How to build on your machine

configure it:

cmake -G "Ninja Multi-Config"  -S . -B build

or specify where to install it:

cmake -G "Ninja Multi-Config" -S . -B build -DCMAKE_INSTALL_PREFIX=/path/to/install

build it:

cmake --build build --config Release

or

cmake --build build --config Debug

or be more specific:

cmake --build build --target all --config Release

If you prefer preset use:

cmake --preset ninja-multi

and

cmake --build --preset ninja-multi-debug

or

cmake --build --preset ninja-multi-release

1. Building the Image

There is a docker file for this project that contains all dependencies and you build the image with:

docker build -t cpp_tutorials .

2. Creating the container

Create a container where you mount the checkout code into your container:

docker run --name <continer-name> -v <checked-out-path-on-host>:<path-in-the-container> -it <docker-image-name>

for instance:

docker run --name cpp_container -v /home/behnam/workspace/cpp_tutorials:/cpp_tutorials -it cpp_tutorials

3. Starting an existing container

If you have already created a container from the docker image, you can start it with:

docker start -i cpp_container

4. Removing unnecessary images and containers

You can remove unnecessary images and containers by:

docker image prune -a

docker container prune

GUI application with docker

1. You need to run:

docker run --name cpp_container -v /home/behnam/workspace/cpp_tutorials:/cpp_tutorials --env="DISPLAY" --env="QT_X11_NO_MITSHM=1" --volume="/tmp/.X11-unix:/tmp/.X11-unix:rw" -it cpp_tutorials

2. On the host run the following (every time you run your container):

export containerId=$(docker ps -l -q)

xhost +local: docker inspect --format='{{ .Config.Hostname }}' $containerId

read more here

Configure VSCode to use Ninja Multi-Config for all CMake projects

To configure VSCode to use CMake with the "Ninja Multi-Config" generator for all CMake projects, you can modify the VSCode settings. Here's how you can do it:

1. Open your VSCode workspace or project.
2. Press Ctrl + , to open the settings, or navigate to File > Preferences > Settings.
3. In the settings search bar, type "cmake generator".
4. Locate the "Cmake: Generator" setting.
5. Click on "Edit in settings.json" or manually edit your settings.json file.

In your settings.json file, add or modify the "cmake.generator" setting to specify "Ninja Multi-Config" as the default generator for all CMake projects:

{
    "cmake.generator": "Ninja Multi-Config"
}

Save the settings.json file.

This change ensures that VSCode uses the "Ninja Multi-Config" generator by default for all CMake projects you work on in that workspace or project.

C++ Tutorials

• Align
• Allocator
• Algorithms Library
• Any
• Assert
• Atomic operations and Atomic Types
• Asynchronous programming
  • std::launch::async, std::future
  • Parallelization with ascync
  • Parallelization with std::packaged_task
• Attribute specifier sequence [[ attribute-list ]]
• Basic IO Operation, Streams, Reading/Writing Files, Formatting Output, cin, scanf, gets, getline, printf
• Big-endian,_Little-endian
• Bitset, Bit field, Bitwise Operations
• Callable Objects, Callbacks
  • 1. Function Pointers
  • 2. Functor (Function Objects)
  • 3. std::function, std::placeholders, and std::bind
  • 4. Lambda Functions
  • 5. Member Function Pointers
  • 6. Signals and Slots
  • 7. std::invoke
  • 8. Packaged Tasks
  • 9. Coroutines
  • 10. Auto-generated operator() from a Captureless Lambda
• Clock, Date, Time
• Conditional Compilation From CMakeLists
• Containers
  • vector
  • lists
  • C arrays, std::array, span
  • set, map, pair, tuple, tie, unordered_map, multimap, unordered_set, multiset
  • stack, queue, priority_queue, deque
• Const, Constexpr and Mutable
• Immutable Objects
• Data Types, Numerical Limits, Machine Epsilon, Precision, std::nan
• Data Types Conversions, Casting, Type Coercion
• Decay
• Dynamic Memory Allocation in C
• Enum
• Error Handling
• Error Code
• Exception Handling, noexcept
• Extern Variables, Extern Functions
• Execution Policies
• File System
• Forking
• Forwarding Reference
• Functions, Extern Function, Function Objects, Function Pointer, Inline Functions
• Hash Functions, Hash Data Structure (Hash Table)
• Heap and Stack, Memory Layout of C Programs
• Iterator, for_each loop, range-for loop, Loop optimization
• std::less, std::greater
• std::not1 and std::unary_negate
• Lambda
• Literals
• Loading Classes Dynamically From Plugins
• Macros
• Memory Error Detection With Memory Address Sanitizer and Valgrind
• Modules
• Nested Namespaces, Unnamed/Anonymous Namespaces
• Numeral Systems in C++ Decimal, Binary, Octal, Hexadecimal
• Optional
• Parameter Pack Expansion ...
• Post-increment, Pre-increment, Unary plus
• Packaged Task
• Register Keyword
• Regex
• Pseudo-random Number Generation, Distributions
• Raw Pointers, Smart (Shared, Unique, Weak) Pointers, Reference, addressof, reference_wrapper, std::ref
• Passing/ Returning Smart Pointers To/ From Functions
• Smart Pointers Class Member
• Return, Abort, Exit, Throw, Terminate
• Scope Resolution Operator
• Scope and Life Cycle of Objects Returned by Functions
• Setting argc, argv
• Simple Command Argument Parser
• Signals
• System Call
• String C/C++, string_view, string literal, string conversion, ASCII, Unicode
• String View
• Structs
• Structured binding declaration
• Switch Case
• Template, Expression Templates
• Template argument deduction
• Ternary (One Line If)
• Temporary Objects
• Track memory allocations(overriding new operator)
• Trivial, standard-layout, Passive/ Plain old data structure (PDS)/ (POD), and literal types
• Type Traits
• Typedef, Type alias (using keyword)
• type_dispatch, integral_constant, true/false type
• Unions
• Variant
• Visit
• Variadic Templates Function
• Volatile Keyword

• C++ Classes
  • Abstract Class Vs Interface
  • Cast Base Class to Derived/ Derived to Base
  • Class Forward Declaration
  • Class Constructor Initializationlist
  • Class Constructor Aggregate/ Copy/ Default/ Direct/ Value/ Uniform/ Zero Initialization, Initializer List
  • Copy/ Move Constructor, rvalue, lvalue, move semantic
  • Cyclic (Circular) Dependency
  • Default(=default), Deleted (=delete) Constructors
  • Diamond Problem Virtual Inheritance
  • Explicit Constructor, Converting Constructor
  • Friend Functions
  • Header Guard
  • Inheritance, Inheritance Prevention (final)
  • Multiple Inheritance Polymorphism
  • Operator Overloading
  • Object Slicing
  • Passing Arguments To Parent Constructor
  • Private Public Protected Inheritance
  • Protected Friend Class Function
  • Shadowing
  • Static Member Function, Static Initialization Order Fiasco
  • Special Member Functions
  • Virtual Function Abstract Class
  • Virtual Destructor, Virtual Constructor
• Multithreading and Process
  • Process, Inter Process Communication (IPC), Process Tree, Process Control Block (PCB
  • Creating (Thread Callable Objects), Terminating Threads
  • Over Subscription
  • Differentiating Between Threads
  • Sleeping Threads
  • Joining/ Detaching Threads, Joinable Detachable
  • Threads Yield
  • Thread Synchronization
  • Racing Condition
  • Mutex
  • Semaphor
  • Thread Safe
  • Dead Lock
  • Lock Guard
  • Scoped Lock
  • Unique Lock
  • Condition Variable
  • Future, Promise and async
  • Packaged Task
  • Event handling/ Concurrency/ Thread design pattern

Advance C++ Concepts and Idioms

• Argument-dependent lookup
• Buffer overflow
• Copy and Swap
• Generating and Debugging Dump File
• Static Casting, Dynamic Casting
• Run-Time Type Information(RTTI)
• Curiously Recurring Template Pattern (CRTP)
• Copy Elision, Return value optimization (RVO, NRVO)
• Double Dispatch
• Most vexing parse
• Metaprogramming
• Pointer to implementation (PIMPL)
• Return Type Resolver
• Resource Acquisition Is Initialization (RAII)
• Rule of 5
• Substitution failure is not an error (SFINAE)
• Stack overflow
• Stack Unwinding
• Type Erasure
• Template Specialization, Tag Dispatch
• Virtual Method Table(VTABLE), Virtual Table Pointer(VPTR)
• Virtual address space
• Tricky Questions
• C++ Translation Units
• Undefined behavior, Unspecified and Implementation-Defined
• Printing List of All Included Headers
• fPIE (Position Independent Executable) and fPIC(Position Independent Code and)
• Lexical Analyzer

Optimizing C++

Data File Storage Parsing

• CSV
• YAML
• JSON
• XML

REST API and Microservices with C++

• Monolithic Architecture vs REST API and Microservices
• gRPC
• REST API with crow
• mocking APIs with Mockoon
• Test API with Postman

Event Streaming and Message Queuing with C++

• Apache Kafka
• RabbitMQ

Logging With C++

• spdlog

Code Benchmarking

• Google Benchmark

Code Profiling

• Tracy Profiler

C++ Package Manager

• Conan
• vcpkg
• Chocolatey
• Winget

Documentation with Doxygen

• API documentation and UML diagram
• Integrate Doxygen with GitHub Action

Application Packaging and Deployment

• CPack Packaging

Software versioning

• Semantic Versioning
• Getting Version From Git in CMake
• Getting Release Version From Git (check for update)

C++ Coding Standards and Style Guide

• Goolge C++ Style Guide
• isocpp
• Bjarne Stroustrup's C++ Style