cpp.txt

`e versions-used
g++ 4.6 with -std=c++0x flag
`e show-version
`$[g++ --version]
`e implicit-prologue
`#[#include <iostream>]
`#[#include <string>]

`*using `*namespace std;
`e hello-world
`$[cat hello.cpp]

`#[#include <iostream>]
`*using `*namespace std;
`*int main(`*int argc, `*char** arg) {
  cout << "Hello, World!" << endl;
}

`$[g++ -std=c++0x hello.cpp]
`$[./a.out]
`e file-suffixes
foo.cpp
foo.h
foo.o
`e block-delimiters
{ }
`e statement-terminator
;
`e top-level-statements
A source file will normally have #include directives at the top, followed by declarations, definitions, and namespaces containing declarations and definitions.


After the preprocessor has finished processing a source file, the compilation unit will only contain declarations, definitions, and namespaces at the top level.
`e end-of-line-comment
// comment
`e multiple-line-comment
/* comment
another comment */
`e local-variable
`*int i;
`*int j = 3;
`*int k(7);
`e uninitialized-local-variable
The behavior is undefined.

Most implementations do not zero-initialize stack variables, so the value will be whatever happened to be in memory.
`e global-variable
`c[in foo.cpp and outside of any function or class definition:]
`*int foo = 7;

