Constructors : What does this statement mean?

It is one way in which member variables can be initialized from within the constructor. It is really no different than writing the constructor this way.

myclass(int num1, int num2)
{
   my1 = num1;
   my2 = num2;
}

The list following the ':' after the constructor parameter list is called initializer list or initialization list. It is a comma-separated list of 'initializers', where each item defines the intialization of either a member variable of the class, or a base class of the class. In case of a member variable, the name of the variable is followed by a single argument (in brackets) that is used to construct the variable via copy-construction. In case of a base class, a variable length argument list (again, in brackets) may be passed that corresponds to any constructor definition of that base class.

Also, the order of initialization may depend on what you put in the initializer list (but I think this does not affect member variables). I can't pinpoint the article I once downloaded about that, but IIRC the order of construction is:
1. virtual base classes
2. base classes (closest level first)
3. member variables

I'm not sure about 1. and 2. but I'm quite sure member variables in initializer lists are always initialized last, i. e. you can use data and functions from your base classes for the purpose of initializing your member variables in the initialization list.

That said, it's probably better not to do anything that depends on the order of initialization, if only to not confuse your colleagues ;)

Most often it doesn't matter whether you use member initializer lists or assignments inside the body of your constructor. For example in your case you can perform the initialization of your int members from both the initializer list and the body of your constructor. However sometimes you can intialize a member only from the initializer list, and sometimes you HAVE TO explicitly initialize some members in the initializer list if you don't want to get a compile error!

class class_with_default_ctor
{
public:
    // this can act as a default ctor
    class_with_default_ctor(int _i=0)
        : i(_i)
    {}

    int i;
};

class class_without_default_ctor
{
public:
    class_without_default_ctor(int _i)
        : i(_i)
    {}

    int i;
};

class something
{
};

class test
{
public:
    test(something& sg)
        // You don't have to initialize m_class_with_default here but
        // you can do that if the default constructor doesn't do what
        // you want and other constructors are available. If you
        // don't call a default constructor here explicitly then
        // the compiler automatically calls the default constructor
        // of the class before the body of your ctor is executed so
        // later modifying the value of m_class_with_default in the
        // body of your constructor means that you initialize twice:
        // once by calling its default constructor and then when you
        // change it. You can avoid this double initialization by
        // explicitly calling a different constructor from the
        // initializer list, you can't do this from the ctor body.
        : m_class_with_default(5)
        // The following initializations are all MANDATORY and they
        // can be performed only from the initializer list! Not
        // initializing any of these from the initializer list leads
        // to a compile error!
        , m_class_without_default(6)
        , m_const_int(7)
        , m_const_something_ref(sg)
        , m_something_ref(sg)
    {
    }

private:
    class_with_default_ctor m_class_with_default;
    class_without_default_ctor m_class_without_default;
    const int m_const_int;
    const something& m_const_something_ref;
    something& m_something_ref;
};

You also HAVE TO use the initializer list to initialize a base class that doesn't have a default constructor if you don't want a compile error and you may want to use it to execute something else than the default ctor of the base class (same as with the member variables).