# C++ QUICK REFERENCE / C++ CHEATSHEET Based on Phillip M. Duxbury's C++ Cheatsheet 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 ISOCPP.org C++11 Cheatsheet). 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 ```cpp // Comment to end of line /* Multi-line comment */ #include // 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 ```cpp 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 ```cpp 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 ```cpp 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 ```cpp 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 ```cpp 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: ```cpp 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. ```cpp 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(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 ```cpp 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 ```cpp template T f(T t);// Overload f for all types template class X {// Class with type parameter T X(T t); }; // A constructor template X::X(T t) {} // Definition of constructor X x(3); // An object of type "X of int" template // Template with default parameters ``` ## Namespaces ```cpp 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) ```cpp #include // Include memory (std namespace) shared_ptr x; // Empty shared_ptr to a integer on heap. Uses reference counting for cleaning up objects. x = make_shared(12); // Allocate value 12 on heap shared_ptr y = x; // Copy shared_ptr, implicit changes reference count to 2. cout << *y; // Deference 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(15); // Assign new value cout << *y; // Deference x to print '15' cout << *x; // Deference x to print '12' weak_ptr w; // Create empty weak pointer w = y; // w has weak reference to y. if (shared_ptr s = w.lock()) { // Has to be copied into a shared_ptr before usage cout << *s; } unique_ptr z; // Create empty unique pointers unique_ptr q; z = make_unique(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; ``` ## `math.h`, `cmath` (floating point math) ```cpp #include // 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) ```cpp #include // Include iostream (std namespace) assert(e); // If e is false, print message and abort #define NDEBUG // (before #include ), turn off assert ``` ## `iostream.h`, `iostream` (Replaces `stdio.h`) ```cpp #include // 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) ```cpp #include // 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) ```cpp #include // 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) ```cpp #include // Include vector (std namespace) vector a(10); // a[0]..a[9] are int (default size is 0) vector 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::iterator p=a.begin(); p!=a.end(); ++p) *p=0; // C++03: Set all elements of a to 0 vector b(a.begin(), a.end()); // b is copy of a vector c(n, x); // c[0]..c[n-1] init to x T d[10]; vector e(d, d+10); // e is initialized from d ``` ## `deque` (Array stack queue) `deque` is like `vector`, but also supports: ```cpp #include // 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) ```cpp #include // Include utility (std namespace) pair 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)) ```cpp #include