// This is a source version of the cpp cheatsheet available here. Note that this does not compile but may have better
// color-highlight than the markdown version in an editor.
//
// Github version available here: https://github.com/mortennobel/cpp-cheatsheet

// # C++ QUICK REFERENCE / C++ CHEATSHEET
// Based on <a href="http://www.pa.msu.edu/~duxbury/courses/phy480/Cpp_refcard.pdf">Phillip M. Duxbury's C++ Cheatsheet</a> and edited by Morten Nobel-Jørgensen.
// The cheatsheet focus is both on the language as well as common classes from the standard library.
// C++11 additions is inspired by <a href="https://isocpp.org/blog/2012/12/c11-a-cheat-sheet-alex-sinyakov">ISOCPP.org C++11 Cheatsheet</a>).
//
// The goal is to give a concise overview of basic, modern C++ (C++14).
//
// The document is hosted on https://github.com/mortennobel/cpp-cheatsheet. Any comments and feedback are appreciated.

// ## Preprocessor

// Comment to end of line
/* Multi-line comment */
#include  <stdio.h>         // Insert standard header file
#include "myfile.h"         // Insert file in current directory
#define X some text         // Replace X with some text
#define F(a,b) a+b          // Replace F(1,2) with 1+2
#define X \
 some text                  // Multiline definition
#undef X                    // Remove definition
#if defined(X)              // Conditional compilation (#ifdef X)
#else                       // Optional (#ifndef X or #if !defined(X))
#endif                      // Required after #if, #ifdef


// ## Literals

255, 0377, 0xff             // Integers (decimal, octal, hex)
2147483647L, 0x7fffffffl    // Long (32-bit) integers
123.0, 1.23e2               // double (real) numbers
'a', '\141', '\x61'         // Character (literal, octal, hex)
'\n', '\\', '\'', '\"'      // Newline, backslash, single quote, double quote
"string\n"                  // Array of characters ending with newline and \0
"hello" "world"             // Concatenated strings
true, false                 // bool constants 1 and 0
nullptr                     // Pointer type with the address of 0

// ## Declarations

int x;                      // Declare x to be an integer (value undefined)
int x=255;                  // Declare and initialize x to 255
short s; long l;            // Usually 16 or 32 bit integer (int may be either)
char c='a';                 // Usually 8 bit character
unsigned char u=255;
signed char s=-1;           // char might be either
unsigned long x =
        0xffffffffL;              // short, int, long are signed
float f; double d;          // Single or double precision real (never unsigned)
bool b=true;                // true or false, may also use int (1 or 0)
int a, b, c;                // Multiple declarations
int a[10];                  // Array of 10 ints (a[0] through a[9])
int a[]={0,1,2};            // Initialized array (or a[3]={0,1,2}; )
int a[2][2]={{1,2},{4,5}};  // Array of array of ints
char s[]="hello";           // String (6 elements including '\0')
std::string s = "Hello"     // Creates string object with value "Hello"
std::string s = R"(Hello
World)";                    // Creates string object with value "Hello\nWorld"
int* p;                     // p is a pointer to (address of) int
char* s="hello";            // s points to unnamed array containing "hello"
void* p=nullptr;            // Address of untyped memory (nullptr is 0)
int& r=x;                   // r is a reference to (alias of) int x
enum weekend {SAT,SUN};     // weekend is a type with values SAT and SUN
enum weekend day;           // day is a variable of type weekend
enum weekend{SAT=0,SUN=1};  // Explicit representation as int
enum {SAT,SUN} day;         // Anonymous enum
enum class Color {Red,Blue};// Color is a strict type with values Red and Blue
Color x = Color::Red;       // Assign Color x to red
typedef String char*;       // String s; means char* s;
const int c=3;              // Constants must be initialized, cannot assign to
const int* p=a;             // Contents of p (elements of a) are constant
int* const p=a;             // p (but not contents) are constant
const int* const p=a;       // Both p and its contents are constant
const int& cr=x;            // cr cannot be assigned to change x
int8_t,uint8_t,int16_t,
uint16_t,int32_t,uint32_t,
int64_t,uint64_t            // Fixed length standard types
auto it = m.begin();        // Declares it to the result of m.begin()
auto const param = config["param"];
// Declares it to the const result
auto& s = singleton::instance();
// Declares it to a reference of the result


// ## STORAGE Classes

int x;                      // Auto (memory exists only while in scope)
static int x;               // Global lifetime even if local scope
extern int x;               // Information only, declared elsewhere


// ## Statements


x=y;                        // Every expression is a statement
int x;                      // Declarations are statements
;                           // Empty statement
{                           // A block is a single statement
    int x;                  // Scope of x is from declaration to end of block
}
if (x) a;                   // If x is true (not 0), evaluate a
else if (y) b;              // If not x and y (optional, may be repeated)
else c;                     // If not x and not y (optional)

while (x) a;                // Repeat 0 or more times while x is true

for (x; y; z) a;            // Equivalent to: x; while(y) {a; z;}

