C++ Member Initialization List

Just to clarify something that came up in some of the other answers...

There is no requirement that the initialization list be in either the source (.cpp) or header (.h) file. In fact, the compiler does not distinguish between the two types of files. The important distinction is between the contructor's declaration and it's definition. The initialization list goes with the definition, not the declaration.
Usually, the declaration is in a header file and the definition is in a source file, however, this is not a requirement of the language (i.e. it will compile). It is not unusual to provide constructor definitions inline in the class declaration when the constructor is empty or short. In that case an initialization list would go inside the class declaration, which would probably be in a header file.

MyClass.h

class MyClass
{
public:
    MyClass(int value) : m_value(value)
    {}
private:
    int m_value;
};

This is the initialization list :

Example::Example( int size, int grow_by) : m_size(5), m_top(-1)
{
... some code here
}

and it should be done only in the cpp file.

Don't you get an error when you do it like you did in the header in your example?

Member Initializer list should be a part of a definition in the source file.
Write this in the .cpp file:

Example ( int size, int grow_by) : m_size(5), m_top(-1)
{

}

The header file should only have:

Example ( int size, int grow_by = 1 );

The header file only declares the constructor, the member initializer list is not a part of the declaration.

Adding to others answers, the one most important thing one should remember about initialization list is that, the order of initialization is decided in the order in which the data members are declared, not the the order in which you have initialized the data members using initialization list

Consider the example (Yours):

class Example
{
private:
    int m_top;
    const int m_size;
    ...
public:
    Example ( int size, int grow_by = 1 ) : m_size(5), m_top(-1){}

                   /* Though size is initialized with a value first
                       But it is m_top variable that is assigned value -1
                       before m_size is assigned value 5 */
    ...
    ~Example(){}
};

In C++11 you can use non-static data member initialization. This is especially useful if you have several constructors that need a common value for a member variable.

class Example
{
private:
    int m_top = -1;
    const int m_size = 5;
    ...
public:
    Example ( int size, int grow_by = 1 );
    ...
    ~Example();
};

...

Example::Example( int size, int grow_by )
{
    ... some code here
}

You can override the value in a constructor if you need to.