Colin's C++ & Object Oriented Programming Guide

Abstraction is the process of moving from a specific idea to a more generalized one. Examples include the concept of data types, functions, and abstract classes.

Example

#include <iostream>
#include <vector>

using namespace std;

enum COLOR{RED,WHITE,BLUE};

class marble_jar{
  vector<COLOR> contents;
  
  public:
    void add(COLOR c){
        contents.push_back(c);
    }
    
    int num_marbles(){
        return contents.size();
    }
    
    COLOR last_color(){
        return contents[contents.size()-1];
    }
    
};

int main()
{
    marble_jar j;
    
    j.add(RED);
    j.add(RED);
    j.add(BLUE);
    j.add(RED);
    j.add(WHITE);
    
    cout << j.num_marbles() << endl;
    cout << j.last_color() << endl;

    return 0;
}

This program outputs:

5
1

Abstract Class

Description

A class which cannot be initialized but can be used as a base class. A class needs atleast one pure virtual function to be an abstract class. Pure virtual functions need to be overriden.

Example

#include <iostream>

//This is an abstract class
class vehicle{
  virtual void honk() = 0; //pure virtual function
};

class car : vehicle{
  public:
  void honk(){
    std::cout << "beep\n";
  }
};

class truck : vehicle{
  public:
  void honk(){
    std::cout << "honk\n";
  } 
};

int main() {

  //We cannot instantiate the below class because it is abstract
  //vehicle v;

  car c;
  truck t;

  c.honk();
  t.honk();
}

This program outputs:

beep
honk

Access Specifiers

Description

Access specifiers are used in classes to define what its encapsulation behavior should be. There are three access specifiers in C++: public, private, and protected. Public class members are accessible to everyone. Private class members are accessible to no one. Protected is just like private, except they are accessible to the class's children.

Example

#include <iostream>
#include <vector>

using namespace std;

class feline{
    
    private:
        string name;
        
    protected:
        int danger_level;
    
    public:     
        string getName(){
            return name;
        }
        
        void setName(string n){
            name = n;
        }    
        
        int getDanger_level(){
            return danger_level;
        }
};

class house_cat : public feline{
    
    public:
        house_cat(){
            danger_level = 1;
        }
    
};

class lion : public feline{
    public:
        lion(){
            danger_level = 10;
        }
};