`c[in bar.cpp and outside of any function or class definition:]
`*extern `*int foo;
`e uninitialized-global-variable
Zero initialized: numeric types and pointers are set to zero. Classes, structs, and arrays have all of their members or elements zero-initialized recursively.
`e constant
`*const `*int i = 7;
`e assignment
`*int n;

n = 3;
`e compound-assignment-arithmetic-string-logical-bit
+= -= *= /= %=
<<= >>= &= ^= |=
`e increment-and-decrement
`*int n = 1;
`*int one = n++;
`*int three = ++n;
`*int two = --n;
`e address
`*int i(3);
`*int* ip = &i;
`e dereference
`*int i(3);
`*int* ip = &i;
`*int i2 = *ip + 1;
`e type-size
cout << `.sizeof(`*int) << endl;

cout << `.sizeof(`*int*) << endl;
`e address-arithmetic

`e unique-pointer

`e reference-count-pointer

`e weak-pointer

`e allocate-heap
`*int* ip = `*new `*int;
`e uninitialized-heap
Memory allocated by the new operator is zero-initialized.
`e free-heap
`*delete i;
`e null
`.NULL
`e coalesce
`.string s1 = s2 || "was null";
`e boolean-type
`*bool
`e true-and-false
`=true `=false
`e falsehoods
`=false `=0 `=[0.0] `.NULL
`e logical-operators
`+[&& || !]
`+[and or not]
`e relational-operators
`+[== != < > <= >=]
`e integer-type
`*signed `*char n1;   `c[1+ bytes]
`*short `*int n2;     `c[2+ bytes]
`*int n3;           `c[2+ bytes]
`*long `*int n4;      `c[4+ bytes]
`*long `*long `*int n5; `c[4+ bytes]
`e unsigned-type
`*unsigned `*char n1;          `c[1+ bytes]
`*unsigned `*short `*int n2;     `c[2+ bytes]
`*unsigned `*int n3;           `c[2+ bytes]
`*unsigned `*long `*int n4;      `c[4+ bytes]
`*unsigned `*long `*long `*int n5; `c[4+ bytes]
`e float-type
`*float x1;       `c[4 bytes]
`*double x2;      `c[8 bytes]
`*long `*double x3; `c[16 bytes]
`e fixed-type
`c[none]
`e arithmetic-operators
+ - * / %
`e integer-division
`c[evaluates to 2:]

7 / 3
`e integer-division-by-zero
process sent a SIGFPE signal
`e float-division
7 / static_cast<`*float>(3)
`e float-division-by-zero
positive dividend: inf
zero dividend: nan
negative dividend: -inf

There are no portably defined literals or constants for the above values.
`e power
`#[#include <cmath>]

`*double x = pow(2.0, 32.0);
`e sqrt
`#[#include <cmath>]

`*double x = sqrt(2);
`e sqrt-1
nan
`e transcendental-functions
`#[#include <cmath>]


exp log log2 log10

sin cos tan

asin acos atan

atan2
`e transcendental-constants
`#[#include <cmath>]

`*double e = M_E;
`*double pi = M_PI;
`e float-truncation
`#[#include <cmath>]
 
`*double x = 3.7;
 
`*long trnc = static_cast<`*long>(x);
`*long rnd = round(x);
`*long flr = floorl(x);
`*long cl = ceill(x);
`e absolute-value-and-signum
`#[#include <cmath>]    `c[fabs(])
`#[#include <cstdlib>]  `c[abs(])

`*int n = -7;
`*int absn = abs(n);

`*double x = -7.77;
`*double absx = fabs(x);
`e integer-overflow
modular arithmetic


The C standard does not define behavior for signed integers, however.
`e float-overflow
no behavior defined by standard; many implementations return inf
`e float-limits-largest-finite-float-smallest-positive-float
`#[#include <cfloat>]

FLT_MAX
FLT_MIN
DBL_MAX
DBL_MIN
LDBL_MAX
LDBL_MIN
`e complex-construction
`#[#include <complex>]

complex<`*double> z(1.0, 2.0);
`e complex-decomposition
z.real()
z.imag()
arg(z)
abs(z)
conj(z)
`e random-number-uniform-integer-uniform-float-normal-float
`#[#include <random>]

default_random_engine dre;

uniform_int_distribution<`*int> uid(0, 99);
uniform_real_distribution<`*double>
  urd(0.0, 1.0);
normal_distribution<`*double> nd(0.0, 1.0);

`*int i = uid(dre);
`*double x = urd(dre);
`*double y = nd(dre);
`e random-seed
`#[#include <random>]

`c[set seed in constructor:]
default_random_engine dre(17);

`c[set seed of existing engine:]

dre.seed(17);
`e bit-operators
 << >> & | ^ ~ 
 bitand bitor compl

>> is arithmetic right shift on signed integers and logical right shift on unsigned integers
`e binary-octal-and-hex-literals
`=[0b0101010]
`=[052]
`=[0x2a]
`e radix-convert-integer-to-and-from-string-with-radix

`e string-type
`.string s("lorem ipsum");

`c[convert to C string:]
`*const `*char* s2 = s.c_str();
`e string-literal
`c[const char*:]
"don't say \"no\""
`e newline-in-literal
Newlines in string literals are ignored.
`e literal-escapes
`%[\a \b \f \n \r \t \v]
`%[\\ \" \']
`%[\xhh \o \oo \ooo]
`e allocate-string
`.string* s = `*new string("hello");
`e are-strings-mutable
`.string s("bar");

s[2] = `=['z'];
`e copy-string
`.string s("bar");

`c[use assignment or copy constructor:]
`.string s2 = s;
`.string s3(s);

`c[s contains "baz"; s2 and s3 contain "bar":]

s[2] = 'z';
`e format
`#[#include <sstream>]

ostringstream oss;

oss << "Spain: " << 7;
`.string s(oss.str());
`e compare-strings
`.string s1("hello");
`.string s2("world");

`c[negative if s1 lexically before s2; zero if s1 and s2 are equal:]
`*int result1 = s1.compare(s2);

`*bool result2 = s1 == s2;
`e concatenate-strings
`.string s("hello");
`.string s2 = s + " world";

s += " world";
`e replicate-string
`.string hbar(80, '-');
`e translate-case
`#[#include <algorithm>]

`.string s("foo");

`c[in place:]

transform(s.begin(), s.end(),
          s.begin(), ::toupper);

transform(s.begin(), s.end(),
          s.begin(), ::tolower);

`c[non-destructive:]
`.string s2;

s2.resize(s.size();

transform(s.begin(), s.end(),
          s2.begin(), ::toupper);
`e trim
`#[#include <algorithm>]

`.string s(" hello ");
`c[trim in place on left:]

s.erase(
  s.begin(),
  find_if(
    s.begin(),
    s.end(),
    not1(ptr_fun<`*int, `*int>(isspace))
  )
);

`c[trim in place on right:]

s.erase(
  find_if(
    s.rbegin(),
    s.rend(),
    not1(ptr_fun<`*int, `*int>(isspace))
  ).base(),
  s.end()
);
`e pad
`#[#include <iomanip>]
`#[#include <sstream>]

`.string s("hello");
`.string rpad(s);

rpad += `.string(10 - s.length(), ' ');

ostringstream oss;

oss << setw(10) << s;
`.string lpad(oss.str());
`e number-to-string

`e string-to-number
`#[#include <sstream>]

stringstream ss("7 14.3 12");
`*int n1;
`*double x;
`*long n2;


ss >> n1 >> x >> n2;
`e join

`e split

`e serialize

`e string-length
`.string s("hello");
size_t len = s.length();
`e index-of-substring
`.string("hello").find("ll")
`e extract-substring
`.string("hello").substr(2, 2)
`e character-type
`*char
wchar_t
`e character-literal
`*char n = 'X';
`e test-character
`c[functions have this signature:]
`*int (*)(`*int)

isalpha
isdigit
isspace
isupper
islower
`e regex-type
regex
wregex
`e character-class-abbreviations
. \d \D \s \S \w \W
`e anchors
^ $ \b \B
`e lookahead-positive-negative
(?=subpattern)

(?!subpattern)
`e match-test
`#[#include <regex>]


regex rx(".*ll.*");

`*bool match = regex_match("hello", rx);
`e case-insensitive-match-test
`#[#include <regex>]


regex rx("lorem", icase);

`*bool match = regex_match("Lorem", rx);
`e modifiers

`e substitution

`e match-prematch-postmatch

`e group-capture

`e date-time-type

`e current-date-time

`e to-unix-epoch-from-unix-epoch

`e date-and-time-to-string

`e format-date

`e parse-date

`e date-subtraction

`e add-duration

`e date-parts

`e time-parts

`e declare-on-stack
`*int a[10];
`e declare-on-heap
`*int* a = `*new `*int[10];
`e free-heap
`*delete[] a;
`e array-initialization-list
`*int a[] = {1, 2, 3};
`e array-size
`*int a[10];

`c[stack arrays only:]
size_t len = `.sizeof(a) / `.sizeof(a[0]);
`e array-lookup
`*int first = a[0];
`e array-update
a[0] = 7;
`e array-out-of-bounds
No defined behavior

An out-of-bounds lookup may return the value the memory location contains; an out-of-bounds update may cause memory corruption. The system may detect an invalid address and send the process a SIGSEGV.
`e array-copy
`*const size_t LEN(4);
`*int src[LEN] = {3, 2, 4, 1};
`*int dest[LEN];

`c[3rd arg is number of bytes to copy:]

memcpy(dest, src, LEN * `.sizeof(src[0]));
`e as-function-argument
`*void
reverse(`*int* a, size_t len) {
  `*for (`*int i = 0; i < len / 2; ++i) {
    `*int tmp = a[len - i - 1];
    a[len - i - 1] = a[i];
    a[i] = tmp;
  }

}

`*const size_t LEN(4);
`*int a[LEN] = {3, 2, 4, 1};

reverse(a, LEN);
`e array-iterate
`*const size_t LEN(4);
`*int a[LEN] = {3, 2, 4, 1};

`*for (`*int i = 0; i < LEN; ++i) {
  cout << "value at " << i << " is "
       << a[i] << endl;

}
`e sort
`#[#include <cstdlib>]

`*int
comp(`*const `*void* `*const `*void* bp) {
  `*int a = *(`*int*)ap;
  `*int b = *(`*int*)bp;
  `*return a < b ? -1 : (a == b ? 0 : 1);

}

`*const size_t LEN(4);
`*int a[LEN] = {3, 2, 1, 4};


qsort(a, LEN, `.sizeof(a[0]), &comp);
`e list-name
vector<T>
`c[supports efficient random access and manipulation of end; STL also provides deque<T> and list<T>]
`e list-declare
`#[#include <vector>]
vector <`*int> a;
`e list-literal
`#[#include <vector>]

vector<`*int> a = {1, 2, 3};
vector<`*int> a2({7, 8, 9});
`e list-size
size_t len = a.size();
`e capacity-get-increase
size_t cap = a.capacity();

`c[will not decrease capacity:]

a.reserve(10);
`e empty-test-and-clear
`*bool is_empty = a.empty();

a.clear();
`e list-lookup
`*int n = a[0];

`c[can raise out_of_range:]
`*int n2 = a.at(0);
`e list-update
a[2] = 4;
`e list-out-of-bounds
using [] with out-of-bounds index has undefined behavior
`e index-of-element
`#[#include <vector>]

vector<`*int> a({6, 7, 8, 9});

`*auto iter = find(a.cbegin(), a.cend(), 8);
`*if (iter != a.cend()) {
  size_t pos = *iter;

}
`e slice
`#[#include <vector>]

vector<`*int> a({6, 7, 8, 9});

`c[a2 contains {7, 8}:]
vector<`*int> a2(a.cbegin() + 1,
               a.cbegin() + 3);
`e drop
`#[#include <vector>]

vector<`*int> a({6, 7, 8, 9});

`c[a2 contains {7, 8, 9}:]
vector<`*int> a2(a.cbegin() + 1, a.cend());
`e manipulate-back
`#[#include <vector>]

vector<`*int> a({6, 7, 8});


a.push_back(9);
`*int elem = a.pop_back();
`e manipulate-front
`#[#include <vector>]

vector<`*int> a({6, 7, 8});

`c[slower than manipulating back:]

a.insert(a.cbegin(), 5);
`*int elem = a[0];

a.erase(a.cbegin());
`e concatenate
`#[#include <vector>]

vector<`*int> a1({1, 2, 3});
vector<`*int> a2({4, 5, 6});


a1.insert(a1.cend(),
          a2.cbegin(),
          a2.cend());
`e list-replicate
`#[#include <vector>]

`c[array of 10 zeros:]
vector<`*int> a(10, 0);
`e list-copy
`#[#include <vector>]

vector<`*int> a({1, 2, 3});
`c[copy constructor:]
vector<`*int> a2(a);
vector<`*int> a3;

`c[assignment performs copy:]

a3 = a;
`e array-as-function-argument
use reference or pointer to avoid copying array
`e iterate-over-elements
`#[#include <vector>]

`*int sum(0);
vector<`*int> a({1, 2, 3});

`*for (`*const `*auto& n: a) {
  sum += n;
}
`e iterate-over-indices-and-elements
`#[#include <vector>]

vector<`*int> a({6, 7, 8});

`*for (`*auto iter = a.cbegin();
     iter != a.cend();
     ++iter) {

  cout << "value at " << iter - a.cbegin()
       << " is " << *iter << endl;
}
`e reverse
`#[#include <vector>]

vector<`*int> a({1, 2, 3});
vector<`*int> a2(a.crbegin(), a.crend());
`e sort
`#[#include <vector>]

vector<`*int> a({3, 2, 4, 1});
sort(a.begin(), a.end());
`e dedupe
`#[#include <set>]
`#[#include <vector>]

vector<`*int> a({1, 1, 2, 2, 3});
set<`*int> tmp(a.cbegin(), a.cend());
`c[often unnecessary since sets provide many of the same methods as vectors:]
vector<`*int> a2(tmp.cbegin(), tmp.cend());
`e membership
`#[#include <vector>]


vector<`*int> a({1, 2, 3});

`*if (find(a.cbegin(), a.cend(), 7) !=
    a.cend()) {
  cout << "contains 7" << endl;
}
`e intersection

`e union

`e relative-complement-symmetric-difference

`e map

`e filter

`e min-and-max-element

`e shuffle-and-sample

`e zip

`e declare-pair
`.pair <`.string, `*int> p1;
`.pair <`.string, `*int> p2("foo", 7);

`*auto p3 = `.make_pair("foo", 7);
`e lookup-pair-elements
`*auto p = `.make_pair("foo", 7);

cout << "first: " << p.first << endl;

cout << "second: " << p.second << endl;
`e update-pair-elements
p.first = "bar";
p.second = 8;
`e declare-tuple
tuple<`.string, `*int, `*float> tup1;
tuple<`.string, `*int, `*float> tup2(
  "foo", 1, 3.7);

`*auto tup3 = make_tuple("foo", 1, 3.7);
`e lookup-tuple-elements

`e update-tuple-elements

`e tuple-size

`e create-references-for-tuple-elements

`e map-declaration
`#[#include <map>]

map<`.string, `*int> m;
`e map-access
m["hello"] = 5;

cout << m["hello"] << endl;
`e map-size
m.size()
`e map-remove-element
m.erase(m.find("hello"));
`e map-element-not-found-result
returns element created by default constructor of value type
`e map-iterate
map<`.string,`*int>::iterator mi;

`*for (mi = m.begin(); mi != m.end(); ++mi) {
  printf("%s %d", mi->first, mi->second)

}
`e declare-function
`c[parameter names are optional:]
`*int
add(`*int m, `*int n);
`e define-function
`*int
add(`*int m, `*int n) {
  `*return m + n;

}
`e invoke-function
`*int sum = add(3, 7);
`e define-static-class-method
`c[Ops.h:]
class Ops {
public:
  static `*int add(`*int m, `*int n);

};

`c[Ops.cpp:]
`*int Ops::add(`*int m, `*int n) {
  `*return m + n;

}
`e invoke-static-class-method
`*int sum = Ops::add(3, 7);

`c[class name not needed inside class namespace:]
`*int sum = add(3, 7);
`e overload-function
`*int add(`*int m, `*int n) {
  `*return m + n;
}

`*float add(`*float x, `*float y) {
  `*return x + y;
}
`e default-argument
`#[#include <cmath>]

`*float
logarithm(`*float x, `*float base = 10.0) {
  `*return log(x) / log(base);

}
`e variable-number-of-arguments

`e named-parameters
none
`e pass-by-value
`*int add1(`*int n) {
  `*return ++n;

}

`*int i(7);

`c[set i2 to 8 w/o modifying i:]
`*int i2 = add1(i);
`e pass-by-reference
`*int add1(`*int& n) {
  `*return ++n;

}

`*int i(7);

`c[set i and i2 to 8:]
`*int i2 = add1(i);
`e pass-by-address
`*int add1(`*int* n) {
  `*return ++*n;

}

`*int i(7);

`c[set i and i2 to 8:]
`*int i2 = add1(&i);
`e return-value
argument of `*return; type must be declared
`e no-return-value
`*void
message(`*const `.string& msg) {
  cout << msg << endl;
}
`e recursive-function
`*int
factorial(`*int n) {
  `*if (n <= 1) {
    `*return 1;
  }
  `*return n * factorial(n - 1);
}
`e lambda
`*auto add = [](`*int n, `*int m) {
  `*return n + m;
};
`c[with explicit type annotation and capture-by-reference:]
`#[#include <functional>]
std::function<`*int(`*int)> fibo = [&](`*int x){
    `*return x <= 1 ? x : fibo(x-1) + fibo(x-2);
};
`e invoke-anonymous-function
`c[on variable holding anon. function:]
`*int sum = add(3, 7);

`c[on lambda expression:]
`*int sum2 = [](`*int n, `*int m) {
  `*return n + m;
}(3, 7);
`e closure

`e function-with-private-state
`*int counter() {
  static `*int i = 0;
  `*return ++i;

}
`e function-as-value

`e overload-operator
Rational Rational::operator+(Rational& o) {
  `*return Rational(this->num * o.denom + o.num * this->denom, this->denom * o.denom);
}
`e if
`*int signum;
`*if (n > 0) {
  signum = 1;
} `*else `*if (n == 0) {
  signum = 0;
} `*else {
  signum = -1;
}
`e dangling-else
`*if (n == 0)
  `*if (m == 0)
    cout << "n and m are zero" << endl;
  `*else
    cout << "n is zero; m isn't" << endl;
`e switch
`*const `*int INVALID_BINARY_DIGIT(-1);
`*int bin_digit;

`*switch(n) {
`*case 0:
`*case 1:
  bin_digit = n;
  break;
`*default:
  bin_digit = INVALID_BINARY_DIGIT;
  `*break;
}
`e while
`*int i(1), fact(1), n(10);

`*while (i < n) {
  fact *= i;
  ++i;
}
`e for
`*int fact, n(10);

`*for (`*int i = 1, fact = 1; i <= n; ++i) {
  fact *= i;

}
`e break
`*int data[4] = {3, 2, 0, 1};
`*int i;
`*bool has_zero(`=false);

`*for (i = 0; i < 4; ++i) {
  `*if (data[i] == 0) {
    has_zero = `=true;
    break;
  }

}
`e break-out-of-nested-loops
`*int data[2][2] = {{3, 2}, {0, 1}};
`*int i, j;
`*bool has_zero(`=false);

`*for (i = 0; i < 2; ++i) {
  `*for (j = 0; j < 2; ++j) {
    `*if (data[i][j] == 0) {
      has_zero = `=true;
      goto end_of_loops;
    }
  }

}

:end_of_loops
`e continue
`*int a[4] = {3, 2, 0, 1};

`*for (`*int i = 0; i < 4; ++i) {
  `*if (a[i] == 0) {
    `*continue;
  }
  cout << 1.0 / a[i] << endl;
}
`e goto

`e base-exception
Any type can be thrown.


All exceptions thrown by the language or the standard library derive from exception, defined in <exception>.
`e predefined-exceptions
`#[#include <exception>]
`#[#include <stdexcept>]
`#[#include <system_error>]
`#[#include <typeinfo>]


exception
  logic_error
    domain_error
    invalid_argument
    length_error
    out_of_range
  runtime_error
    system_error
      ios_base::failure
  bad_cast
  bad_exception
  bad_alloc
`e raise-exception
`#[#include <cstdlib>]
`#[#include <stdexcept>]

`*void risky() {
  `*if (rand() < 10) {
    `*throw runtime_error("bam!");
  }

}
`e handle-exception
`#[#include <stdexcept>]

try {
  risky();

}
catch (`*const exception &e) {
  cout << e.what() << endl;

}
`e define-exception
`#[#include <stdexcept>]

class Bam : public runtime_error {
public:
  Bam() : runtime_error("bam!") {}

};

throw Bam();
`e re-raise-exception
`#[#include <stdexcept>]

try {
  risky();

}
catch (`*const exception& e) {
  cout << "an error occurred..." << endl;
  throw;

}
`e catch-all-handler
`#[#include <stdexcept>]

try {
  risky();

}
catch (...) {
  cout << "an error was ignored"
       << endl;

}
`e multiple-handlers
`#[#include <stdexcept>]

try {
  risky();

}
catch (`*const system_error &e) {
  cout << "system error: " << e.name()
       << endl;

}
catch (`*const exception &e) {
  cout << "exception: " << e.what()
       << endl;

}
catch (...) {
  cout << "unknown error" << endl;

}
`e uncaught-exception-behavior
calls terminate() which by default calls abort()
`e error-message
`#[#include <exception>]

try {
  risky();

}
catch (`*const exception &e) {
  `*const `*char *msg = e.what();

}
`e system-call-errno
`#[#include <system_error>]

try {
  risky();

}
catch (`*const system_error &e) {
  `*int err_code_val = e.code().value();

}
`e finally
none
`e exception-specification
`c[Use noexcept to declare that a function does not raise exceptions; declaring which exceptions a function raises is deprecated in C++11.]
`*int
add(`*int a, `*int b) noexcept {
  `*return a + b;

}
`e start-thread

`e terminate-current-thread

`e terminate-other-thread

`e list-threads

`e wait-on-thread

`e lock

`e create-message-queue

`e send-message

`e receive-message

`e standard-file-handles
cin
cout
cerr
clog
`e printf
cout << "count: " << 7 << endl;
`e read-from-file
`#[#include <fstream>]

`.string line;

ifstream f("/etc/passwd");

`*if (f.is_open()) {
  `*while (!f.eof()) {
    getline(f, line);
    `c[process line]
  }
  f.close();
  `*if ( 0 != f.fail() ) {
    `c[handle error]
  }
} `*else {
  `c[handle error]
}
`e write-to-file
`#[#include <fstream>]

ofstream f("/tmp/test4");

`*int i;

`*for (i = 0; i < 10; ++i) {
  f << i << endl;

}

f.close();

`*if (0 != f.fail()) {
  handle error

}
`e file-exists-test-regular-test

`e file-size

`e is-file-readable-writable-executable

`e set-file-permissions

`e copy-file-remove-file-rename-file

`e csv

`e json

`e build-xml

`e parse-xml

`e parse-html

`e build-pathname

`e dirname-and-basename
`#[#include <libgen.h>]

`.string s1 = dirname("/etc/hosts");
`.string s2 = basename("/etc/hosts");
`e absolute-pathname
`#[#include <climits>]
`#[#include <cstdlib>]

`*char buf[PATH_MAX];

`*if (realpath("..", buf) == NULL) {
  throw exception();

} `*else {
  `.string path(buf);
}
`e iterate-over-directory-by-file

`e glob-paths

`e make-directory

`e recursive-copy

`e remove-empty-directory

`e remove-directory-and-contents

`e directory-test

`e generate-unused-directory-name

`e system-temporary-file-directory

`e signature-of-main
`*int main(`*int argc, `*char** argv) {
`e first-argument
pathname of executable
`e environment-variable
`#[#include <stdlib.h>]

`*char* home = getenv("HOME");

setenv("EDITOR", "emacs", 1);

unsetenv("EDITOR");
`e iterate-through-environment-variables

`e standard-library-name
C++ Standard Library
`e declare-namespace
`*namespace foo {
  `*namespace bar {
    class Baz {
      static `*const `*int ANSWER = 42;
    };
  }

}
`e multiple-namespaces-per-file
yes
`e namespaces-map-to-directories
no
`e import-namespace
`*using `*namespace foo::bar;

cout << Baz::ANSWER << endl;
`e import-part-of-namespace
`*using `*namespace foo;

cout << bar::Baz::ANSWER << endl;
`e import-symbol
`*using foo::bar::Baz;

cout << Baz::ANSWER << endl;
`e import-static-symbol
none
`e import-position
anywhere a statement is legal
`e using-a-symbol-that-hasn-t-been-imported
cout << foo::bar::Baz::ANSWER << endl;
`e application-environment

`e multiple-installations

`e package-manager

`e type-synonym
typedef `*int customer_id;

customer_id cid = 3;
`e enum
enum day_of_week { mon, tue, wed, thu, fri, sat, sun };

day_of_week d = tue;
`e struct-definition
`*class MedalCount {
`*public:
  `*const `*char *country;
  `*int gold;
  `*int silver;
  `*int bronze;
};
`e struct-declaration
MedalCount spain;
`e struct-initialization
MedalCount spain = { "Spain", 3, 7, 4 };
`e struct-member-assignment
spain.country = "Spain";
spain.gold = 3;
spain.silver = 7;
spain.bronze = 4;
`e struct-member-access
`*int spain_total = spain.gold + spain.silver + spain.bronze;
`e define-generic-type
`*template <class A>
`*class Foo {
`*public:
  A a;
  Foo(A a);
};

`*template <`*class A>
Foo<A>::Foo(A a) : a(a) {
}
`e instantiate-generic-type
Foo<`.string> f = Foo<`.string>("foo");
`e generic-function
template <class C>

C add(C a, C b) {
  `*return a + b;

}
`e generic-array
template <class C>

class Foo {

public:
  C a[10];

};
`e value-parameter
template <`*int N>

`*int add(`*int i) {
  `*return N+i;

}
 

cout << add<7>(3) << endl;
`e template-parameter

`e template-specialization

`e multiple-type-parameters
template <class A, class B>

class Pair {

public:
  A a;
  B b;
  Pair(A a, B b);

};
 

template <class A, class B>

Pair<A, B>::Pair(A a, B b) :
  a(a), b(b) { }
  

Pair<`*int, `.string> p =
  Pair<`*int, `.string>(7, "foo");
`e generic-type-parameters
Pair<`*int, Foo<`.string> > p =
  Pair<`*int, Foo<`.string> >(
    7, Foo<`.string>("foo"));
`e template-parameters

`e variadic-template

`e semantics-of
value comparison
`e define-class
Rational.hpp:

class Rational {
 public:
  `*int num, denom;
  Rational(`*int num, `*int denom);
  virtual ~Rational();
  Rational operator+(Rational& addend);
  static Rational max(Rational& a, Rational& b);

};
`e class-definition-location
top level, class block, or function block
`e constructor
Rational::Rational(`*int n, `*int d) : num(n), denom(d) {
  `*if (denom == 0) {
    throw "zero denominator";
  }
  `*int div = gcd(n,d);
  num = num / div;
  denom = denom / div;
}
`e create-object
Rational r1(7, 3);

Rational* r2 = `*new Rational(8, 5);
`e destructor
Rational::~Rational() {};
`e destroy-object
`*delete r2;
`e define-method
`*int Rational::height() {
  `*return (abs(num) > abs(denom)) ? abs(num) : abs(denom);
}
`e invoke-method
r1.height();

r2->height();
`e define-class-method
declare static in class definition
`e invoke-class-method

`e name-of-receiver
this
`e access-control
access keywords define regions:

class Foo {
  `*int privateInt1;
  `*int privateInt2;

public:
  `*int publicInt1;
  `*int publicInt2;

protected:
  `*int protectedInt1;
  `*int protectedInt2;

private:
  `*int privateInt3;
  `*int privateInt4;

};
`e anonymous-class
possible but not useful
`e dynamic-dispatch
declare as virtual in base class
`e static-dispatch
dispatch static by default
`e subclass
class Integer : public Rational {
 public:
  Integer(`*int n);
  virtual ~Integer();

};
`e invoking-superclass-constructor
Integer::Integer(`*int n) : Rational(n, 1) {

}
`e mark-class-underivable-or-method-unoverrideable
none
`e root-class
none
`e root-class-methods
none
`e get-type-class-of-object

`e get-type-class-from-string

`e get-type-class-from-type-identifier
typeid(Foo)
`e class-name
typeid(Foo).name()
`e get-methods

`e has-method

`e invoke-method-object

`e get-local-hostname-dns-lookup-reverse-dns-lookup

`e http-get

`e http-post

`e absolute-url

`e parse-url

`e url-encode-decode

`e base64-encode-decode

`e test-class
`$[cat > test_foo.cpp]

`#[#include <cppunit/TestCaller.h>]

`#[#include <cppunit/TestCase.h>]

`#[#include <cppunit/TestSuite.h>]

`#[#include "test_foo.h"]


`*using `*namespace CppUnit;


`*void TestFoo::test_01() {
  CPPUNIT_ASSERT_EQUAL(1, 1);

}


Test* TestFoo::suite() {
  TestSuite* suiteOfTests = `*new TestSuite("Foo");
  suiteOfTests->addTest(
  `*new TestCaller<TestFoo>(
    "test_01",
    &TestFoo::test_01));

  `*return suiteOfTests;

}


`$[cat > test_foo.h]

`#[#include <cppunit/TestCase.h>]


class TestFoo: public CppUnit::TestCase {

public:
  `*void test_01();

  static CppUnit::Test* suite();

};
`e run-all-tests
`$[cat > test_runner.cpp]

