C++

References

See also C references.

• www.cplusplus.com — C++ Reference
• Including C Language Library
• and ... IOStream Library
• SGI — Standard Template Library Programmer's Guide
• C++ FAQ
• Evolving a language in and for the real world: C++ 1991-2006, Bjarne Stroustrup (pdf)
• manpage stl-manual (from SGI)

sudo apt-get install stl-manual
ln -s /usr/share/doc/stl-manual/html /var/www/sgi        # Now the manual is available at http://localhost/sgi

References - local copy

# Make a local copy of www.cplusplus.com - use option -P http://proxy:port if needed
httrack http://www.cplusplus.com/ -W -O /var/www -%v "-www.cplusplus.com/forum/*" "-www.cplusplus.com/src/*" "-www.cplusplus.com/member/*"

Books

• Design Patterns: Elements of Reusable Object-Oriented Software

C++ Standards

References

• http://en.cppreference.com/ (can be freely downloaded, or installed as package cppreference-doc-en-html).

New in C++11

TBC

New in C++14

References

• http://www.drdobbs.com/cpp/the-c14-standard-what-you-need-to-know/240169034

Return type deduction

auto can be used as function return type. Most useful when combined with templates, or to avoid cascade of API changes if changing some object internal type.

auto getvalue()
{
    return 1.4;
}

Generic lambdas

These are lambdas using auto as parameter type:

// Here we make in fact a named-lambda
auto adder  = [](auto op1, auto op2){ return op1 + op2; };

This is the loose equivalent of creating a template function.

Initialized Lambda Captures

Now lambda parameter can be initialized:

auto y = [&r = x, x = x+1]()->int {...}

This allows for the move semantic in lambdas:

#include <memory>
#include <iostream>
 
int main()
{
  std::unique_ptr<int> p(new int);
  int x = 5;
  *p = 11;
  auto y = [p=std::move(p)]() { std::cout << "inside: " << *p << "\n";};
  y();
  std::cout << "outside: " << *p << "\n";
  return 0;
}

The deprecated attributes

[[deprecated("Consider using something other than cranky")]]
int cranky()
{
   return 0;
}

Handling is compiler specific.

Binary Literals and Digit Separators

Now we can use 0b to construct binary literals (like 0x for hex).

int val = 0b11110000;

Use ' to separate digit group (will not change the value):

int   mask   = 0b1000'0001'1000'0000;
float salary = 300'000.00;

Miscellaneous

• Variable templates

C++0x (old stuff)

• C++0x - the next ISO C++ standard (Bjarne Stroustrup)
• C++0x support in GCC
• The Biggest Changes in C++11 (and Why You Should Care)

auto_ptr deprecated

• Using auto_ptr To Automate Memory Management
• history of auto_ptr

unique_ptr and shared_ptr

• Using unique_ptr, Part I
  Basically, unique_ptr permits move from rvalues with copy syntax using a move constructor (which binds to rvalues), while blocking the copy from lvalues by making the copy constructor (which binds to lvalues) private:

template <class T>
class unique_ptr
{
public:
 unique_ptr(unique_ptr&& u);   // rvalues bind here
private:
 unique_ptr(const unique_ptr&); // lvalues bind here
};

• http://www.informit.com/guides/content.aspx?g=cplusplus&seqNum=239 The shared_ptr Class]

rvalue references (and move semantics)

• The rvalue Reference Proposal, Part I

Benchmark

Between compilers

• g++
• EKOPath4, a recently open-sourced compiler with much better performance than gcc/g++.
• Intel compiler
• pathCC, PathScale compiler

Between languages

• C++ reported to be the fastest language, even faster than C and java. See The Computer Language Benchmarks Game
• C++ the Clear Winner In Google's Language Performance Tests

Nested Classes

See Nested classes on ibm.com.

Virtual destructors

Rule of thumb: make your destructor virtual if your class has any virtual functions.

Virtual destructors are needed when a derived class is explicitly deleted via delete, but using a reference/pointer to a base class.

Patterns