for (x : y) a;              // Range-based for loop e.g.
// for (auto& x in someList) x.y();

do a; while (x);            // Equivalent to: a; while(x) a;

switch (x) {                // x must be int
case X1: a;             // If x == X1 (must be a const), jump here
case X2: b;             // Else if x == X2, jump here
default: c;             // Else jump here (optional)
}
break;                      // Jump out of while, do, or for loop, or switch
continue;                   // Jump to bottom of while, do, or for loop
return x;                   // Return x from function to caller
try { a; }
catch (T t) { b; }          // If a throws a T, then jump here
catch (...) { c; }          // If a throws something else, jump here

// ## Functions

int f(int x, int y);        // f is a function taking 2 ints and returning int
void f();                   // f is a procedure taking no arguments
void f(int a=0);            // f() is equivalent to f(0)
f();                        // Default return type is int
inline f();                 // Optimize for speed
f() { statements; }         // Function definition (must be global)
T operator+(T x, T y);      // a+b (if type T) calls operator+(a, b)
T operator-(T x);           // -a calls function operator-(a)
T operator++(int);          // postfix ++ or -- (parameter ignored)
extern "C" {void f();}      // f() was compiled in C

// Function parameters and return values may be of any type. A function must either be declared or defined before
// it is used. It may be declared first and defined later. Every program consists of a set of a set of global variable
// declarations and a set of function definitions (possibly in separate files), one of which must be:


int main()  { statements... }     // or
int main(int argc, char* argv[]) { statements... }


// `argv` is an array of `argc` strings from the command line.
// By convention, `main` returns status `0` if successful, `1` or higher for errors.
//
// Functions with different parameters may have the same name (overloading). Operators except `::` `.` `.*` `?:` may be overloaded.
// Precedence order is not affected. New operators may not be created.

// ## Expressions

// Operators are grouped by precedence, highest first. Unary operators and assignment evaluate right to left. All
// others are left to right. Precedence does not affect order of evaluation, which is undefined. There are no run time
// checks for arrays out of bounds, invalid pointers, etc.

T::X                        // Name X defined in class T
N::X                        // Name X defined in namespace N
::X                         // Global name X
t.x                         // Member x of struct or class t
p-> x                       // Member x of struct or class pointed to by p
a[i]                        // i'th element of array a
f(x,y)                      // Call to function f with arguments x and y
T(x,y)                      // Object of class T initialized with x and y
x++                         // Add 1 to x, evaluates to original x (postfix)
x--                         // Subtract 1 from x, evaluates to original x
typeid(x)                   // Type of x
typeid(T)                   // Equals typeid(x) if x is a T
dynamic_cast< T>(x)         // Converts x to a T, checked at run time.
static_cast< T>(x)          // Converts x to a T, not checked
reinterpret_cast< T>(x)     // Interpret bits of x as a T
const_cast< T>(x)           // Converts x to same type T but not const

sizeof x                    // Number of bytes used to represent object x
sizeof(T)                   // Number of bytes to represent type T
++x                         // Add 1 to x, evaluates to new value (prefix)
--x                         // Subtract 1 from x, evaluates to new value
~x                          // Bitwise complement of x
!x                          // true if x is 0, else false (1 or 0 in C)
-x                          // Unary minus
+x                          // Unary plus (default)
&x                          // Address of x
*p                          // Contents of address p (*&x equals x)
new T                       // Address of newly allocated T object
new T(x, y)                 // Address of a T initialized with x, y
new T[x]                    // Address of allocated n-element array of T
delete p                    // Destroy and free object at address p
delete[] p                  // Destroy and free array of objects at p
(T) x                       // Convert x to T (obsolete, use .._cast<T>(x))

x * y                       // Multiply
x / y                       // Divide (integers round toward 0)
x % y                       // Modulo (result has sign of x)

x + y                       // Add, or \&x[y]
x - y                       // Subtract, or number of elements from *x to *y
x << y                      // x shifted y bits to left (x * pow(2, y))
x >> y                      // x shifted y bits to right (x / pow(2, y))

x < y                       // Less than
x <= y                      // Less than or equal to
x > y                       // Greater than
x >= y                      // Greater than or equal to

x & y                       // Bitwise and (3 & 6 is 2)
x ^ y                       // Bitwise exclusive or (3 ^ 6 is 5)
x | y                       // Bitwise or (3 | 6 is 7)
x && y                      // x and then y (evaluates y only if x (not 0))
x || y                      // x or else y (evaluates y only if x is false (0))
x = y                       // Assign y to x, returns new value of x
x += y                      // x = x + y, also -= *= /= <<= >>= &= |= ^=
x ? y : z                   // y if x is true (nonzero), else z
throw x                     // Throw exception, aborts if not caught
x , y                       // evaluates x and y, returns y (seldom used)

// ## Classes

class T {                   // A new type
private:                    // Section accessible only to T's member functions
protected:                  // Also accessible to classes derived from T
public:                     // Accessible to all
    int x;                  // Member data
    void f();               // Member function
    void g() {return;}      // Inline member function
    void h() const;         // Does not modify any data members
    int operator+(int y);   // t+y means t.operator+(y)
    int operator-();        // -t means t.operator-()
    T(): x(1) {}            // Constructor with initialization list
    T(const T& t): x(t.x) {}// Copy constructor
    T& operator=(const T& t)
    {x=t.x; return *this; } // Assignment operator
    ~T();                   // Destructor (automatic cleanup routine)
    explicit T(int a);      // Allow t=T(3) but not t=3
    T(float x): T((int)x) {}// Delegate constructor to T(int)
    operator int() const
    {return x;}             // Allows int(t)
    friend void i();        // Global function i() has private access
    friend class U;         // Members of class U have private access
    static int y;           // Data shared by all T objects
    static void l();        // Shared code.  May access y but not x
    class Z {};             // Nested class T::Z
    typedef int V;          // T::V means int
};
void T::f() {               // Code for member function f of class T
    this->x = x;}           // this is address of self (means x=x;)
int T::y = 2;               // Initialization of static member (required)
T::l();                     // Call to static member
T t;                        // Create object t implicit call constructor
t.f();                      // Call method f on object t

struct T {                  // Equivalent to: class T { public:
    virtual void i();         // May be overridden at run time by derived class
    virtual void g()=0; };    // Must be overridden (pure virtual)
class U: public T {         // Derived class U inherits all members of base T
public:
    void g(int) override; };  // Override method g
class V: private T {};      // Inherited members of T become private
class W: public T, public U {};
// Multiple inheritance
class X: public virtual T {};
// Classes derived from X have base T directly

// All classes have a default copy constructor, assignment operator, and destructor, which perform the
// corresponding operations on each data member and each base class as shown above. There is also a default no-argument
// constructor (required to create arrays) if the class has no constructors. Constructors, assignment, and
// destructors do not inherit.

// ## Templates

template <class T> T f(T t);// Overload f for all types
template <class T> class X {// Class with type parameter T
    X(T t); };                // A constructor
template <class T> X<T>::X(T t) {}
// Definition of constructor
X<int> x(3);                // An object of type "X of int"
template <class T, class U=T, int n=0>
// Template with default parameters

// ## Namespaces

namespace N {class T {};}   // Hide name T
N::T t;                     // Use name T in namespace N
using namespace N;          // Make T visible without N::

// ## `memory` (dynamic memory management)

#include <memory>           // Include memory (std namespace)
shared_ptr<int> x;          // Empty shared_ptr to a integer on heap. Uses reference counting for cleaning up objects.
x = make_shared<int>(12);   // Allocate value 12 on heap
shared_ptr<int> y = x;      // Copy shared_ptr, implicit changes reference count to 2.
cout << *y;                 // Dereference y to print '12'
if (y.get() == x.get()) {   // Raw pointers (here x == y)
  cout << "Same";
}
y.reset();                  // Eliminate one owner of object
if (y.get() != x.get()) {
  cout << "Different";
}
if (y == nullptr) {         // Can compare against nullptr (here returns true)
  cout << "Empty";
}
y = make_shared<int>(15);   // Assign new value
cout << *y;                 // Dereference x to print '15'
cout << *x;                 // Dereference x to print '12'
weak_ptr<int> w;            // Create empty weak pointer
w = y;                      // w has weak reference to y.
if (shared_ptr<int> s = w.lock()) { // Has to be copied into a shared_ptr before usage
  cout << *s;
}
unique_ptr<int> z;          // Create empty unique pointers
unique_ptr<int> q;
z = make_unique<int>(16);   // Allocate int (16) on heap. Only one reference allowed.
q = move(z);                // Move reference from z to q.
if (z == nullptr){
  cout << "Z null";
}
cout << *q;
shared_ptr<B> r;
r = dynamic_pointer_cast<B>(t); // Converts t to a shared_ptr<B>


// ## `math.h`, `cmath` (floating point math)

#include <cmath>            // Include cmath (std namespace)
sin(x); cos(x); tan(x);     // Trig functions, x (double) is in radians
asin(x); acos(x); atan(x);  // Inverses
atan2(y, x);                // atan(y/x)
sinh(x); cosh(x); tanh(x);  // Hyperbolic sin, cos, tan functions
exp(x); log(x); log10(x);   // e to the x, log base e, log base 10
pow(x, y); sqrt(x);         // x to the y, square root
ceil(x); floor(x);          // Round up or down (as a double)
fabs(x); fmod(x, y);        // Absolute value, x mod y

// ## `assert.h`, `cassert` (Debugging Aid)

#include <cassert>        // Include iostream (std namespace)
        assert(e);                // If e is false, print message and abort
#define NDEBUG            // (before #include <assert.h>), turn off assert

// ## `iostream.h`, `iostream` (Replaces `stdio.h`)

