Sunday, November 18, 2007

C++ tricks from Jim Brooks

C++ Programming Language

C++ Programming


Please click here if you notice any mistakes or have additions.

C++ Tricks

// To turn a fundamental type into a (somewhat) distinct type.
class CLASS \
{ \
public: \
CLASS( T val ) : mVal(val) { } \
operator T() const { return mVal; } \
CLASS& operator=( const T& val ) { mVal = val; return *this; } \
private: \
T mVal; \
void Rotate( Radian rad ); // these overloaded functions become possible
void Rotate( Degree deg ); // yet can be manipulated as floats

STL Code Snippets

// Vector:
vector vec;
vec.push_back( name ); // push_back() means append

// Iterating thru a container:
vector files;
vector::iterator itr;
for ( itr = files.begin(); itr != files.end(); ++itr )
cout << *itr << endl;

// Iterating by subscript using an index (N/A to associative containers):
vector vec;
for ( int i = 0; i < vec.size(); ++i )

// Building and iterating thru a map and using pairs:
map mp;
mp.insert( pair( "a", 1 ) );
mp.insert( pair( "b", 2 ) );
mp.insert( pair( "c", 3 ) );
map::iterator itr;
for ( itr = mp.begin(); itr != mp.end(); ++itr )
cout << itr->first << " " << itr->second << endl;

// To test if a key exists in a map/set:
if ( mMap.find(key) != mMap.end() )

// Adding then removing from a container.
list l;
for ( int i = 0; i < 10; ++i )
l.push_back( i ); // append
while ( ! l.empty() )
{ // Prints/pops oldest (head) element first,
cout << l.front() << endl;

// If no match.
if ( map.find("key") == map.end() ) cout << "not found" << endl;

// Print a container.
list con;
copy( con.begin(), con.end(), ostream_iterator(cout," ") );

// Copy a container:
copy( con1.begin(), con1.end(),
con2 ); // WRONG/PITFALL if con2 smaller than con1

copy( con1.begin(), con1.end(),
back_inserter(con2) ); // OK if con2 smaller than con1

// Sorting using a binary predicate:
// An alternative (using the container container pointers instead
// of values) that doesn't need a binary predicate is to define
// your own operator<() which sort() uses by default.
bool BinPred( const Class& o1, const Class& o2 )
return o1.val < o2.val;
vector vec;
sort( vec.begin(), vec.end(), BinPred );

// A function that returns a pair.
// The pair is returned by value (like a struct would be, so it isn't dangling).

AddMul( float x, float y )
std::pair res;
res.first = x + y;
res.second = x * y;
return res;

// Print a binary number in base 2 using bitset.
bitset<8> val = 0xff;
cout << val;

// Turn string to all upper-case.
string s;
transform( s.begin(), s.end(),
toupper );

// Distance between two iterators.
distance( itr1, itr2 )

// Getting the iterator of an item that was inserted into a map:
// (a multimap/multiset differs, adapted from gfx_share.hh)
std::pair insertion;
insertion = mMap.insert( std::make_pair( *obj, std::make_pair(copy,1) ) );
itr = insertion.first; // insertion is assumed to succeed (bool not checked)

// Replacing/substituting chars of a string.
// string::replace() is really an overwrite, not a substitution.
Unix2DosDirChar( char c )
return c == '/' ? '\': c;
Unix2DosDir( const string& dirname )
string s = dirname;
std::transform( s.begin(), s.end(),
Unix2DosDirChar );
return s;

Stream Code Snippets

// Save/restore stream flags.
std::ios::fmtflags savedFlags = cout.flags();

// showbase (eg automatically print "0x" prefix for hex, etc).
cout.setf( std::ios::showbase );

// Set float precision.
mStream.setf( ios::fixed, ios::floatfield );
mStream.precision( 20 );

// Writing to an integer to a stream using width/precision.
// Note that width/precision is discarded after every call to stream object!
std::cout << std::setw(5) << std::setfill('0') << x << ' ';
std::cout << std::setw(5) << std::setfill('0') << y << ' ';
std::cout << std::setw(5) << std::setfill('0') << z << ' ' << std::endl;

// Convert an int to a string stream for the purpose
// of passing the int as a C++ string.
int i;
ostringstream ss;
ss << i; Print( ss.str() );

// Open for reading to test if file is empty. fname, ios::in|ios::binary );
if ( strm.good() && strm.is_open() )
// File exists. Is it empty?
char c; strm >> c; // a read is required to trigger EOF, seekg(1) alone won't
if ( strm.eof() )
cout << "File exists and is empty." << endl;
cout << "File exists and contains data." << endl;
cout << "File doesn't exist." << endl;

// Reopen in R/W mode.
strm.clear(); fname, ios::in|ios::out|ios::trunc|ios::binary );

Redirecting Streams

To write a class that redirects a stream to something else, define your own
streambuf class, then construct an ostream with pointer to the streambuf object.
An example is in Nicolais Josuttis's STL book.

A faux-pas is trying to derive from ostream (see prog/c++/
One problem is that passing endl will result in a "bad cast&qout; exception (g++ 3/4).

Defining operator<<()

The idea is to overload operator<<() with your user-defined type.

class Point
int x, y;

operator<<( ostream& strm, const Point& obj )
strm << "(" << obj.x << "," << obj.y << ")";
return strm;

Overloaded Operators

Overloaded operators, except assignment, are inherited.
But subtle compiler errors can occur.

Let's say you have two related classes that are logically different types,
but are structurally equivalent (identical members).

class Vertex
Vertex& operator+( const Vertex& src );

float x, y, z;

class WorldVertex : public Vertex

Now try adding two derived objects:

void Draw( const WorldVertex& v );

WorldVertex v1, v2, v3;
v3 = v1 + v2; // compile error
Draw( v1 + v2 ); // ok

Some compilers will give obscure errors, leading you to think
that you need to duplicate all the overloaded operator code
into every derived class. That wouldn't ideal.

What's happening in v3 = v1 + v2

is that Vertex::operator+() is called which returns a base Vertex object,
not a derived WorldVertex object.
You might think assigning a base object into a derived object is an immediate error.
But the C++ compiler first tries to find the matching assignment operator
such as Derived& operator=( const Base& ):

class WorldVertex : public Vertex

WorldVertex& operator=( const Vertex& src )
x = src.x;
y = src.y;
z = src.z;
return *this;

Because these classes are structurally equivalent,
Derived& operator=( const Base& ) does make sense,
as it can simply copy .x, .y, .z.

C++ Pitfalls & Traps

C++ has a zillion pitfalls, this lists some of the worst.

  • Reusing or abusing assignment operator=() in a copy constructor:

  • This pitfall exists with more complex classes whose members aren't fundamental types.
    Assignment operators should free members before reassigning them.
    If an operator=() that frees resources is called in a copy constructor,
    it will try to free garbage. A solution is have separate Copy() and Free() methods.

    class Class
    Class( const Class& src )
    *this = src; // the temptation to write terse code leads to a pitfall
    Class& operator=( const Class& src )
    delete mObj; // free members
    mObj = src.Obj; // reassign members
    return *this;
    Class2* mObj;

  • Method overriding will fail if you forget to write virtual
    by a method in base class or the function signatures differ.

  • Calling a virtual method from a base constructor.

  • Think about the order of construction: the derived object hasn't been constructed yet.

  • Default copy constructors or assignment operators may cause trouble.

  • Safegaurds writing a dummy default copy constructor as private and/or with assert(0).

  • A constructor with a single arg might be misinterpreted as a conversion operator.

  • Use the keyword explicit if conversion isn't desired.

    Class( int );
    int n;
    Class obj = n; // converts an int to a Class obj !!

  • Temporary objects and reference args

  • void Byref( int& x )
    x = y;
    Byref( a + 2 ); // oops, result went nowhere into a temp

  • operator bool()

  • operator bool() is seductive for tersely testing if an object is valid:

    class Data
    operator bool() const { return mValid; }
    string mData;

    void Process( Data& data )
    // Valid data?
    if ( data )

    Let's say two objects are valid but their values (members) differ.

    if ( data0 == data1 ) return;

    You'd think return won't happen. But it will.
    This is what's compiled:

    if ( bool(data0) == bool(data1) ) return; // true == true

    The pitfall is implicit conversion.
    The class doesn't define operator==().
    But the compiler doesn't supply a default memberwise comparison
    as you might assume.
    Rather, the compiler implicity converts both operands to bools.
    Because that's precisely what operator bool() is for.

STL Pitfalls & Traps

  • end()

  • for ( itr = files.begin(); itr < files.end(); ++itr ) // WRONG
    for ( itr = files.begin(); itr != files.end(); ++itr ) // ok

  • reserve() vs. resize()

  • resize() expands the container -- reserve() doesn't!

  • Incrementing iterators

  • while ( itr++ != files.end() ) // WRONG, itr incremented past end

  • Short destination containers

  • This could be a bug if vec2 is shorter than vec.

    copy() won't extend the destination container.

    copy( vec.begin(), vec.end(),
    vec2.begin() );

    One solution is: vec2.resize( vec1.size() ).

    Another is to use an insert iterator (insertor):

    copy( vec.begin(), vec.end(),
    back_inserter(vec2) );

  • Catenating a string with a char

  • char baseName[] = "myfile";
    string suffix = "txt";
    string fileName = baseName + '.' + suffix; // WRONG

    This is wrong because the compiler misinterprets this as C's way
    of adding an integer to a pointer rather than as C++ string catenation.
    That is, the compiler's intepretation is:

    string fileName = &baseName[ int('.') ] + suffix;

C Preprocessor Tricks

  • Macro to expand a unique name:

  • // Arcane indirect trick to give a variable a unique name.
    // Subtlety: If written on the same line, UNIQUE_NAME() expands the same name.


© 2007 Jim Brooks

Last modified: Thu May 24 14:11:14 EDT 2007

keywords: C++ STL programming language, C++ STL resources, C++ tricks recipes, Standard Template Library, C++ common phrases expressions idioms, C++ code snippets, C++ pitfalls traps quirks caveats, programming tricks, GNU gcc g++,

No comments: