C++ for Dummies Cheat Sheet

objName                         // for a simple object
operator expression             // for unary operators
expr1 operator expr2            // for binary operators
expr1 ? expr2 : expr3           // for the ternary operator
funcName([argument list]);      // for function calls

[<signed | unsigned >]char
[<signed | unsigned >]wchar_t
[<signed | unsigned>] [<short | long | long long>] int
float
[long] double
bool

[<extern|static>][const] type var[=expression]; // variable
[<extern|static>][const] type array[size][={list}]; // array
[const] type object[(argument list)];           // object
[const] type object [= {argument list}];        // alternative
[const] type * [const] ptr[=pointer expression];// pointer
type& refName = object;                         // reference
type fnName([argument list]);                   // function

auto var = 1L;               // the type of var is long int

decltype(var1) var2;         // the type of var2 is the same as var1

// simple function
[<inline|constexpr>] type fnName(argument list) {...}
// member function defined outside of class
[inline] type Class::func(argument list) [const] {...}
// constructor/destructors may also be defined outside of class
Class::Class([argument list]) {...}
Class::~Class() {...}
// constructors/destructor may be deleted or defaulted
// in lieu of definition
Class::Class([argument list]) = <delete|default>;
Class::~Class() = <delete|default>;

MyClass& operator+(const MyClass& m1, const MyClass& m2);// simple
MyClass& MyClass::operator+(const MyClass& m2); // member;

<struct | class> ClassName [ : [virtual] [public] BaseClass]
{
     <public|protected>:
       // constructor
       ClassName([arg list]) <[: member(val),...] {...} |;>
       ClassName() [= <delete|default>;]
       // destructor
       [virtual] ~ClassName() <{...} | [=<delete|default>;>
       // public data members
       type dataMemberName [= initialValue];
       // public member functions
       type memberFunctionName([arg list]) [{...}]
       // const member function
       type memberFunctionName([arg list]) const [{...}]
       // virtual member functions
       virtual type memberFunctionName([arg list]) [{...}];
       // pure virtual member functions
       virtual type memberFunctionName([arg list]) = 0;
       // function that must override a base class function
       type memberFunctionName([arg list]) override;
       // a function that cannot be overriden in a subclass
       type memberFunctionName([arg list]) final;
};

enum STATE {DC,                 // gets 0
            ALABAMA,            // gets 1
            ALASKA,             // gets 2
            ARKANSAS,           // gets 3
            // ...and so on
            };
int n = ALASKA;                 // ALASKA is of type int

enum ALPHABET:char {A = 'a',    // gets 'a'
                    B,          // gets 'b'
                    C,          // gets 'c'
                                // ...and so on
            };
char c = A;                     // A is of type char

// the following enumeration defines a new type STATE
enum class STATE { DC,          // gets 0
                   ALABAMA,     // gets 1
                   ALASKA,      // gets 2
                   ARKANSAS,    // gets 3
                   // ...and so on
                 };
STATE s = STATE::ALASKA;  // now STATE is a new type
// the following uses a different underlying type
enum class ALPHABET:char {A = 'a',// gets 'a'
                          B,      // gets 'b'
                          C,      // gets 'c'
                                  // ...and so on
                 };
ALPHABET c = ALPHABET::A;         // A is of type ALPHABET

// type T is provided by the programmer at use
template <class T, {...}> type FunctionName([arg list])
template <class T, {...}> class ClassName { {...} };

if (booleanExpression)
{
    expressions1;
}
[else
{
    expressions2;
}]

while (booleanExpression)
{
    expressions;
}

do
{
    expressions;
} while(booleanExpression);

for (initCommand; boolExpression; loopExpression)
{
    expressions;
}

for (declaration: list)
{
    expressions;
}

switch(integerExpression)
{
  case val1:
            expressions1;
            break;
  case val2:
            expressions2;
            break;
  [default:
            expressionsN;
  ]
}

for(int i = 0; i < 20; i++)
{
    // if the number is not prime...
    if (!isPrime(i))
    {
        // ...skip over to the next value of i
        continue;
    }
    // proceed on processing 
}

while(true)
{
    // read a line from input object
    input >> line;
    // if a failure or end-of-file occurs...
    if (cin.eof() || cin.fail())
    {
       // ...then exit the loop
       break;
    }
    // process the line
}

while(true)
{
    // read a line from input object
    input >> line;
    // if a failure or end-of-file occurs...
    if (cin.eof() || cin.fail())
    {
       // ...then exit the loop
       goto exitLabel;
    }
    // process the line
}
exitLabel:
    // control continues here