#include <iostream>         // Include iostream (std namespace)
cin >> x >> y;              // Read words x and y (any type) from stdin
cout << "x=" << 3 << endl;  // Write line to stdout
cerr << x << y << flush;    // Write to stderr and flush
c = cin.get();              // c = getchar();
cin.get(c);                 // Read char
cin.getline(s, n, '\n');    // Read line into char s[n] to '\n' (default)
if (cin)                    // Good state (not EOF)?
// To read/write any type T:
istream& operator>>(istream& i, T& x) {i >> ...; x=...; return i;}
ostream& operator<<(ostream& o, const T& x) {return o << ...;}

// ## `fstream.h`, `fstream` (File I/O works like `cin`, `cout` as above)

#include <fstream>          // Include filestream (std namespace)
ifstream f1("filename");    // Open text file for reading
if (f1)                     // Test if open and input available
f1 >> x;                    // Read object from file
f1.get(s);                  // Read char or line
f1.getline(s, n);           // Read line into string s[n]
ofstream f2("filename");    // Open file for writing
if (f2) f2 << x;            // Write to file

// ## `string` (Variable sized character array)

#include <string>         // Include string (std namespace)
string s1, s2="hello";    // Create strings
s1.size(), s2.size();     // Number of characters: 0, 5
s1 += s2 + ' ' + "world"; // Concatenation
s1 == "hello world"       // Comparison, also <, >, !=, etc.
s1[0];                    // 'h'
s1.substr(m, n);          // Substring of size n starting at s1[m]
s1.c_str();               // Convert to const char*
s1 = to_string(12.05);    // Converts number to string
getline(cin, s);          // Read line ending in '\n'

// ## `vector` (Variable sized array/stack with built in memory allocation)

#include <vector>         // Include vector (std namespace)
vector<int> a(10);        // a[0]..a[9] are int (default size is 0)
vector<int> b{1,2,3};        // Create vector with values 1,2,3
a.size();                 // Number of elements (10)
a.push_back(3);           // Increase size to 11, a[10]=3
a.back()=4;               // a[10]=4;
a.pop_back();             // Decrease size by 1
a.front();                // a[0];
a[20]=1;                  // Crash: not bounds checked
a.at(20)=1;               // Like a[20] but throws out_of_range()
for (int& p : a)
p=0;                    // C++11: Set all elements of a to 0
for (vector<int>::iterator p=a.begin(); p!=a.end(); ++p)
*p=0;                   // C++03: Set all elements of a to 0
vector<int> b(a.begin(), a.end());  // b is copy of a
vector<T> c(n, x);        // c[0]..c[n-1] init to x
T d[10]; vector<T> e(d, d+10);      // e is initialized from d

// ## `deque` (Array stack queue)

// `deque<T>` is like `vector<T>`, but also supports:

#include <deque>          // Include deque (std namespace)
a.push_front(x);          // Puts x at a[0], shifts elements toward back
a.pop_front();            // Removes a[0], shifts toward front

// ## `utility` (pair)

#include <utility>        // Include utility (std namespace)
        pair<string, int> a("hello", 3);  // A 2-element struct
a.first;                  // "hello"
a.second;                 // 3

// ## `map` (associative array - usually implemented as binary search trees - avg. time complexity: O(log n))

#include <map>            // Include map (std namespace)
map<string, int> a;       // Map from string to int
a["hello"] = 3;           // Add or replace element a["hello"]
for (auto& p:a)
    cout << p.first << p.second;  // Prints hello, 3
a.size();                 // 1

// ## `unordered_map` (associative array - usually implemented as hash table - avg. time complexity: O(1))

#include <unordered_map>  // Include map (std namespace)
unordered_map<string, int> a; // Map from string to int
a["hello"] = 3;           // Add or replace element a["hello"]
for (auto& p:a)
cout << p.first << p.second;  // Prints hello, 3
a.size();                 // 1

// ## `set` (store unique elements - usually implemented as binary search trees - avg. time complexity: O(log n))

#include <set>            // Include set (std namespace)
set<int> s;               // Set of integers
s.insert(123);            // Add element to set
if (s.find(123) != s.end()) // Search for an element
s.erase(123);
cout << s.size();         // Number of elements in set

// ## `unordered_set` (store unique elements - usually implemented as a hash set - avg. time complexity: O(1))

#include <unordered_set>  // Include set (std namespace)
unordered_set<int> s;     // Set of integers
s.insert(123);            // Add element to set
if (s.find(123) != s.end()) // Search for an element
s.erase(123);
cout << s.size();         // Number of elements in set

// ## `algorithm` (A collection of 60 algorithms on sequences with iterators)

#include <algorithm>      // Include algorithm (std namespace)
min(x, y); max(x, y);     // Smaller/larger of x, y (any type defining <)
swap(x, y);               // Exchange values of variables x and y
sort(a, a+n);             // Sort array a[0]..a[n-1] by <
sort(a.begin(), a.end()); // Sort vector or deque
reverse(a.begin(), a.end()); // Reverse vector or deque

// ## `chrono` (Time related library)

#include <chrono>         // Include chrono
using namespace std::chrono; // Use namespace
auto from =               // Get current time_point
        high_resolution_clock::now();
// ... do some work       
auto to =                 // Get current time_point
        high_resolution_clock::now();
using ms =                // Define ms as floating point duration
duration<float, milliseconds::period>;
// Compute duration in milliseconds
cout << duration_cast<ms>(to - from)
.count() << "ms";

// ## `thread` (Multi-threading library)

#include <thread>         // Include thread
unsigned c =
        hardware_concurrency(); // Hardware threads (or 0 for unknown)
auto lambdaFn = [](){     // Lambda function used for thread body
    cout << "Hello multithreading";
};
thread t(lambdaFn);       // Create and run thread with lambda
t.join();                 // Wait for t finishes

// --- shared resource example ---
mutex mut;                         // Mutex for synchronization
condition_variable cond;           // Shared condition variable
const char* sharedMes              // Shared resource
        = nullptr;
auto pingPongFn =                  // thread body (lambda). Print someone else's message
        [&](const char* mes){
            while (true){
                unique_lock<mutex> lock(mut);// locks the mutex
                do {
                    cond.wait(lock, [&](){     // wait for condition to be true (unlocks while waiting which allows other threads to modify)
                        return sharedMes != mes; // statement for when to continue
                    });
                } while (sharedMes == mes);  // prevents spurious wakeup
                cout << sharedMes << endl;
                sharedMes = mes;
                lock.unlock();               // no need to have lock on notify
                cond.notify_all();           // notify all condition has changed
            }
        };
sharedMes = "ping";
thread t1(pingPongFn, sharedMes);  // start example with 3 concurrent threads
thread t2(pingPongFn, "pong");
thread t3(pingPongFn, "boing");

// ## `future` (thread support library)

#include <future>         // Include future
        function<int(int)> fib =  // Create lambda function
[&](int i){
    if (i <= 1){
        return 1;
    }
    return fib(i-1)
           + fib(i-2);
};
future<int> fut =         // result of async function
        async(launch::async, fib, 4); // start async function in other thread
// do some other work 
cout << fut.get();        // get result of async function. Wait if needed.

int numRings = 20;

int numRings(20);

int numRings{20}

int numRings{}

#include <cstdint> // for fixed width integers

/* 
 * 8 bit singed integer. Many systems consider them as chars. So it is better
 * to not use them if using integers is the purpose
 */
int8_t var;

uint8_t var;  // 8 bit unsigned integer

intN_t var; // N = 16, 32, 64 bits signed integer
uintN_t var;  // N = 16, 32, 64 bits unsigned integer

int_fast32_t var;

int_least64_t var;

#include <iostream>
#include <iomanip> // for std::setprecision()

int main(){
  double d{12.34567890};

  std::cout << "Without precision: " << d << std::endl;
  std::cout << std::setprecision(4);
  std::cout << "With precision: " << d << std::endl;

  return 0;
}

#include <iostream>

int main(){
  float zero(0.0);
  float posinf = 5.0 / zero;
  float neginf = -5.0 / zero;
  float nan = zero / zero;

  std::cout << posinf << std::endl;
  std::cout << neginf << std::endl;
  std::cout << nan << std::endl;

  return 0;
}

#include <iostream>

int main(){
  bool universeCameFromNothing(true);

  std::cout << "Universe came from nothing: " << universeCameFromNothing
    << std::endl;

  std::cout << std::boolalpha;
  
  std::cout << "Universe came from nothing: " << universeCameFromNothing
    << std::endl;

  return 0;
}

#include <iostream>

int main(){
  char ch(65);

  std::cout << ch << std::endl;
  std::cout << static_cast<int>(ch) << std::endl;

  return 0;
}

#include <typeinfo>

int main(){
  int numerator(50);
  double denominator(5.0);

  std::cout << typeid(numerator).name() << std::endl;
  std::cout << typeid(numerator / denominator).name() << std::endl;
}

int integer(50);  // integer
float f(0.05f);   // used f suffix as default literal is double type
double d(0.31416);  // double floating literal
int hex(0xa0);    // hexadecimal literal
int oct(012);   // Octal literal
int bin(0b1010);  // Binary literal

int longNumber(1'23'570) // c++14 only

const double avg(6.023e23);
const double massEarth;   // This is not allowed

int x(50);
const int y(x)      // This is allowed

constexpr double adg(9.8);  // Compile time constant. Value of the constant
        // must be resolved in compile time otherwise
        // will generate an error. This is c++11 feature

int number(5);

if(number == 5){
  int number;   // local variable

  number = 10;  // will effect only local variable
      // this is shadowing

  std::cout << number << std::endl; // will print local
}

std::cout << number << std::endl; // will print outer block number

int x(50);  // global variable

int main(){
  int x(40);

  std::cout << x << std::endl;  // will print local x
  std::cout << ::x << std::endl;  // will print global x
}

#include <iostream>

int main(){
  int selection;

  std::cin >> selection;
  std::cout << "You have selected: " << selection << std::endl;

  return 0;
}

#include <iostream>
#include <string>

int main(){
  std::string name;

  std::cout << "Enter Name: ";
  std::getline(std::cin, name);
  std::cout << "Your name is: " << name;

  return 0;
}

#include <iostream>
#include <string>

int main(){
  std::string name;
  int select;

  std::cout << "Select: ";
  std::cin >> select;

  std::cout << "Enter name: ";
  std::getline(std::cin, name);   // will not work
 
  std::cout << "Your name is: " << name << "! You have selected: "
      << select;

  return 0;
}

#include <iostream>
#include <string>

int main(){
  int select;
  std::string name;
  
  std::cout << "Select: ";
  std::cin >> select;

  std::cin.ignore(32767, '\n');

  std::cout << "Enter name: ";
  std::getline(std::cin, name);

  std::cout << "Hi " << name << "! You have selected " << select << std::endl;

  return 0;
}

#include <iostream>
#include <ctime>
#include <cstdlib>

int main(){
  /* For generating different seed each time the program runs */
  srand(static_cast<unsigned int>(time(0)));
  std::cout << rand();

  return 0;
}

#include <iostream>
#include <ctime>
#include <cstdlib>

int getRandom(int min, int max){
  return min + (rand() % (max - min + 1));
}

int main(){
  /* For generating different seed each time the program runs */
  srand(static_cast<unsigned int>(time(0)));
  std::cout << getRandom(1, 6);

  return 0;
}

#include <iostream>
#include <ctime>
#include <cstdlib>

int getRandom(int min, int max){
  static const double fraction = 1.0 / RAND_MAX;

  return min + ((max - min + 1) * (rand() * fraction));
}

int main(){
  /* For generating different seed each time the program runs */
  srand(static_cast<unsigned int>(time(0)));
  std::cout << getRandom(1, 6);

  return 0;
}

#include <iostream>

int main(){
  int array[5]; // ok

  #define ARR_SIZE 5
  int array[ARR_SIZE];  // ok

  int const arr_size = 5;
  int array[arr_size];  // ok

  int arr_size = 5;
}

#include <iostream>

int main(){
  int arr[2] = {1, 2};

  /* Following two address will be same*/
  std::cout << arr << std::endl;
  std::cout << &arr[0] << std::endl;

  return 0; 
}

#include <iostream>

int main(){
  int arr[5] = {1, 2, 3, 4, 5};
  int *arrPtr = arr;  // arr is converted from int (*)[2] to int *

  /* Will print the size of the array which is 5 * 8 bytes */
  std::cout << sizeof(arr) << std::endl;

  /* Will print the size of the pointer which is 8 bytes */
  std::cout << sizeof(arrPtr) << std::endl;

  return 0; 
}

#include <iostream>

int main(){
  /*
   * keep the string constant in memory with r/w access
   * and return the pointer to it.
   * So string constant can be changed any time later
   */
  char arr[] = "hello, world";

  /*
   * Keep the string constant in read-only section of memory
   * so it can't be changed
   */
  char *text = "GNU is not Unix";

  /* As it is a constant so its better to initialize following way */
  const char *text = "GNU is not Unix";

  arr[0] = 'g';     // This OK

  /* 
   * In this case as string constant is kept in read-only
   * memory, doing this will generate segmentation
   * fault
   */
  *(text + 2) = 'O'; 

  std::cout << arr << std::endl;
  std::cout << text << std::endl;

  return 0; 
}

#include <iostream>

int main(){
  int *ptr = nullptr;

  if(ptr){
    std::cout << "Not null" << std::endl;
  }
  else{
    std::cout << "Null" << std::endl;
  }
    
  return 0; 
}

#include <iostream>

int main(){
  int x(5);
  void *ptr = &x; // pointing to an integer

  std::cout << *static_cast<int*>(ptr) << std::endl;

  char ch = 'P';  // pointing to a char
  ptr = &ch;
  
  std::cout << static_cast<char*>(ptr) << std::endl;

  return 0;
}

#include <iostream>

int main(){
  int x = 17;
  unsigned int addressX = reinterpret_cast<int>(&x);

  std::cout << addressX << std::endl;

  return 0;
}

#include <iostream>

int main(){
  int *ptr = new int; // dynamically an integer is allocated.

  *ptr = 5;

  return 0;
}

#include <iostream>

int main(){
  int *ptr = new int(5); // memory is allocated to the pointer

  /* memory is deallocated.
   * memory is realesed by os.
   */

  delete ptr; 

  /* still the pointer is holding the memory address
   * so its better to make it null
   */
  ptr = 0;
  ptr = nullptr;  // c++11

  return 0;
}

#include <iostream>

void doSomthing(){

  /* Memory is allocated but not deallocated
   * so memory leak happens when the variable
   * goes out of scope as there is no way
   * to deallocate in that case
   */

  int *ptr = new int;
}

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

#include <iostream>

int main(){
  int *ptr = int new;

  int val;

  // assigning to a address with out deallocating
  ptr = &val; // memory leak

  return 0;
}

#include <iostream>

int main(){
  int *ptr = new int(5);

  // allocating new memory without deallocating previous one
  int *ptr = new int(10);

  return 0;
}

#include <iostream>

int main(){
  int x(10);
  int &y = x; // reference variable

  /*
   * will output:
   * 10
   * 10
   */
  std::cout << x << std::endl
  std::cout << y << std::endl

  return 0;
}

#include <iostream>

int main(){
  int fibseq[] = {1, 1, 2, 3, 5, 8, 13, 21};

  std::cout << "Fibonacci Sequence: ";
  for(const auto &elem: fibseq){
    std::cout << elem << " ";
  }
  std::cout << std::endl;

  return 0;
}

#include <iostream>

int foo(int x){
  return x*x;
}

int main(){
  int (*square)(int) = foo;

  std::cout << square(10) << std::endl;

  return 0;
}

#include <iostream>
#include <cstdarg>  // to use ellipsis

void printNum(int count, ...){
  va_list list;
  va_start(list, count);

  for(int arg = 0; arg < count; arg++){
    std::cout << va_arg(list, int) << std::endl;
  }

  va_end(list);
}

int main(){
  printNum(5, 1, 2, 3, 4, 5);

  return 0;
}

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

int main(int argc, char *argv[]) {
    std::vector<bool> bitvect{1, 0, 0, 1};

    /* lambda function example: used to make ~bitvect */
    std::transform(bitvect.begin(), bitvect.end(), bitvect.begin(),
            [](bool b){ return b == 1 ? 0 : 1; });
    
    return 0;
}

#include <iostream>

class Point{

  private:
    double m_x;
    double m_y;

  public:
    double getX(){
      return m_x;
    }

    void setX(double x){
      m_x = x;
    }

    double getY(){
      return m_y;
    }

    void setY(double y){
      m_y = y;
    }
};

int main(){
  Point p;
  
  p.setX(-2.5);
  p.setY(2.5);

  std::cout << "(" << p.getX() << ", " << p.getY() << ")" << std::endl;

  return 0;
}

#include <iostream>

class Point{

  private:
    double m_x;
    double m_y;

  public:
    Point(double x = 0, double y = 0): m_x(x), m_y(y){
        // empty
    }

    double getX(){
      return m_x;
    }

    void setX(double x){
      m_x = x;
    }

    double getY(){
      return m_y;
    }

    void setY(double y){
      m_y = y;
    }

    void printPoint(){
      std::cout << "(" << m_x << ", " << m_y << ")" << std::endl;
    }
};

int main(){
  Point p(0.5, 0.5);
  
  p.printPoint();

  return 0;
}

#include <iostream>

class Point{

  private:
    double m_x = 0; // default value of x
    double m_y = 0; // default value of y

  public:
    // member variable will be initialized with default value
    // if called
    Point(){
      //empty
    }

    double getX(){
      return m_x;
    }

    void setX(double x){
      m_x = x;
    }

    double getY(){
      return m_y;
    }

    void setY(double y){
      m_y = y;
    }

    void printPoint(){
      std::cout << "(" << m_x << ", " << m_y << ")" << std::endl;
    }
};

int main(){
  Point p;  // will call default constructor
  
  p.printPoint();

  return 0;
}

#include <iostream>
#include <cassert>

class Point{

  private:
    double m_x;
    double m_y;

  public:
    Point(double x = 0, double y = 0): m_x(x), m_y(y){
      //empty
    }

    double getX(){
      return m_x;
    }

    void setX(double x){
      m_x = x;
    }

    double getY(){
      return m_y;
    }

    void setY(double y){
      m_y = y;
    }

    void printPoint(){
      std::cout << "(" << m_x << ", " << m_y << ")" << std::endl;
    }
};

class PointArray{

  private:
    Point *m_points;
    int m_length;

  public:
    PointArray(int length){
      m_points = new Point[length];
      m_length = length;
    }

    // Destructor
    ~PointArray(){
      delete[] m_points;
    }

    void insert(Point &p, int index){
      assert(index >= 0 && index < m_length);

      m_points[index] = p;
    }

    Point& get(int index){
      assert(index >= 0 && index < m_length);

      return m_points[index];
    }
};

int main(){
  PointArray parr(5);
  
  Point p(2, 3);
  Point q;

  parr.insert(p, 0);
  
  q = parr.get(0);
  q.printPoint();

  return 0;
}

#include <iostream>

class Static{
  public:
    static int id;
};

/* Have to initialize first otherwise linker error will generate */
int Static::id = 1;

int main(){
  Static s;
  Static t;

  /* Shared by both object */
  s.id = 5;
  std::cout << s.id << "\t" << t.id << std::endl;

  /* Bound to whole class */
  Static::id = 10;
  std::cout << s.id << "\t" << t.id << std::endl;

  return 0;
}

#include <iostream>

class ID{
  private:
    static int m_id;

  public:
    static int getID(){
      return m_id;
    }
};

/* Have to initialize first otherwise linker error will generate */
int ID::m_id = 1;

int main(){
  std::cout << ID::getID << std::endl;

  return 0;
}

#include <iostream>

class Point{
public:
    using point_t = int; // Member type

    Point(point_t x, point_t y): m_x(x), m_y(y){}

    void print(void){
        std::cout << "(" << m_x << ", " << m_y << ")";
    }

private:
    point_t m_x;
    point_t m_y;
};

int main(int argc, char *argv[]){
    Point p(10, 20);
    p.print();
    return 0;
}

#include <iostream>

class Point{
public:
    using point_t = int;

    Point(point_t x, point_t y): m_x(x), m_y(y){}

    Point& add(point_t x, point_t y){
        this->m_x += x; 
        this->m_y += y;
        return *this;
    }

    Point& mul(point_t x, point_t y){
        this->m_x *= x; 
        this->m_y *= y;
        return *this;
    }

    void print(void){
        std::cout << "(" << m_x << ", " << m_y << ")";
    }

private:
    point_t m_x;
    point_t m_y;
};

int main(int argc, char *argv[]){
    Point p(10, 20);
    p.add(3, 5).mul(7, 8).add(2, 3);
    p.print();
    return 0;
}

#include <iostream>
 
class Humidity;
 
class Temperature
{
private:
    int m_temp;
public:
    Temperature(int temp=0) { m_temp = temp; }
 
    friend void printWeather(const Temperature &temperature, const Humidity &humidity);
};
 
class Humidity
{
private:
    int m_humidity;
public:
    Humidity(int humidity=0) { m_humidity = humidity; }
 
    friend void printWeather(const Temperature &temperature, const Humidity &humidity);
};
 
void printWeather(const Temperature &temperature, const Humidity &humidity)
{
    std::cout << "The temperature is " << temperature.m_temp <<
       " and the humidity is " << humidity.m_humidity << '\n';
}
 
int main()
{
    Humidity hum(10);
    Temperature temp(12);
 
    printWeather(temp, hum);
 
    return 0;
}

#include <iostream>
 
class Storage
{
private:
    int m_nValue;
    double m_dValue;
public:
    Storage(int nValue, double dValue)
    {
        m_nValue = nValue;
        m_dValue = dValue;
    }
 
    // Make the Display class a friend of Storage
    friend class Display;
};
 
class Display
{
private:
    bool m_displayIntFirst;
 
public:
    Display(bool displayIntFirst) { m_displayIntFirst = displayIntFirst; }
 
    void displayItem(const Storage &storage)
    {
        if (m_displayIntFirst)
            std::cout << storage.m_nValue << " " << storage.m_dValue << '\n';
        else // display double first
            std::cout << storage.m_dValue << " " << storage.m_nValue << '\n';
    }
};
 
int main()
{
    Storage storage(5, 6.7);
    Display display(false);
 
    display.displayItem(storage);
 
    return 0;
}

#include <iostream>

class Point{
private:
    using point_t = int;
    point_t m_x;
    point_t m_y;

public:
    Point(): m_x(0), m_y(0){}
    Point(point_t x, point_t y): m_x(x), m_y(y){}

    // constant memeber function
    void print(void) const {
        std::cout << "(" << m_x << ", " << m_y << ")" << "\n";
    }

    // This is not a member function only a friend function
    // This could defined outside of the function too
    friend Point operator+(cost Point &p, const int n){
        return Point(p.m_x + n, p.m_y + n); 
    }

    friend Point operator+(const int n, const Point &p){
        return p + n;
    }

    friend Point operator+(const Point &p1, const Point &p2){
        return Point(p1.m_x + p2.m_x, p1.m_y + p2.m_y);
    }
};

int main(int argc, char *argv[]){
    Point p1(10, 20);
    Point p2(4, 5);
    Point p3 = p1 + p2 + 5;

    p3.print();

    return 0;
}

#include <iostream>

class Point{
private:
    using point_t = int;
    point_t m_x;
    point_t m_y;

public:
    Point(): m_x(0), m_y(0){}
    Point(point_t x, point_t y): m_x(x), m_y(y){}

    point_t getX(void) const {
        return m_x; 
    }
    
    point_t getY(void) const {
        return m_y; 
    }

    // constant memeber function
    void print(void) const {
        std::cout << "(" << m_x << ", " << m_y << ")" << "\n";
    }
};

Point operator+(const Point &p, const int n){
    return Point(p.getX() + n, p.getY() + n); 
}

Point operator+(int n, const Point &p){
    return p + n;
}

Point operator+(const Point &p1, const Point &p2){
    return Point(p1.getX() + p2.getX(), p1.getY() + p2.getY());
}

int main(int argc, char *argv[]){
    Point p1(10, 20);
    Point p2(4, 5);
    Point p3 = p1 + p2 + 5;

    p3.print();

    return 0;
}