From 1dab859d28aa586cfd059737a870aacd4aa904a3 Mon Sep 17 00:00:00 2001 From: Lilian Besson Date: Wed, 25 Apr 2018 16:56:44 +0200 Subject: [PATCH] Typo corrected --- README.md | 675 +++++++++++++++++++++++++++--------------------------- 1 file changed, 343 insertions(+), 332 deletions(-) diff --git a/README.md b/README.md index db901e7..430b911 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,7 @@ Fork me on GitHub -# C++ QUICK REFERENCE / C++ CHEATSHEET -Based on Phillip M. Duxbury's C++ Cheatsheet and edited by Morten Nobel-Jørgensen. +# C++ QUICK REFERENCE / C++ CHEATSHEET +Based on Phillip M. Duxbury's C++ Cheatsheet and edited by Morten Nobel-Jørgensen. The cheatsheet focus is on C++ - not on the library. C++11 additions is inspired by ISOCPP.org C++11 Cheatsheet). @@ -9,415 +9,426 @@ The goal is to give a concise overview of basic, modern C++. The document is hosted on https://github.com/mortennobel/cpp-cheatsheet. Any comments and feedback are appreciated. -## PREPROCESSOR +## Preprocessor -~~~~ - // 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 +```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) // Condional compilation (#ifdef X) -#else // Optional (#ifndef X or #if !defined(X)) -#endif // Required after #if, #ifdef -~~~~ + 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 +## 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 -~~~~ +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 +## 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 +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 +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 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 -~~~~ +## STORAGE Classes -## 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 +```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) +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 +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; 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; +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 -~~~~ +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); // 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 -~~~~ +## Functions -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 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 +``` -~~~~ -int main() { statements... } or -int main(int argc, char* argv[]) { statements... } -~~~~ +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: -argv is an array of argc strings from the command line. By convention, main returns status 0 if successful, 1 or -higher for errors. +```cpp +int main() { statements... } // or +int main(int argc, char* argv[]) { statements... } +``` -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. +`argv` is an array of `argc` strings from the command line. +By convention, `main` returns status `0` if successful, `1` or higher for errors. -## 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. +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. -~~~~ -T::X // Name X defined in class T -N::X // Name X defined in namespace N -::X // Global name X +## Expressions -t.x // Member x of struct or class t +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 +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)) +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 // 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 // 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 // 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) -~~~~ +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 +## Classes + +```cpp +class T { // A new type private: // Section accessible only to T's member functions -protected: // Also accessable to classes derived from T -public: // Accessable 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 +protected: // Also accessuble to classes derived from T +public: // Accessuble 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) + {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 contructor 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 + 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) +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 + +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 {}; + 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 -~~~~ +class X: public virtual T {}; + // Classes derived from X have base T directly +```cpp -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. +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 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 -~~~~ +## Templates -## NAMESPACES -~~~~ +```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:: -~~~~ - -## MATH.H, CMATH (Floating point math) -~~~~ +N::T t; // Use name T in namespace N +using namespace N; // Make T visible without N:: +``` + +## `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 +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 -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) -~~~~ +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) -~~~~ +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 << ...;} -~~~~ +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) - -~~~~ +## `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 -~~~~ +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) -~~~~ +## `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* +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' -~~~~ +getline(cin, s); // Read line ending in '\n' +``` -## VECTOR (Variable sized array/stack with built in memory allocation) +## `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 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.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) +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 +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) +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 is like vector<T>, but also supports: -~~~~ +## `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) -~~~~ +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 red-black trees) -~~~~ -#include // Include map (std namespace) -map 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 -~~~~ +pair a("hello", 3); // A 2-element struct +a.first; // "hello" +a.second; // 3 +``` -## ALGORITHM (A collection of 60 algorithms on sequences with iterators) -~~~~ -#include // 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 -~~~~ +## `map` (associative array - usually implemented as red-black Trees) +```cpp +#include // Include map (std namespace) +map 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 +``` - +## `algorithm` (A collection of 60 algorithms on sequences with Iterators) - - - - +```cpp +#include // 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 +```