Quote:Original post by Mco
If so what is the difference doing it the first way?

The first version initializes the members with the provided value. The second version initializes the members with default values, and then assigns the provided value to them.

There's a couple of reasons to use initializer lists instead of assigning in the constructor's body:

1) Clarity, it's clearer and more concise that you're perform initialisation and you don't have to worry about prefixing everything with 'this.' if your parameter names are the same as your member variable names (eg: IvVector3::IvVector3(float x, float y, float z) : x(x), y(y), z(z) { })

2) Performance, assigning in the constructor's body means that the member variables are first default constructed, then assigned (using IvVector3::IvVector3() and IvVector3::operator=(const &IvVector3& v) respectively). With builtin types this won't make any difference, but for custom types with non-trivial/expensive constructors this double initialisation can hurt you performance-wise.

There's also reason the not use the initialiser list:

1) You cannot initialise arrays in the initialiser list, the syntax just doesn't exist in C++.

2) If you want to pass 'this' to a member variable's constructor. While allowed you can run into problems if the member's constructor tries to use the 'this' pointer immediately as your object may not have finished initialising yet.

3) If you want to pass a member variable into another member variables's constructor. Member variable's aren't constructed in the order they appear in the initialiser list, but rather in the order they're declared in the class. So again, while this is allowed it's usually a good idea to avoid it.

For example:

class MyClass{    C c;    B b;    A a;public:    MyClass() : a(), b(this), c(b) { }    void Func() { a.Func(); }};

This might seem OK by looking at the constructor, but the order of initialisation is really c(b), b(this), a(). C's constructor will be getting passed an uninitialised 'b', and if B's constructor tries to call this->Func() it'll end up calling A::Func() with an uninitialised 'a'.

Also, to be pedantic, that is not a function, rather it is a "constructor" which is a special method used to initialize an instance of a class or struct.

You cannot apply the member list initializer syntax to other methods or functions, only to constructors.

Quote:Original post by Zahlman
Why does seemingly noone know about such a basic language feature, ten years later?

Because they're "fairly new to c++ and slightly confused"?