`#[#include <cppunit/ui/text/TestRunner.h>]
`#[#include "test_foo.h"]

`*int main( `*int argc, `*char** argv) {
  CppUnit::TextUi::TestRunner runner;
  runner.addTest(TestFoo::suite());
  runner.run();
  `*return 0;
}

`$[sudo apt-get install libcppunit-dev]
`$[cat > Makefile]

test_runner: test_runner.o test_foo.o
        g++ -o $@ $^ -lcppunit


check: test_runner
        ./test_runner


`$[make check]
`e equality-assertion
`#[#include <cppunit/TestCase.h>]


CPPUNIT_ASSERT_EQUAL(1, 1);

CPPUNIT_ASSERT_EQUAL("foo", "bar");

CPPUNIT_ASSERT_EQUAL_MESSAGE("1 != 1",
  1, 1);
`e approximate-assertion

`e exception-assertion

`e setup

`e teardown

`e stronger-warnings
`$[g++ -Wall foo.cpp]
`e suppress-warnings
`$[g++ -w foo.cpp]
`e treat-warnings-as-errors
`$[g++ -Werror foo.cpp]
`e run-debugger
`$[g++ -g -o foo foo.cpp]


`$[gdb foo]

(gdb) b main

(gdb) run
`e debugger-commands-help-list-source-re-load-executable-next-step-set-breakpoint-show-breakpoints-delete-breakpoint-continue-backtrace-up-stack-down-stack-print-run-quit
> h
> l [FIRST_LINENO, LAST_LINENO]
> file PATH
> n
> s
> b [FILE:]LINENO
> i
> d NUM
> c
> bt
> up
> do
> p EXPR
> r [ARG1[, [ARG2 ...]]
> q
`e benchmark-code

`e profile-code
gprof does not work on Mac OS X:


`$[g++ -pg -o foo foo.cpp]


`$[./foo]


`$[gprof foo]
`e memory-tool
`$[sudo apt-get install valgrind]


`$[g++ -o foo foo.cpp]


`$[valgrind ./foo]