Resource Allocation Is Initialization (RAII)

Reference:

• Resource Acquisition Is Initialization
• Bjarne Stroustrup's explanation about absence of finally block

From Kevin on stackoverflow.com: The idea is that an object's destructor is responsible for freeing resources. When the object has automatic storage duration, the object's destructor will be called when the block in which it was created exits — even when that block is exited in the presence of an exception.

Tips

Scoped enums

Use scoped enums to specify the underlying (storage) type for enums (available since c++11, ie. gcc/clang option -std=c++11):

typedef enum : unsigned char { zero, one, two } enum8_t;
typedef enum : unsigned short { zero16, one16, two16 } enum16_t;

assert (sizeof(enum8_t) == 1);                 
assert (sizeof(enum16_t) == 2);

Finally blocks

From stackoverflow.com:

int * array = new int[10000000];
try {
    // Some code that can throw exceptions
    // ...
    throw std::exception();
    // ...
} catch (...) {
    // The finally-block (if an exception is thrown)
    delete[] array;
    // re-throw the exception.
    throw; 
}
// The finally-block (if no exception was thrown)
delete[] array;

Note that the finally block may throw an exception, hence discarding the original exception.

To avoid the double delete:

std::exception_ptr e;

try { 
    /*try block*/ 
}
catch (...) {
    /*finally block*/
    e = std::current_exception();
}
if (e) {                            // e evaluates to 'false' if no exception!
    std::rethrow_exception(e);
}

Miscellaneous

Problem	Solution
Overloading operators i++ or ++i See [1] for more details.	class Number { public: // prefix ++ - Must return (*this) Number& operator++ (); // postfix ++ - Must never return (*this) by reference Number operator++ (int); // ... OR .... void operator++ (int); };
Reset ostringstream	ostringstream oss; oss << "Hello," << 123 << endl; string s = oss.str(); oss.str(""); // oss empty now - we can reuse it oss << "World!" << 456 << endl;

Binary I/O

See [2] for reference:

• Open a file. Binary file must be opened with mode ios::binary.

// Open a file for input
ifstream myFile ("data.bin", ios::in | ios::binary);

// Open a file for output
ofstream myFile;
...
myFile.open ("data2.bin", ios::out | ios::binary);

// Open a file for input and output
fstream myFile;
myFile.open ("data3.bin", ios::in | ios::out | ios::binary);

• Read from a file. Complex data must be casted to (char*).

#include <fstream.h>
...
char buffer[100];
ifstream myFile ("data.bin", ios::in | ios::binary);
myFile.read (buffer, 100);
if (!myFile) {
    // An error occurred!
    // myFile.gcount() returns the number of bytes read.
    // calling myFile.clear() will reset the stream state
    // so it is usable again.
}
...
if (!myFile.read (buffer, 100)) {
    // Same effect as above
}

• Write to a file. Complex data must be casted to (char*).

#include <fstream.h>
...
char buffer[100];
ofstream myFile ("data.bin", ios::out | ios::binary);
myFile.write (buffer, 100);

Security Tips

Problem	Solution
Use mlock() to prevent a section of memory from swapping to disk (source: "Building Secure Software," John Viega & Gary McGraw)

Tools

GNU cflow

GNU cflow analyzes a collection of C source files and prints a graph, charting control flow within the program.

GNU cflow is able to produce both direct and inverted flowgraphs for C sources. Optionally a cross-reference listing can be generated. Two output formats are implemented: POSIX and GNU (extended).

<iostream.h> or <iostream>

• <iostream> is the standard compliant library. <iostream.h> is deprecated since many many years.
• <iostream> contains a set of templatized I/O classes which support both narrow and wide characters (by contrast, <iostream.h> classes are confined to char exclusively).
• Third, the C++ standard specification of iostream's interface was changed in many subtle aspects. Consequently, the interfaces and implementation of <iostream> differ from <iostream.h>.
• Finally, <iostream> components are declared in namespace std whereas <iostream.h> components are declared in the global scope.

Note that both libraries cannot be mixed in one program.