Arrays being dangerous:


    #include <iostream>

    using namespace std;

    int main()
    { int a = 111, b = 222, c = 333, d = 444, e = 555;
      int f[16];
      int g = 666, h = 777, i = 888, j = 999;

      for (int i = -4; i < 25; i += 1)
        f[i] = 1000000 + i;

      cout << a << " " << b << " " << c << " " << d << " " << e << " "
           << g << " " << h << " " << i << " " << j << "\n"; }


Evaluating a reverse polish expression:


    - * 12 456 * / 18 4 921 =

    ___________________________
     12 456 * 18 4 / 921 * - =
    ^
    12
    ___________________________
     12 456 * 18 4 / 921 * - =
       ^
    12 456
    ___________________________
     12 456 * 18 4 / 921 * - =
           ^
    5472
    ___________________________
     12 456 * 18 4 / 921 * - =
             ^
    5472 18
    ___________________________
     12 456 * 18 4 / 921 * - =
                ^
    5472 18 4
    ___________________________
     12 456 * 18 4 / 921 * - =
                  ^
    5472 4.5
    ___________________________
     12 456 * 18 4 / 921 * - =
                    ^
    5472 4.5 921
    ___________________________
     12 456 * 18 4 / 921 * - =
                        ^
    5472 4144.5
    ___________________________
     12 456 * 18 4 / 921 * - =
                          ^
    1327.5
    ___________________________
     12 456 * 18 4 / 921 * - =
                            ^

Converting a normal expression into reverse polish:


    convert 17 * (8 + 3 * 6) / (7 * (5 + 4)) * (4 - 7)



    17 * (8 +      ) / (7 * (5 + 4)) * (4 - 7)
             3 6 *


    17 * (         ) / (7 * (5 + 4)) * (4 - 7)
          8 3 6 * +


    17 * (         ) / (7 *      ) * (4 - 7)
          8 3 6 * +         5 4 +


                   / (7 *      ) * (4 - 7)
    17 8 3 6 * + *        5 4 +


                   /           * (4 - 7)
    17 8 3 6 * + *   7 5 4 + *


                   /           * 
    17 8 3 6 * + *   7 5 4 + *   4 7 -


                               * 
    17 8 3 6 * + * 7 5 4 + * /   4 7 -


                              
    17 8 3 6 * + * 7 5 4 + * / 4 7 - *


Vectors


    #include <vector>

    vector<int> vi;
    vector<string> vs;

    vi.push_back(123);
    vi.push_back(17);
    vi.push_back(-6);
    vi.push_back(1);
    vi.push_back(12345678);

    for (int j = 0; j < v.size(); j += 1)
      cout << vi.at(j) << " ";

    would print
    123 17 -6 1 12345678

    vi.at(3) = 22;     
    vi.at(4) *= 2;
    cout << vi.at(5);    // error
    vi.at(5) = 99;       // also error even though not trying to see what doesn't exist

    vector<int> vi2(vi);     // identical copy

    vector<int> vi3(10, 123);    vi3.at(0) to vi3.at(9) all exist and = 123

    vector<int> vi4 = { 9, 8, 7, 4, 5, 3 };

    vi4.resize(100, 123);    like vi4.pus_back(123) repeated 94 times
                             94 not 100 because 6 alreay there

    vs.clear()

    vi.empty()   true or false, is size 0

    vi.back()  always = last entry

    vi.back() = 111;
    cout << vi.back();

    vi.push_back();     removes last item

    for (int i: vi)
      cout << i;

    vi[2] = 9;
    cout << vi[3];      almost the same as using at() except this is the dangerous one
                        it does not check that the position being accessed exists.