commit b976c1e23f1a12c5631ef6071b24ed2694e64ecc Author: Morten Nobel-Joergensen Date: Thu Aug 18 23:51:49 2016 +0200 Initial commit diff --git a/README.md b/README.md new file mode 100644 index 0000000..315d644 --- /dev/null +++ b/README.md @@ -0,0 +1,295 @@ + +# C++ QUICK REFERENCE / C++ CHEATSHEET +Based on Phillip M. Duxbury's C++ Cheatsheet and edited by Morten Nobel-Jørgensen. +The cheatsheet focus on C++ - not on the library. +C++11 additions is inspired by ISOCPP.org C++11 Cheatsheet). + +The goal is to give a concise overview of basic, modern C++. + +The document is hosted on XXX. Any comments and feedback are appreciated. + +## 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 +#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 +~~~~ + +## 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); // 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(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 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 + 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 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 +}; +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 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 +~~~~ +namespace N {class T {};} // Hide name T +N::T t; // Use name T in namespace N +using namespace N; // Make T visible without N:: +~~~~ + \ No newline at end of file