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++0x

• 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.

Tips

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.