int main(){
    house_cat h;
    h.setName("Fluffy");
    
    lion l;
    l.setName("Cecil");
    
    cout << h.getName() << " is danger level: " << h.getDanger_level() << endl;
    cout << l.getName() << " is danger level: " << l.getDanger_level() << endl;

This program outputs:


Fluffy is danger level: 1
Cecil is danger level: 10

Async, Future, and Promise

Description

Future and promoise are two seperate sides of an asynchronous operation Promise acts as a producer and future acts as a consumer. A future will block until it's thread is ready to be joined. The function async creates a new thread and returns a future. The future function has two launch policies:

"std::launch::async" which cretes a new thread

"std::launch::deferred" which does not create a new thread

By default async decides which launch policy works best at time of execution.

Example

#include <iostream>
#include <future>
#include <vector>

using namespace std;

int factorial(int input){
    int output = 1;
    for(uint i=1;i<=input;i++){
        output *= i;
    }
    return output;
}

int main() {
    
    vector<future<int> > f;
    
    for(int i=1;i<11;i++){
        f.push_back(async(factorial,i));
    }
    
    for(int i=1;i<11;i++){
        cout << i << "! = " << f[i-1].get() << endl;
    }
}

This program outputs:

1! = 1                                                                
2! = 2                                                                
3! = 6                                                                
4! = 24                                                               
5! = 120                                                              
6! = 720                                                              
7! = 5040                                                             
8! = 40320                                                            
9! = 362880                                                           
10! = 3628800

Atomic Datatypes

Description

Atomic datatypes are datatypes that have all of their member functions execute as a single transaction. They are similar to mutexes, except they are signifigantly faster due to cache level optimization. Atomic datatypes do not inherit all of the member functions of their parent datatype. For example, in most cases, mulitply is not overloaded. Overloaded operators are good for making atomic datatypes readable, but in practice the atomic member functions help you write more "correct" code. Atomic member functions include: load(), store(), exchance(), etc.

Example

#include <iostream>
#include <thread>
#include <atomic>

using namespace std;

atomic<int> atomic_iter;
int iter = 0;

void update(){
    atomic_iter++;
    iter++;
}

int main()
{
    const auto processor_count = 10;

  thread threads[processor_count];

  for(uint i=0;i<processor_count;i++){
    threads[i] = thread(update);
  }

  for(uint i=0;i<processor_count;i++){
    threads[i].join();
  }
  
  cout << atomic_iter << endl; //Cannot have a race condition
  cout << iter << endl; //Can have a race condition

    return 0;
}

This program outputs:

10
10

Atomic Flags

Description

Atomic flag is a data type that is guaranteed to be lock free. Atomic flags are very similar to atomic bool, except the load and store operations are not provided. In C++11, the only functions available for atomic flag are clear() and test_and_set(). Clear() sets the flag to false and test_and_set() returns the value of the flag and sets the flag to true.

Example

#include <thread>
#include <iostream>
#include <atomic>
#include <unistd.h>

using namespace std;

class spin_lock{
    public:
        
        spin_lock(){
            f.clear();
        }
    
        void lock(){
            while(f.test_and_set()){
            }
            cout << "locked" << endl;

        };
        
        void unlock(){
            cout << "unlocked" << endl;
            f.clear();
        };
        
    private:
        atomic_flag f;
};


int main()
{
    spin_lock sl;
    
    thread t1([&] {
        cout << "1 started" << endl;
        sl.lock();
        usleep(1000);
        sl.unlock();
        cout << "1 done" << endl;
    });
    
    thread t2([&] {
        cout << "2 started" << endl;
        sl.lock();
        usleep(1000);
        sl.unlock();
        cout << "2 done" << endl;
    });
    
    thread t3([&] {
        cout << "3 started" << endl;
        sl.lock();
        usleep(1000);
        sl.unlock();
        cout << "3 done" << endl;
    });
    
    t1.join();
    t2.join();
    t3.join();
}

This program can output:

2 started
1 started
locked
3 started
unlocked
2 done
locked
unlocked
1 done
locked
unlocked
3 done

Bind

Description

Bind() is a function template which generates a forwarding call wrapper for a given function. Calling the wrapper is equalvalent to invoking the function with its binded arguments.

Example

#include <iostream>
#include <algorithm>
#include <vector>
#include <functional>

using namespace std;

double noise_gate(double x, double thresh){
    if(x<thresh) return 0;
    return x;
}

int main()
{
    
    vector<double> input;
    for(double i=-4;i<4;i++){
        input.push_back(i);
    }
    
    transform(input.begin(), input.end(), input.begin(), bind(noise_gate, placeholders::_1, 0));
    
    for(auto v : input){
        cout << v << endl;
    }
    
    
}

This program outputs:

Compare Exchange Weak vs Strong

Description

Atomic datatypes have public functions which allow them to compare and exchange their value. If the first parameter matches the atomic variable's value, then the variable gets updated to the value of the second parameter. If the first parameter does not match the atomic variable's value, then the first parameter gets updated to the value of the second parameter. The compare and exchange function returns true if the atomic variable is equal to the first parameter's value and false otherwise. If the atomic variable is lock free, then the compare and exchange is only one CPU instruction~

There are two kinds of compare and exchange functions: "weak" and "strong". "compare_exchange_weak()" can have spurious failures, but is faster than "compare_exchange_strong()". However, Compare_exchange_strong can still fail, because of concurrent writes. If you have a compare_exchange_weak() in a loop because you cannot afford a spurious failure, then use a compare_exchange_strong() instead.

Example

#include <iostream>
#include <unistd.h>
#include <atomic>
#include <chrono>

#define TIME std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count()

using namespace std;

int main ()
{
    atomic<int> a;
    a.store(0);
    int b = 0;
    
    double num_weak_fails = 0;
    auto start = TIME;
    
    for(int i=0;i<1000000;i++){
        if(!a.compare_exchange_weak(b,0)){
            num_weak_fails++;
        }
    }
    
    cout << "compare_exchange_weak took " << TIME-start << " ms" << endl;
    
    double num_strong_fails = 0;
    
    for(int i=0;i<1000000;i++){
        if(!a.compare_exchange_strong(b,0)){
            num_strong_fails++;
        }
    }
    
    cout << "compare_exchange_strong took " << TIME-start << " ms" << endl;
    start = TIME;
    
    cout << "num_weak_fails " << num_weak_fails << endl;
    cout << "num_strong_fails " << num_strong_fails << endl;
    


  return 0;
}

This program outputs:

compare_exchange_weak took 20 ms
compare_exchange_strong took 33 ms
num_weak_fails 0
num_strong_fails 0

Auto

Description

Auto deduces the type of a declared variable from its initialization expression at compile time. There are situations where auto can make code for engineers much more difficult to read.

Example

#include <iostream>

using namespace std;

class point{
    
    public:
        int x,y;
    
        point(int x, int y){
            this->x = x;
            this->y = y;
        }
};

int main(){
    auto p = point(1,5); //Deduces the type from the initializer
    cout << p.x << ", " << p.y << endl;

    return 0;
}

This program outputs:

1, 5

Automatically Constructors and Destructors

Description

Certian constructors and destructors are automatically generated by the compilier. The empty constructor "class()" is generated if there isn't any user written constructors. The copy assignment and constructor are automatically generated if there isn't a move assignment or constructor written. The move assignment and constructor are automatically generated if there isn't a copy assignment, copy constructor, or destructor written. Destructors are generated if none is written. Move was not added to C++ until C++11.

Example

#include <iostream>

using namespace std;

class nothing{ };

class copy_assign{
    public:
    copy_assign() { cout << "    const" << endl; }
    copy_assign& operator=(const copy_assign& other) { cout << "    copy assign" << endl; return *this; }    
};


class copy_const{
    public:
    copy_const() { cout << "    const" << endl; }
    copy_const(const copy_const &p1) { cout << "    copy const" << endl; }
};

class move_assign{
    public:
    move_assign() { cout << "    const" << endl; }
    move_assign& operator=(const move_assign& other) { cout << "    move assign" << endl; return *this; }    
};

class move_const{
    public:
    move_const() { cout << "    const" << endl; }
    move_const(const copy_const &&p1) { cout << "    move const" << endl; }
};


int main()
{
    cout << "nothing const" << endl;
    nothing n1;
    cout << "nothing copy assignment" << endl;
    nothing n2 = n1;
    cout << "nothing copy const" << endl;
    nothing n3(n1);
    cout << "nothing move assignment" << endl;
    nothing n4 = std::move(n1);
    cout << "nothing move const" << endl;
    nothing n5(std::move(n2));
    cout << endl;
    
    cout << "copy_assign const" << endl;
    copy_assign ca1;
    cout << "copy_assign copy assignment" << endl;
    copy_assign ca2 = ca1;
    cout << "copy_assign copy const" << endl;
    copy_assign ca3(ca1);
    cout << "copy_assign move assignment" << endl;
    copy_assign ca4 = std::move(ca1);
    cout << "copy_assign move const" << endl;
    copy_assign ca5(std::move(ca2));
    cout << endl;
    
    cout << "copy_const const" << endl;
    copy_const cc1;
    cout << "copy_const copy assignment" << endl;
    copy_const cc2 = cc1;
    cout << "copy_const copy const" << endl;
    copy_const cc3(cc1);
    cout << "copy_const move assignment" << endl;
    copy_const cc4 = std::move(cc1);
    cout << "copy_const move const" << endl;
    copy_const cc5(std::move(cc2));
    cout << endl;
    
    cout << "move_assign const" << endl;
    move_assign ma1;
    cout << "move_assign copy assignment" << endl;
    move_assign ma2 = ma1;
    cout << "move_assign copy const" << endl;
    move_assign ma3(ma1);
    cout << "move_assign move assignment" << endl;
    move_assign ma4 = std::move(ma1);
    cout << "move_assign move const" << endl;
    move_assign ma5(std::move(ma2));
    cout << endl;

    cout << "move_const const" << endl;
    move_const mc1;
    cout << "move_const copy assignment" << endl;
    move_const mc2 = mc1;
    cout << "move_const copy const" << endl;
    move_const mc3(mc1);
    cout << "move_const move assignment" << endl;
    move_const mc4 = std::move(mc1);
    cout << "move_const move const" << endl;
    move_const mc5(std::move(mc2));
    cout << endl;
}

This program outputs:

nothing const
nothing copy assignment
nothing copy const
nothing move assignment
nothing move const

copy_assign const
    const
copy_assign copy assignment
copy_assign copy const
copy_assign move assignment
copy_assign move const

copy_const const
    const
copy_const copy assignment
    copy const
copy_const copy const
    copy const
copy_const move assignment
    copy const
copy_const move const
    copy const

move_assign const
    const
move_assign copy assignment
move_assign copy const
move_assign move assignment
move_assign move const

move_const const
    const
move_const copy assignment
move_const copy const
move_const move assignment
move_const move const

Condition Variables

Description

Condition variables allow a thread to atomically release a held mutex and put itself to sleep. There are two main functions to a condition variable: wait() and notify_one(). Wait() tells the thread to go to sleep until a notification is available. Notify_one() sends a signal to one of the sleeping threads to wake up. There are additional functions. Wait_for and wait_until allows us to cancel a thread's sleeping to prevent a deadlock. Wait also has an option to take in a predicate to handle sperious wakeups. We also have notify_all() which works like notify_one(), except it notifies all waiting threads instead of just one.

Example

#include <iostream>
#include <condition_variable>
#include <thread>
#include <mutex>
#include <string>
#include <queue>
#include <chrono>

using namespace std;

mutex m;
condition_variable cv;

queue<string> food_counter;


int main()
{
    
    for(uint i=0;i<5;i++){
        thread customer([]{
            unique_lock<mutex> ul(m);
            cv.wait(ul);
            food_counter.pop();
            cout << "A customer ate the food" << endl;
        });
        customer.detach();
    }
    
    thread chef([]{
        for(uint i=0;i<10;i++){
            unique_lock<mutex> ul(m);
            cout << "chef made food" << endl;
            food_counter.push("food");
            ul.unlock();
            cv.notify_one();
            std::this_thread::sleep_for(chrono::seconds(1));
        }
    });
    
    
    chef.join();
    
    return 0;
}

This program outputs:

chef made food
A customer ate the food
chef made food
A customer ate the food
chef made food
A customer ate the food
chef made food
A customer ate the food
chef made food
A customer ate the food
chef made food
chef made food
chef made food
chef made food
chef made food

Const

Description

A keyword that specifies that a variable's value is constant and prevents the programmer from modifying it. To make things more complicated, there are also pointers to consts and const pointers. Pointers to const can have thier address change, but not their value. Const pointers can have their values changed, but not their addresses.

Example

int main(){
    int a = 1;
    int b = 2;
    
    //Standard const
    const int test1 = a;
    //test1 = b; //Not allowed
    
    //Pointer to const
    const int* test2 = &a;
    test2 = &b; //Allowed
    //*test2 = b; //Not allowed
    
    //Pointer to const
    int* const test3 = &a;
    *test3 = b; //Allowed
    //test3 = &b; //Not allowed    
}

Context Switching

Description

Context switching is the process of storing the state of a process or a thread so that it can be later restored and resume execution at a later point. The act of "switching" from one process/ thread "context" takes time. This switching latency is caused by a number of low level effects. For example, task schedulers, TLB flushes, and CPU cache sharing.

The following two examples assume each part of the program takes exactly 1 execution:

Unoptimized for Context Switching

# OF EXECUTIONS	THREAD 1	CONTEXT SWITCHING	THREAD 2
0	Lock m1
1	Lock m2
2	Do task
3	Unlock m1
4		Switch ->
5			Lock m1
6		<- Switch
7	Unlock m2
8			Lock m2
9			Do task
10			Unlock m1
11			Unlock m2

Optimized for Context Switching

# OF EXECUTIONS	THREAD 1	CONTEXT SWITCHING	THREAD 2
0	Lock m1
1	Lock m2
2	Do task
3	Unlock m2
4	Unlock m1
5		Switch ->
6			Lock m1
7			Lock m2
8			Do task
9			Unlock m1
10			Unlock m2

Example

#include <stdlib.h>
#include <thread>
#include <mutex>
#include <iostream>
#include <vector>
#include <chrono>

using namespace std;

mutex m0,m1;

int main(){
    
    auto t1 = std::chrono::high_resolution_clock::now();
    
    vector<thread> lots_of_context_switches;

    for(int i=0;i<20000;i++){
        
        int product = 1;
        
        lots_of_context_switches.push_back(thread ([i,&product]{
            m0.lock();
            m1.lock();
            
            product *= i;
            
            m0.unlock(); //Unlocking m0 first here causes more context switching
            m1.unlock(); 
        }));
    }
        
    for(auto &v : lots_of_context_switches){
        v.join();
    }
    
    auto t2 = std::chrono::high_resolution_clock::now();
    std::cout << "lots_of_context_switches took "
              << std::chrono::duration_cast<std::chrono::milliseconds>(t2-t1).count()
              << " millisecondsn";
              
    auto t3 = std::chrono::high_resolution_clock::now();
 
    vector<thread> less_context_switches;

    for(int j=0;j<20000;j++){
        
        int product = 1;
        
        less_context_switches.push_back(thread ([j,&product]{
            m0.lock();
            m1.lock();
            
            product *= j;
            
            m1.unlock(); //Unlocking m1 first here causes less switching
            m0.unlock();
            
        }));
    }
        
    for(auto &v : less_context_switches){
        v.join();
    }
    
    auto t4 = std::chrono::high_resolution_clock::now();
    std::cout << "less_context_switches took "
              << std::chrono::duration_cast<std::chrono::milliseconds>(t4-t3).count()
              << " millisecondsn";
}

This program outputs:

lots_of_context_switches took 1861 milliseconds
less_context_switches took 1785 milliseconds

Copy Vs. Move

Description

std::move() was introducted in C++11 and now allows us to "move" an lvalue from one rvalue to another. When a copy is performed, a complete matching copy of the source rvalue's data is created and given to the destination rvalue. When a move is performed, only the source rvalue's address is moved to destination rvalue. Therefore if you only need to move a lvalue from one rvalue to another, one can save both time and memory by using std::move() instead of performing a copy.

Example

#include <iostream>
#include <string>
#include <cstring>
#include <vector>
#include <chrono>

using namespace std;

int parseLine(char* line){
    // This assumes that a digit will be found and the line ends in " Kb".
    int i = strlen(line);
    const char* p = line;
    while (*p <'0' || *p > '9') p++;
    line[i-3] = '\0';
    i = atoi(p);
    return i;
}

int getValue(){ //Note: this value is in KB!
    FILE* file = fopen("/proc/self/status", "r");
    int result = -1;
    char line[128];

    while (fgets(line, 128, file) != NULL){
        if (strncmp(line, "VmSize:", 7) == 0){
            result = parseLine(line);
            break;
        }
    }
    fclose(file);
    return result;
}

template <class T> int
swap_copy(T& a, T& b) {
	int start_bytes = getValue() * 1000;

    T tmp(a);   // Now there are two copies of a
    a = b;      // Now there are two copies of b
    b = tmp;    // Now there are two copies of tmp

    return (getValue() * 1000) - start_bytes;
}

template <class T> int
swap_move(T& a, T& b) {

	int start_bytes = getValue() * 1000;

    T tmp(std::move(a)); //a's address moved to tmp
    a = std::move(b); //b's address moved to a
    b = std::move(tmp); //tmp's address moved to b

    return (getValue() * 1000) - start_bytes;
}

int main(){

	vector<int> big_vec1;
	vector<int> big_vec2;
	for(int i=0;i<10000000;i++){
		big_vec1.push_back(i);
		big_vec2.push_back(i);
	}

	auto t1 = std::chrono::high_resolution_clock::now();

	int copy_bytes = swap_copy<vector<int>>(big_vec1, big_vec2);

	auto t2 = std::chrono::high_resolution_clock::now();

	int move_bytes = swap_move<vector<int>>(big_vec1, big_vec2);

	auto t3 = std::chrono::high_resolution_clock::now();

	cout << "swap_copy() took " << copy_bytes << " bytes and " << 
		std::chrono::duration_cast<std::chrono::milliseconds>(t2-t1).count() << " milliseconds" << endl;

	cout << "swap_move() took " << move_bytes << " bytes and " << 
		std::chrono::duration_cast<std::chrono::milliseconds>(t3-t2).count() << " milliseconds" << endl;
	
}

This program outputs:

swap_copy() took 39064000 bytes and 35 milliseconds
swap_move() took 0 bytes and 0 milliseconds

Deadlocks

Description

A deadlock is any situation in which two or more threads are blocked indefinitely. For example, lets say there are two threads, t1 and t2, and two resources, r1 and r2. T1 and t2 both will not finish their execution unless they have both resource r1 and r2 locked. If t1 locks r1 and t2 locks r2, then neither thread will ever finish resulting in a deadlock.

Example

#include <iostream>
#include <string>
#include <thread>
#include <mutex>
#include <unistd.h>

using namespace std;

mutex chopstick1;
mutex chopstick2;

void eat1(){
    
    lock_guard<mutex> g1(chopstick1);
    usleep(1 * 1000000);
    lock_guard<mutex> g2(chopstick2);
    
    cout << "burp" << endl;
}

void eat2(){
    
    lock_guard<mutex> g2(chopstick2);
    usleep(1 * 1000000);
    lock_guard<mutex> g1(chopstick1);
    
    cout << "burp" << endl;
}


int main(){
    thread t1 = thread(eat1);
    thread t2 = thread(eat2);
    t1.join();
    t2.join();
}

Difference between a thread and a process

Description

A thread is a sequence of instructions executed concurrently and is part of a process. A process is an instance of a program. Threads are "lighter" than processes. They require less time for context switching and require less resources. Threads share resources, unlike processes. Processes collabrate less with each other compared to threads.

Example

#include <iostream>
#include <thread>
#include <unistd.h> 

using namespace std;

const uint NUM_THREADS = 3;
pid_t* pid = (pid_t*)malloc(sizeof(pid_t));

void task1(int id){
  printf("Process #%d, Thread #%dn",*pid,id);
}

int main(){

  //fork() creates a new process
  pid[0] = fork(); 

  thread threads[NUM_THREADS];

  for(int i=0;i<NUM_THREADS;i++){
    //thread() creates a new thread
    threads[i] = thread(task1, i); 
  }

  for(int i=0;i<NUM_THREADS;i++){
    threads[i].join();
  }
}

This program outputs:

Process #0, Thread #0
Process #0, Thread #1
Process #1136, Thread #0
Process #1136, Thread #2
Process #0, Thread #2
Process #1136, Thread #1

Encapsulation

Description

Encapsulation is the binding of data with the functions which manipulate them. Encapsulation reduces complexity, protects our data, and makes our classes easier to change. Through data hiding, encapsulation leads to more abstraction.

Example

#include <iostream>
#include <string>

using namespace std;

class product{
  double price;
  string name;
  
  public:
    double getPrice(){
      return price;  
    };
    
    string getName(){
      return name;  
    };
    
    void setPrice(double p){
        price = p;
    }
    
    void setName(string n){
        name = n;
    }
};

int main()
{
    product p;
    p.setPrice(19.99);
    p.setName("Overpriced Hamburger");
    
    cout << "The " << p.getName() << " is $" << p.getPrice();

    return 0;
}

This progam outputs:

The Overpriced Hamburger is $19.99

Dependency Injection

Description

Dependency injection is providing the service objects that a client object needs instead of having the client object define the service objects themselves. Dependency injection can make testing and configuration easier, but can lead to less readable code.

Example

#include <iostream>

using namespace std;

class service{
};

class client{
    
    service myService;
    
    public:
        client(service s){
        }
};

int main()
{
    service s;
    client c(s);
    return 0;
}

Detached Threads

Description

Detached threads are threads that have had their "detached()" member function called. They cannot be joined. When a detached thread is done, its resources are destroyed safely.

Example

#include <iostream>
#include <thread>
#include <unistd.h>

using namespace std;

int main ()
{
  thread t1([]{
     cout << "t1 started" << endl;
     sleep(3);
     cout << "t1 done" << endl;
  });
  
  thread t2([]{
     cout << "t2 started" << endl;
     sleep(2);
     cout << "t2 done" << endl;
  });
  
  thread t3([]{
     cout << "t3 started" << endl;
     sleep(1);
     cout << "t3 done" << endl;
  });
  
  t1.detach();
  t2.detach();
  t3.detach();
  
  sleep(5);

  return 0;
}

This program outputs:

t1 started
t3 started
t2 started
t3 done
t2 done
t1 done

Diamond Probelem of Inheritance

Description

The diamond problem of inheritance is an issue where multiple inheritance can lead to ambigious data. The diamond problem is the following:

We have four classes: A, B, C, and D

A has an uninitialized public member e

B and C publicaly inherit A and initialize e

D publicaly inherits B and C

What is the value of e when you initialize D?

Example

#include <iostream>
#include <string>

using namespace std;

class animal{   
    
    public:
        virtual string says(){
            return "generic sound";
        }
        
        animal(){
            cout << "animal init" << endl;
        }
        
        double height, width;
};

//virtual here allows for says() function to not be ambigious
class duck : virtual public animal {
    public:
        string says(){
            return "quack";
        }
        
        duck(){
            cout << "duck init" << endl;
        }
};

//virtual here allows for says() function to not be ambigious
class mammal : virtual public animal{
    public:
        string says(){
            return "generic mammal sound";
        }
        
        mammal(){
            cout << "mammal init" << endl;
        }
};

class platypus: public duck,mammal{
    public:
    string says(){
        return "platypus sound";
    }
    
    platypus(){
        cout << "platypus init" << endl;
    }
};


int main()
{
    animal *a = new platypus();
    cout << a->says() << endl;
    
    return 0;
}

This program outputs:

animal init
duck init
mammal init
platypus init
platypus sound

Enumerations

Description

A user defined set of named constants. It is a way of associating names with integers.

Example

#include <iostream>

enum temperature {cold, lukewarm, hot};
enum direction {East=0, West=180, North=90, South=270};

int main() {
  temperature temp1 = cold;
  temperature temp2 = hot;

  direction direction1 = East;
  direction direction2 = South;

  std::cout << temp1 << std::endl;
  std::cout << temp2 << std::endl;
  std::cout << direction1 << std::endl;
  std::cout << direction2 << std::endl;
}

This program outputs:

Factory Method

Description

A factory method is a design pattern that lets you create a derived class at run time. A factory method returns a pointer to a virtual class. The virtual class is initalized as a derived class. Factory methods are needed with C++, becuase virtual constructors are not supported.

Example

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

class machine_ops{
    public:
        static machine_ops *make_instance(bool isLinux);
        virtual void power_off() = 0;
        virtual void reset() = 0;
};

class linux : public machine_ops{
    public:
        void power_off(){
            cout << "Powering off Linux style" << endl;
        }
        
        void reset(){
            cout << "Resetting Linux style" << endl;
        }
};

class windows : public machine_ops{
    public:
        void power_off(){
            cout << "Powering off Windows style" << endl;
        }
        
        void reset(){
            cout << "Resetting Windows style" << endl;
        }
};

machine_ops* machine_ops::make_instance(bool is_linux){
    if(is_linux){
        return new linux();
    }else{
        return new windows();
    }
}

int main() {
	
	machine_ops* m = machine_ops::make_instance(1);
	m->power_off();
	m->reset();
	
	return 0;
}

This program outputs:

Powering off Linux style
Resetting Linux style

Final

Description

Final is a keyword which prevents virtual functions from being overriden.

Example

#include <iostream>
#include <vector>

using namespace std;

class fish{
    public:
        virtual void print_home() final{
            cout << "Ocean" << endl;
        };
        void print_shape(){
            cout << "Long" << endl;
        };
};

class flounder : public fish{
    
    public:
        //Not allowed, would return error
        // void print_home(){
        //     cout << "Sand" << endl;
        // };
        
        void print_shape(){
            cout << "Flat" << endl;
        }
    
};

int main(){
    fish f1;
    f1.print_home();
    f1.print_shape();
    
    flounder f2;
    f2.print_home();
    f2.print_shape();
    
    return 0;
}

This program outputs:


Ocean
Long
Ocean
Flat

Friend Class

Description

A friend class in C++ can access the private and protected members of the class in which it was declared as a friend. A derived class cannot give itself access to it's parent class's private. Proper use of friend classes increases encapsulation.

Example

#include <iostream>
#include <vector>

using namespace std;

class flower;

class petal{
    string color;
    friend flower;
    
    public:
        string getColor(){
            return color;
        }
};

class flower{
    public:
        vector<petal> ps;
        void set_color(string c){
            for(auto &v : ps){
                v.color = c;
            }
        }
        
};

int main()
{
    flower f;
    f.ps.push_back(petal());
    f.ps.push_back(petal());
    f.ps.push_back(petal());
    f.set_color("periwinkle");
    for(auto &v : f.ps){
        cout << v.getColor() << endl;
    }
   
    return 0;
}

This program outputs:

periwinkle
periwinkle
periwinkle

Friend Function

Description

A function that is given access to private and protected data. They are defined outside of the class scope.

Example

#include <iostream>
#include <vector>

using namespace std;

class grass{
    double length;
    
    friend void cut(grass &g);
    
    public:
        double getLength(){
            return length;
        };
    
        grass(double l){
            length = l;
        }

};

void cut(grass &g){
    g.length = 3;
}

int main()
{
    grass g1(5);
    grass g2(3);
    grass g3(6);
    
    cout << "Before cut" << endl;
    cout << g1.getLength() << endl;
    cout << g2.getLength() << endl;
    cout << g3.getLength() << endl;
    
    cut(g1);
    cut(g2);
    cut(g3);

    cout << endl << "After cut" << endl;    
    cout << g1.getLength() << endl;
    cout << g2.getLength() << endl;
    cout << g3.getLength() << endl;
    
    return 0;
}

This program outputs:


Before cut
5
3
6

After cut
3
3
3

Inline Functions

Description

Forces the compilier to directly replace function calls with the contents of the function. This allows faster runtimes for functions that are small and called often.

Example

#include <iostream>
#include <chrono>
#include <thread>
#include <iostream>
#include <float.h>

using namespace std;

double small_increase(double a){
    return a*1.00001;
}    

inline double inline_small_increase(double a){
    return a*1.00001;
}    

int main(){
    
    double x = 2;
    double y = 2;
    
    auto t1 = chrono::high_resolution_clock::now();
    while(x < DBL_MAX){
        x = small_increase(x);
    }
    auto t2 = chrono::high_resolution_clock::now();
    while(y < DBL_MAX){
        y = inline_small_increase(x);
    }
    auto t3 = chrono::high_resolution_clock::now();
    
    cout << "non-inline took "
              << chrono::duration_cast<std::chrono::milliseconds>(t2-t1).count()
              << " milliseconds" << endl;
    cout << "inline took "
              << chrono::duration_cast<std::chrono::milliseconds>(t3-t2).count()
              << " milliseconds" << endl;
}

This program outputs:

non-inline took 132 milliseconds
inline took 0 milliseconds

Interfaces

Description

Example

Interfaces are used to separate the declaration from the implementation. Implementation of an interface is done with run-time polymorphism. An abstract class that only has pure abstract classes is an interface. Pure virtual functions are virtual functions which end in "=0";

Example#include <iostream>

using namespace std;

class person{
    public:
    virtual void speak() = 0;
    virtual int getSalary() = 0;
};

class teacher : person{
    public: 
    void speak(){
        cout << "Today's lesson is..." << endl;
    }
    int getSalary(){
        return 50000;
    }
};

class student : person{
    public:
    void speak(){
        cout << "I love learning" << endl;
    }
    int getSalary(){
        return 0;
    }
};

int main ()
{
  teacher t;
  student s;
  t.speak();
  s.speak();

  return 0;
}

This program outputs:

Today's lesson is...
I love learning

Inheritance

Description

Inheritance is when you define a class in terms of another class. It allows us to write less code. Less code equals less opportunities for bugs. Inheritance is a "is a" relationship. For example, a vehicle IS A car. There are three kinds of inheritance: public, protected, and private. A derived class inherits all of the base class's methods except for: constructors, destructors, copy constructors, overloaded operators, and friend functions. When a derived class overrides a method from its parent, not only does the overriden function become hidden, but all of the overloaded methods of the parent become hidden too. These hidden parent methods can still be access using their scope resolution operator.

Example

#include <iostream>
#include <string>

using namespace std;

class edible{
    public:
    int calories;
};

class animal{
    public:
    int consumed_calories = 0;
    virtual void eat(edible e) = 0;
};

class tiger : public animal{
    public:
    void eat(edible e){
        consumed_calories += e.calories;
        cout << "The tiger has " << consumed_calories << " total calories" << endl;
    }
};

class rabbit : public edible, public animal{
    public:
    void eat(edible e){
        consumed_calories += e.calories;
        cout << "The rabbit has " << consumed_calories << " total calories" << endl;
    }
    
    rabbit(){
        calories = 5000;
    }
};

class grass : public edible{
    public:
    grass(){
        calories = 1;
    }
};

int main()
{
    tiger t1;
    rabbit r1;
    grass g1;
    grass g2;
    grass g3;
    
    r1.eat(g1);
    r1.eat(g1);
    r1.eat(g1);
    t1.eat(r1);

    return 0;
}

This program outputs:

The rabbit has 1 total calories                                                                                                                                              
The rabbit has 2 total calories                                                                                                                                              
The rabbit has 3 total calories                                                                                                                                              
The tiger has 5000 total calories

Iterators

Description

Any object that points to some element and has the ability to iterate through the elements with the operators "++"(increment) and "*"(dereference).

Example

#include <iostream>
#include <iterator>
#include <vector>
#include <deque>

//This function returns the mean of a iterable container
template <class InputIterator, class T> double mean(InputIterator first, InputIterator last, T init){

  T output = 0;
  double count = 0;

  while (first!=last) {
    output += *first;
    first++;
    count++;
  }
  return output/count;
}

int main() {
  std::vector<int> v = {1,2,3,4};
  std::deque<double> d = {5.1,5.2,5.3};
  std::cout << mean(v.begin(),v.end(),0) << std::endl;
  std::cout << mean(d.begin(),d.end(),0.0) << std::endl;
}

This program outputs:

2.5
5.2

Lambda Functions

Description

A function written in line without an identifier. Functions without idenfifiers are called "anonymous functions". Anonymous functions can only be invoked once.

Example

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

typedef struct rectangle{
  double width;
  double height;
} rectangle;

int main(){

    vector<rectangle> rects;
    rectangle r1 = {0,1};
    rects.push_back(r1);
    rectangle r2 = {3,3};
    rects.push_back(r2);
    rectangle r3 = {1,2};
    rects.push_back(r3);
    rectangle r4 = {4,4};
    rects.push_back(r4);
    rectangle r5 = {2,1};
    rects.push_back(r5);
    
    sort(rects.begin(), rects.end(), [](const rectangle& a, const rectangle& b) -> bool{ 
        return a.width * a.height < b.width * b.height; 
    }); 
    
    cout << "width, height" << endl;
    for(auto &v:rects){
        cout << v.width << ", " << v.height << endl;
    }
    
    return 0;
}

This program outputs:

width, height
0, 1
1, 2
2, 1
3, 3
4, 4

Lvalue vs Rvalue

Description

An lvalue is an object reference and a rvalue is a value. Lvalues have a defined region of storage which has an address, while rvalues do not. A single ampersand is how you do a lvalue reference and a double ampersand is how you do a rvalue reference. Rvalue references were added in C++11.

Example

#include <iostream>
#include <string>
#include <vector>

using namespace std;

void add_and_print(int& v){
    v += 1;
    cout << "lvalue ref: " << v << endl;
}

void add_and_print(int&& v){
    v += 1; //Cannot be accessed later, because it doesn't have a set address
    cout << "rvalue ref: " << v << endl;
}

int main()
{
    int x = 5;
    add_and_print(x);
    cout << x << endl << endl;
    
    add_and_print(5);
}

This program outputs:

lvalue ref: 6
6

rvalue ref: 6

Mutexes

Description

Lockable objects that are designed to signal when critical sections of code require exclusive access. They lock when they get to the critical section and unlock once they are done with it.

Example

#include <iostream>
#include <thread>
#include <mutex>
#include <unistd.h>

const uint NUM_THREADS = 3;

using namespace std;

mutex m;

void hello_without_mutex(uint id) {
  cout << " Hello";
  usleep(1000);
  cout << " I am ";
  cout << id << endl;
}

void hello_with_mutex (uint id) {
  lock_guard<std::mutex> g(m); 
  cout << " Hello";
  usleep(1000);
  cout << " I am ";
  cout << id << endl;
}

int main() {

  cout << "Without Mutexes:" << endl;

   thread threads1[NUM_THREADS];
   for(uint i=0;i<NUM_THREADS;i++){
     threads1[i] = thread(hello_without_mutex,i);
   }

   for(int i=0;i<NUM_THREADS;i++){
     threads1[i].join();
   }
   
   cout << endl;
   cout << "With Mutexes:" << endl;

   thread threads2[NUM_THREADS];
   for(uint i=0;i<NUM_THREADS;i++){
     threads2[i] = thread(hello_with_mutex,i);
   }

   for(int i=0;i<NUM_THREADS;i++){
     threads2[i].join();
   }
}

This program outputs:

Without Mutexes:
 Hello Hello Hello I am 0
 I am 2
 I am 1

With Mutexes:
 Hello I am 0
 Hello I am 2
 Hello I am 1

No Except

Description

Noexcept is a specifier which makes it so that a function is not allowed to throw an exception.

Example

#include <iostream>

using namespace std;

double the_number_two() noexcept {
    //throw 2; THIS WOULD CAUSE AN ERROR
    return 2;
}

int main(){
    the_number_two();
    return 0;
}

Call_once Flag

Description

The call once flag ensures that a callable is only called once. The "call_once()" function take a once_flag and callable function as parameters.

Example

#include <iostream>
#include <mutex>
#include <time.h>
#include <chrono>

using namespace std;

once_flag flag;
string x;

void get_time(){
    time_t     now = time(0);
    struct tm  tstruct;
    char       buf[80];
    tstruct = *localtime(&now);
    strftime(buf, sizeof(buf), "%Y-%m-%d.%X", &tstruct);
    
    x = buf;
}

int main(){
    
    call_once(flag,get_time);
    cout << x << endl;
    call_once(flag,get_time);
    cout << x << endl;
    call_once(flag,get_time);
    cout << x << endl;
    
    return 0;
}

This program outputs:

2020-12-13.22:18:36
2020-12-13.22:18:36
2020-12-13.22:18:36

Override Keyword

Description

The override keyword shows the reader of the code that you are overriding a virtual function. When this keyword is used, the compiler will verify that your function is being overridden. Good C++ software engineers prefer compile time errors over runtime errors.

Example

#include <iostream>
#include <vector>

using namespace std;

class item{
    public:
        virtual double price() = 0;
};

class banana : public item{
    public:
        double price() override {
            return 1.00;
        }
};

int main()
{
    item* i = new banana();
    cout << i->price() << endl;
    
    return 0;
}

This program outputs:

Packaged Task

Description

A packaged task is a class template that wraps a callable target so that it can be invoked asynchronously. The callable target can be a function, lambda expression, bind expression, or another function object. The packaged task's callable can be executed with the () operator and its return value is gotten with the get_future() member.

Example

#include <iostream>
#include <future>
#include <functional>

using namespace std;

double multiply(double x, double y){
    cout << "multiply() called" << endl;
    return x * y;
}

int main()
{
    
    cout << "Storing tasks" << endl;
    
    vector<packaged_task<double()> > tasks;
    vector<future<double> > results;
    
    for(double i=1;i<=2;i++){
        for(double j=1;j<=2;j++){
            packaged_task<double()> task(bind(multiply,i,j));
            
            results.push_back(task.get_future());
            tasks.push_back(move(task));
        }
    }
    
    cout << "Running tasks" << endl;
    for(auto &v : tasks){
        v();    
    }
    
    cout << "Getting Results" << endl;
    for(auto &v : results){
        cout << v.get() << endl;
    }
    
}

This program outputs:

Storing tasks
Running tasks
multiply() called
multiply() called
multiply() called
multiply() called
Getting Results
1
2
2
4

PIMPL Idiom

Description

The PIMPL idiom is when you move all private members of a class from its header file to its implementation file. This provides two benefits: less complilation time when change a class's private members and more data hiding which improves abstraction. PIMPL is useful if your library is confidential. The private members are moved to the implemenation file by:

Forward declaring an "IMPL" class as a public member in the header

Declaring an unique pointer to the "IMPL" class

Defining the "IMPL" class as a struct in the implmentation file containg all of the private members

And finally initalizing the "IMPL" class in the main class's constructor

Example

#include <iostream>
#include <string>
#include <memory>

using namespace std;

//HEADER FILE
class launch_nuclear_missle {
    private:
        class IMPL;
        unique_ptr<IMPL> impl_;
    public:
        launch_nuclear_missle();
};

//IMPLEMENTATION FILE
struct launch_nuclear_missle::IMPL{
    void call_president(); //We don't want anyone seeing this
    void call_general(); //We don't want anyone seeing this
};

launch_nuclear_missle::launch_nuclear_missle() : impl_(new IMPL){
    impl_->call_president();
    impl_->call_general();
}

void launch_nuclear_missle::IMPL::call_president(){
    cout << "Calling Mr. President..." << endl;
}

void launch_nuclear_missle::IMPL::call_general(){
    cout << "Calling the general..." << endl;
}

int main()
{
    launch_nuclear_missle();
    return 0;
}

This program outputs:

Calling Mr. President...
Calling the general...

Predicate

Description

Predicates are any callable function which returns a bool. Many STL algorithms use predicates as an input. For example, all_of(), any_of(), and none_of().

Example

#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

//This is a predicate
bool is_positive(int i){
    if(i) return true;
    return false;
}

int main() {
    
    vector<int> nums = {0,1,-5,5,9,-9};
    
    cout << all_of(nums.begin(),nums.end(),is_positive) << endl;
    cout << any_of(nums.begin(),nums.end(),is_positive) << endl;
    cout << none_of(nums.begin(),nums.end(),is_positive) << endl;

    return 0;
}

This program outputs:

0
1
0

Public VS Protected VS Private Inherience

Description

Public inheritance has everything able to access everything of the base class. Protected inheritance only has the children able to access everything of the base class. Private inheritance only allows the parent to have access to everything. Default inheritance is private.

Example

#include <iostream>
#include <string>

using namespace std;

class public_child{
    public:
        string a = "public childred"; 
};

class protected_child{
    public:
        string b = "protected childred"; 
};

class private_child{
    public:
        string c = "private childred"; 
};

class A : public public_child, protected protected_child, private private_child{
    
    public:
        string get_b(){
            return b;
        }
        
        string get_c(){
            return c;
        }
        
};

class B : A {
    
    public:
        string get_a(){
                return b;
        }
        
        string get_b(){
                return b;
        }
};

int main()
{
  A test;
  cout << test.a << " can access directly" << endl;
  cout << test.get_b() << " and " << test.get_c() << " need getters" << endl;
  B test2;
  cout << test2.get_a() << " and " << test2.get_b() 
  << " can be printed by children of the base class" << endl;
}

This program outputs:

public childred can access directly
protected childred and private childred need getters
protected childred and protected childred can be printed by children of the base class

Race Conditions

Description

A race condition is when two or more threads try to read or write a piece of data and atleast one of those threads is writing. Race conditions result in undefined behavior. The cure for a race condition, most of the time, is mutexes.

Example

#include <iostream>
#include <thread>
#include <unistd.h>
#include <stack>

using namespace std;

std::stack<int> s;

void remove_add_1(){
    //MUTEX HERE WOULD PREVENT RACE CONDITION
    s.pop();
    usleep(1000);
    s.push(1);
    cout << s.top() << endl;
}

int main(){
    
    s.push(0);
    
    thread readers[10];
    
    for(int i=0;i<10;i++){
        readers[i] = thread(remove_add_1);
    }
    
    for(int i=0;i<10;i++){
        readers[i].join();
    }
}

This program outputs:

Created
Segmentation Fault

RAII

Description

Stands for "Resource Acquistion Is Initialization". This is a terrible name for a great concept. A better name for RAII would be "Scope Based Memory Management". The resource allocation is done at initialization by the constructor and the resource deallocation is done at finalization by the destructor.

Example

#include <iostream>
#include <memory>

class true_false_exam{
  public:
  bool* answers;

  true_false_exam(){
    answers = new bool(100); 
    std::cout << "Created" << std::endl;
  }

  ~true_false_exam(){
    delete (answers);
    std::cout << "Deleted" << std::endl;
  }
};

int main() {
  //Unique pointer will automatically call the deconstructor
  //once the object is out of scope
  std::unique_ptr<true_false_exam> t(new true_false_exam());
}

This program outputs:

Created
Deleted

reference_vs_pointer

Reference Vs. Pointer

Description

A pointer holds an address in memory. In order to access the data to this address, the programmer has to use the dereference operator "*". References are an alias of an existing variable. One can think of references as a constant pointer who's value can be changed, but its address cannot.

Example

#include <iostream>
using namespace std;

int main() {
	
	int* ptr = new int(0);
	int& ref = *ptr;
	
	cout << "ptr address: " << ptr << endl;
	cout << "ptr value: " << *ptr << endl;
	cout << "ref value: " << ref << endl << endl;
	ref++;
	cout << "ptr address: " << ptr << endl;
	cout << "ptr value: " << *ptr << endl;
	cout << "ref value: " << ref << endl << endl;
	ptr = new int(5);
	cout << "ptr address: " << ptr << endl;
	cout << "ptr value: " << *ptr << endl;
	cout << "ref value: " << ref << endl;
	
	return 0;
}

This program outputs:

ptr address: 0x10d2c20
ptr value: 0
ref value: 0

ptr address: 0x10d2c20
ptr value: 1
ref value: 1

ptr address: 0x10d3c50
ptr value: 5
ref value: 1

Scoped Lock

Description

A scoped lock locks an arbitrary number of mutexes and avoids deadlocks. If you use scoped lock with only one lock, it works very similar to lock_guard.

Example

#include <iostream>
#include <mutex>
#include <thread>
#include <unistd.h>

using namespace std;

int num_cheese = 10;
int num_bread = 20;
int num_sandwichs = 0;

mutex m1,m2,m3;

int main()
{
    for(int i=0;i<10;i++){
        thread t([i]{
            scoped_lock s(m1,m2,m3);
            num_cheese -= 1;
            num_bread -= 2;
            num_sandwichs++;
            cout << i << " made their sandwich" << endl;
            cout << "num_sandwichs: " << num_sandwichs << endl;
            usleep(100);
        });
        
        t.detach();
    }
    
    sleep(1);
    
    
    return 0;
}

This program outputs:

0 made their sandwich
num_sandwichs: 1
4 made their sandwich
num_sandwichs: 2
2 made their sandwich
num_sandwichs: 3
3 made their sandwich
num_sandwichs: 4
1 made their sandwich
num_sandwichs: 5
5 made their sandwich
num_sandwichs: 6
6 made their sandwich
num_sandwichs: 7
7 made their sandwich
num_sandwichs: 8
8 made their sandwich
num_sandwichs: 9
9 made their sandwich
num_sandwichs: 10

Semaphores

Description

Used to control access to a common resource. When you create a semaphore you give it a starting resource count. Every time we use a resource we decrement from the resource count. Every time we are done with the resource we increment. If the resource count is less than zero, when we want the resource, then we must wait until the resource count is greater than or equal to zero.

Semaphores which allow an arbitrary resource count are called "counting semaphores". Semaphores which are either locked or unlocked are called "binary semaphores". Binary semaphores can be used as a mutex.

Example

#include <iostream>
#include <pthread.h>
#include <vector>
#include <mutex>

using namespace std;

const uint NUM_THREADS = 5;

class semaphore{
    
    private: 
        pthread_mutex_t lock;
        pthread_cond_t wait;
        int value;
        
        
    public: 
    
        semaphore(int v){
            value = v;
            pthread_cond_init(&wait,NULL);
            pthread_mutex_init(&lock,NULL);
        }
        
        void P(){
            value--;
            if(value < 0) {
                pthread_cond_wait(&wait,&lock);
            }
            pthread_mutex_unlock(&lock);
        }
        
        void V(){
            pthread_mutex_lock(&lock);
            value++;
            if(value <= 0) {
                pthread_cond_signal(&wait);
            }
            pthread_mutex_unlock(&lock);
        }

};

semaphore* s = new semaphore(2);

void *test_func(void *input) {
    
    int id = *((int*)(&input));
    
    printf("%d is inn",id);
    s->P();
    
    for(int wasting_time=0;wasting_time<1000000000*id;wasting_time++);

    s->V();
    printf("%d is outn",id);
    
    return NULL;
}

int main(){   
    pthread_t threads[NUM_THREADS];
    
    //Starting each thread
    for(uint i = 0; i < NUM_THREADS; i++) {
        pthread_create(&threads[i], NULL, test_func, (void*)i);
    }

    //Stopping and collecting data from each thread
    for(uint i = 0; i < NUM_THREADS; i++) {
        pthread_join(threads[i], NULL);
    }
}

This program outputs:

 0 is in
  0 is out
  2 is in
  4 is in
  4 is out
  2 is out
  1 is in
  1 is out
  3 is in
  3 is out

Shared Lock

Description

Shared locks can be used in conjunction with unique locks to allow multiple readers and exclusive writers. They are similar to unique_locks in that they can be moved but not copied. Shared locks are used for read integrity.

Example

#include <iostream>
#include <shared_mutex>
#include <mutex>
#include <thread>
#include <unistd.h>

using namespace std;

double price = 0;
shared_timed_mutex m;
mutex pm;

void update_price(double p){
    unique_lock ul(m);
    price = p;
    lock_guard<mutex> lg(pm);
    cout << "The new price is " << price << endl;
}

double read_price(){
    shared_lock sl(m);
    lock_guard<mutex> lg(pm);
    cout << "Reading price: " << price << endl;
    return price;
}

int main(){
        
    for(uint i=0;i<10;i++){
        
        usleep(100);
        
        thread t;
        
        if(i%3==0){
            t = thread(update_price,i);
        }
        else{
            t = thread(read_price);
        }
    
        t.detach();
        
    }
    
    sleep(1);
    
    
    return 0;
}

This program outputs:

The new price is 0
Reading price: 0
Reading price: 0
The new price is 3
Reading price: 3
Reading price: 3
The new price is 6
Reading price: 6
Reading price: 6
The new price is 9

Slicing

Description

Slicing is when you assign an object of a derived class to an instance of a base class, therefore some its information is "sliced" away.

Example

#include <iostream>
#include <string>

using namespace std;

class vehicle{
    public:
        string color = "red";
};

class truck : public vehicle{
    public:
        double bed_size = 5;
};

int main()
{
    vehicle* v = new truck();
    cout << v->color << endl;
    //cout << v->bed_size << endl; This is sliced away
    
    return 0;
}

This program outputs:

red

Smart Pointer

Description

Similar to a pointer except it has automatic memory management. Once the scope of the smart pointer ends, the program knows to destory the pointer. There are currently three kinds of smart pointers: "unique_ptr", "shared_ptr", and "weak_ptr". There used to be an "auto_ptr", but this was deprecated in c++11 and removed in c++17.

Unique Pointers

Owns and manages another object through a pointer and disposes of it when the pointer goes out of scope. If you try to make a copy of a unique pointer, the compilier will give you an error.

Shared Pointers

Same thing as a unique pointer, except you are allowed to make copies.

Weak Pointers

Smart pointer that has a non-owning("weak") reference to an object that is a shared pointer.

Example

#include <iostream>
#include <string>
#include <memory>

class named_object{

  public:

    std::string name;

    named_object(std::string n){
      name = n;
      std::cout << name << " created" << std::endl;
    }

    ~named_object(){
      std::cout << name << " deleted" << std::endl;
    }
};

int main() {
  //The raw pointer is not deleted correctly because it is not "smart"
  named_object* raw = new named_object("raw pointer"); 

  //The unique, shared, and weak pointers below are deleted correctly
  //because they are "smart"
  std::unique_ptr<named_object> unique(new named_object("unique"));
  std::shared_ptr<named_object> shared(new named_object("shared"));
  std::shared_ptr<named_object> shared2 = shared;
  std::weak_ptr<named_object> weak = shared2;
}

This program outputs:

raw pointer created
unique created
shared created
shared deleted
unique deleted

static_vs_dynamic_memory

Static vs Dynamic memory

Description

Static memory lives on heap and dynamic memory lives on the stack. As static memory is allocated, the heap travels down and as dynamic memory is allocated the stack travels up. If the heap and the stack meet each other in the middle, you are out of memory! Static memory is managed by the compiler and dynamic memory is managed by the programmer. In order to create static data the programmer can use common initialization, for example "int i = 5;". If the programmer wants to create dynamic data, they use "new" or "malloc". "new" or "malloc" allocates memory on the stack and returns the address of the allocated memory. This address is stored in a "pointer". If the program attempts to allocate memory when there is not enough, new would throw a "bad_alloc" and malloc would return a nullptr. If the programmer does not free the dynamically allocated memory, a data leak occurs.

STL Algorithms

Description

The STL algorithms are a large number of helpful algorithms each implemented with iterator. Some of the algorithms require an operator to declared, for example "<". STL algorithms are helpful for writing fast programs quickly.

Example

#include <iostream>
#include <vector>
#include <algorithm>
#include <chrono>
#include <random>

using namespace std;

int main()
{
    vector<char> kemps_deck;
    for(int i=0;i<4;i++){
        for(int j=0;j<9;j++){
            kemps_deck.push_back(48+j);
        }
        kemps_deck.push_back('J');
        kemps_deck.push_back('Q');
        kemps_deck.push_back('K');
        kemps_deck.push_back('A');
    }
    
    unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();
    shuffle(kemps_deck.begin(),kemps_deck.end(),default_random_engine(seed)); //from <algorithm>
    
    vector<char> player1_hand;
    vector<char> player2_hand;
    vector<char> player3_hand;
    vector<char> player4_hand;
    
    for(int i=0;i<4;i++){
        player1_hand.push_back(kemps_deck.back());
        kemps_deck.pop_back();
        player2_hand.push_back(kemps_deck.back());
        kemps_deck.pop_back();
        player3_hand.push_back(kemps_deck.back());
        kemps_deck.pop_back();
        player4_hand.push_back(kemps_deck.back());
        kemps_deck.pop_back();
    }
    
    sort(player1_hand.begin(),player1_hand.end()); //from <algorithm>
    sort(player1_hand.begin(),player1_hand.end()); //from <algorithm>
    sort(player1_hand.begin(),player1_hand.end()); //from <algorithm>
    sort(player1_hand.begin(),player1_hand.end()); //from <algorithm>

    cout << "Player 1's Hand: " << endl;
    for(int i=0;i<4;i++){
        cout << "   " << player1_hand[i] << endl;
    }
    if(equal(player1_hand.begin()+1,player1_hand.end(),player1_hand.begin())){
        cout << "   " << "Player 1 has kemps" << endl;
    }
    
    cout << "Player 2's Hand: " << endl;
    for(int i=0;i<4;i++){
        cout << "   " << player2_hand[i] << endl;
    }
    if(equal(player1_hand.begin()+1,player1_hand.end(),player1_hand.begin())){
        cout << "   " << "Player 2 has kemps" << endl;
    }
    
    cout << "Player 3's Hand: " << endl;
    for(int i=0;i<4;i++){
        cout << "   " << player3_hand[i] << endl;
    }
    if(equal(player1_hand.begin()+1,player1_hand.end(),player1_hand.begin())){
        cout << "   " << "Player 3 has kemps" << endl;
    }
    
    cout << "Player 4's Hand: " << endl;
    for(int i=0;i<4;i++){
        cout << "   " << player4_hand[i] << endl;
    }
    if(equal(player1_hand.begin()+1,player1_hand.end(),player1_hand.begin())){
        cout << "   " << "Player 4 has kemps" << endl;
    }
    
    return 0;
}

This program outputs:


Player 1's Hand: 
   4
   6
   A
   K
Player 2's Hand: 
   7
   7
   7
   7
   Player 2 has kemps
Player 3's Hand: 
   J
   2
   8
   A
Player 4's Hand: 
   Q
   2
   4
   J

Terminate

Description

Terminate is called automatically in a C++ program when there is an unhandled exception. The function "set_terminate()" allows you to set which function gets called on terminate.

Example

#include <iostream>
#include <vector>

using namespace std;

void handle(){
    cout << "Exception thrown but nothing to catch it..." << endl;
}

int main(){
    set_terminate(handle);
    
    vector<int> p;
    p.at(0);
    
    return 0;
}

This program outputs:


Exception thrown but nothing to catch it...
bash: line 7: 15928 Aborted                 (core dumped) ./a.out

Type Generics

Description

Allows you write code without stating the actual data type. The use of generics is commonly seen in data structures like array and vector. Generics make our code more reusable.

Example

#include <iostream>
#include <string>

using namespace std;

template <typename T> T myAbs(T a){
    if(a < 1) a *= -1;
    return a;
}

int main(){
    double x = -1.2;
    int y = 100;
    float z = -20.9;
    
    cout << myAbs(x) << endl;
    cout << myAbs(y) << endl;
    cout << myAbs(z) << endl;
}

This program outputs:

1.2
100
20.9

Unique Locks

Description

Unique locks on construction locks a mutex and on destruction unlocks a mutex. Unique locks differs from lock guards, because they can be unlocked.

Example

#include <iostream>
#include <mutex>
#include <thread>
#include <vector>
#include <unistd.h>

using namespace std;

mutex m;

int main() {
    
    vector<thread> threads;
    
    for(int i=0;i<10;i++){
        threads.push_back( 
            thread([i]{
                unique_lock<mutex> ul(m);
                cout << i << "'s critical";
                usleep(1*100);
                cout << " section";
                usleep(1*100);
                cout << endl;
                usleep(1*100);
            })
        );
    }
    
    for(int i=0;i<10;i++){
        threads[i].join();
    }

    return 0;
}

This program outputs:

0's critical section                                                              
3's critical section                                            
4's critical section                                           
5's critical section                                            
6's critical section                                           
7's critical section                                            
8's critical section                                            
2's critical section                                           
1's critical section                                            
9's critical section

Threads

Description

A sequence of instructions which can be executed concurrently. Each thread is given a function to run and parameters for its function. A join function is used to finish the thread and collect its returned data. Threads have the risks of errors due to things like race condidtions. However concurrency can greatly improve the run time of your program.

Example

#include <iostream>
#include <cstdlib>
#include <pthread.h>

using namespace std;

const uint NUM_THREADS = 5;

//Data for each thread
struct thread_data{
  int thread_id;
  int input;
};

//Function which each thread will do
void *calc_part(void *input) {

  thread_data* ptr = (thread_data*)input;
  int n = ptr->thread_id;
  int m = ptr->input;

  int* thread_sum = (int*)malloc(sizeof(int));

  thread_sum[0] = 1;

  for(int i=1;i<=m;i++){
    if(i%NUM_THREADS == n){
      thread_sum[0] *= i;
    }
  }

  //Using printf instead to prevent race conditions
  printf("  Thread  #%d returns %dn",n,thread_sum[0]);
  pthread_exit(thread_sum);
}

int factorial(int x){

  cout << "Input is " << x << endl;

  if(x==0){
    cout << "Output is 0" << endl;
    return 0;
  }

  int output = 1;

  pthread_t threads[NUM_THREADS];

  int** results = (int**)malloc(sizeof(int) * NUM_THREADS);

  //Setting up the data for each thread
  thread_data* thread_datas = (thread_data*)malloc(sizeof(thread_data) * NUM_THREADS);
  for(int i = 0; i < NUM_THREADS; i++) {
    thread_data d; 
    d.thread_id = i;
    d.input = x;
    thread_datas[i] = d;
  }

  //Starting each thread
  for(int i = 0; i < NUM_THREADS; i++) {
    pthread_create(&threads[i], NULL, calc_part, &thread_datas[i]);
  }

  //Stopping and collecting data from each thread
  for(int i = 0; i < NUM_THREADS; i++) {
    pthread_join(threads[i], (void**)&results[i]);
    output *= results[i][0];
  }

  cout << "Output is " << output << endl;
  return output;
}

int main () {
  factorial(1);
  factorial(2);
  factorial(5);
  factorial(10);
}

This program outputs:

Input is 1
  Thread  #1 returns 1
  Thread  #2 returns 1
  Thread  #0 returns 1
  Thread  #3 returns 1
  Thread  #4 returns 1
Output is 1
Input is 2
  Thread  #0 returns 1
  Thread  #3 returns 1
  Thread  #4 returns 1
  Thread  #2 returns 2
  Thread  #1 returns 1
Output is 2
Input is 5
  Thread  #4 returns 4
  Thread  #2 returns 2
  Thread  #3 returns 3
  Thread  #1 returns 1
  Thread  #0 returns 5
Output is 120
Input is 10
  Thread  #2 returns 14
  Thread  #1 returns 6
  Thread  #0 returns 50
  Thread  #3 returns 24
  Thread  #4 returns 36
Output is 3628800

What makes a function "thread-safe"?

Description

Functions are thread-safe if they behave correctly during simultaneous executions of threads. The risk of a function not being thread safe comes entirely from data sharing. The easiest way to have a function be thread-safe is to have each thread only use private data or data which is handled with atomic operations. If non-atomic shared data is needed among the threads, the engineer must use mutual exclusion. Mutual exclusion opens a Pandora's box of possible bugs into your software including: deadlocks, race conditions, and starvation. If you must use threads, follow the K.I.S.S. principle: Keep It Simple Stupid!

Example

#include <stdlib.h>
#include <thread>
#include <mutex>
#include <iostream>
#include <atomic>
#include <vector>
#include <string> 
#include <unistd.h>

using namespace std;

//Local data only
void print_index(int size){
    
    vector<thread> t;
    
    for(int i=0;i<size;i++){
        t.push_back(thread([i]{
            cout << (to_string(i) + " ");
            sleep(1);
        }));
    }
    
    for(int i=0;i<size;i++){
        t[i].join();
    }
    cout << endl;
}

//Atomic operation only
int series_sum(int size){
    
    atomic<int> output = 0;
    
    vector<thread> t;
    
    for(int i=0;i<size;i++){
        t.push_back(thread([&output,i]{
            output += i;
        }));
    }
    
    for(int i=0;i<size;i++){
        t[i].join();
    }
    
    return output;
}

//Mutual Exclusions
int series_product(int size){
    
    int output = 1;
    
    vector<thread> t;
    
    mutex m1;
    
    for(int i=1;i<=size;i++){
        t.push_back(thread([&output,i,&m1]{
            lock_guard<mutex> g1(m1);
            output *= i;
        }));
    }
    
    for(int i=0;i<size;i++){
        t[i].join();
    }
    
    return output;
}

int main(){
    print_index(10);
    cout << series_sum(1000) << endl;
    cout << series_product(10) << endl;
}

This program outputs:

1 0 2 3 4 5 6 7 8 9 
499500
3628800

Vector vs List vs Array

Description

Lists are doubly linked lists which have O(1) insert and deletion times and O(N) random access time. Their elements may not be in order in memory and are best when you have to store a fixed number of large objects.

Vectors are dynamic arrays which have O(N) insert and deletion times and O(1) random access time. Their elements are in order and are best for storing many small objects that are randomly accessed often.

Arrays are inherited from C. They are similar to vectors except they are not resizable, more compact, and don't require STL headers.

Example

#include <iostream>
#include <vector>
#include <list>
using namespace std;

int main() {
	
	
	vector<int> v;
	list<int> l;
	int a[10]; //statically allocated
	
	for(int i=0;i<10;i++){
	    v.push_back(i);
	    l.push_back(i);
	    a[i] = i;
	}
	
	for(int i=0;i<10;i++){
	    cout << "vector: " << v[i] <<
	    " list: " << *l.begin()+i <<
	    " array: " << a[i] << endl;
	}
	
	return 0;
}

This program outputs:

vector: 0 list: 0 array: 0
vector: 1 list: 1 array: 1
vector: 2 list: 2 array: 2
vector: 3 list: 3 array: 3
vector: 4 list: 4 array: 4
vector: 5 list: 5 array: 5
vector: 6 list: 6 array: 6
vector: 7 list: 7 array: 7
vector: 8 list: 8 array: 8
vector: 9 list: 9 array: 9

Virtual

Description

Virtual functions are functions which are defined at runtime. This is called late-binding. They differ from normal functions, because normal function are defined at compile time AKA early-binding. Because virtual functions use late binding, they are overridable and are able to benefit from polymorphism. The implementation of the virtual method is decided by the pointer which you call it through.

Example

#include <iostream>

using namespace std;

class base{
    public:
        virtual void print_name(){
            cout << "base" << endl;
        };
        
        void print_name_non_virtual(){
           cout << "base" << endl;
        };
};

class derived : public base{
    
    public:
        void print_name(){
            cout << "derived" << endl;
        };  
        
        void print_name_non_virtual(){
           cout << "derived" << endl;
        };
};

int main(){

    derived d;
    base* bptr = &d;
    
    bptr->print_name(); //derived
    bptr->print_name_non_virtual(); //base
    bptr->base::print_name_non_virtual(); //base

    return 0;
}

This program outputs:


derived
base
base

Volatile

Description

Prevents the addresses from being optimized away. Volatile is needed for embedded development where the hardware device is memory-mapped and memory may change without the compilier knowing.

Example

int main(){
    
    //The compiler may optimize the while loop into "while(true)"
    int a = 100;
    while(a == 100){}
    
    //The compliler will not "optimize away" the b variable
    volatile int b = 100;
    while(b == 100){}
}

Colin's C++ & Object Oriented Programming Guide

Table of Contents

Abstraction

Description

Example

Abstract Class

Description

Example

Access Specifiers

Description

Example

Async, Future, and Promise

Description

Example

Atomic Datatypes

Description

Example

Atomic Flags

Description

Example

Bind

Description

Example

Compare Exchange Weak vs Strong

Description

Example

Auto

Description

Example

Automatically Constructors and Destructors

Description

Example

Condition Variables

Description

Example

Const

Description

Example

Context Switching

Description

Unoptimized for Context Switching

Optimized for Context Switching

Example

Copy Vs. Move

Description

Example

Deadlocks

Description

Example

Difference between a thread and a process

Description

Example

Encapsulation

Description

Example

Dependency Injection

Description

Example

Detached Threads

Description

Example

Diamond Probelem of Inheritance

Description

Example

Enumerations

Description

Example

Factory Method

Description

Example

Final

Description

Example

Friend Class

Description

Example

Friend Function

Description

Example

Inline Functions