C ++ 0x指定的初始化程序

Question

I could find a way to do Designated Initializers in C++0x with only one member initializing. Is there a way for multiple member initializing ?

public struct Point3D
{
    Point3D(float x,y) : X_(x) {}
    float X;
};

I want :

public struct Point3D
{
    Point3D(float x,y,z) : X_(x), Y_(y), Z_(z) {}
    float X_,Y_,Z_;
};

Answer 1

You have a few mistakes in your constructor, here is how you should write it:

/* public */ struct Point3D
// ^^^^^^ 
// Remove this if you are writing native C++ code!
{
    Point3D(float x, float y, float z) : X_(x), Y_(y), Z_(z) {}
    //               ^^^^^    ^^^^^
    //               You should specify a type for each argument individually
    float X_;
    float Y_;
    float Z_;
};

Notice, that the public keyword in native C++ has a meaning which is different from the one you probably expect. Just remove that.

Moreover, initialization lists (what you mistakenly call "Designated Initializers") are not a new feature of C++11, they have always been present in C++.

Answer 2

@Andy explained how you should be doing this if you're going to define your own struct .

However, there is an alternative:

#include <tuple>

typedef std::tuple<float, float, float> Point3D;

and then define some function as:

//non-const version
float& x(Point3D & p) { return std::get<0>(p); }
float& y(Point3D & p) { return std::get<1>(p); }
float& z(Point3D & p) { return std::get<2>(p); }

//const-version
float const& x(Point3D const & p) { return std::get<0>(p); }
float const& y(Point3D const & p) { return std::get<1>(p); }
float const& z(Point3D const & p) { return std::get<2>(p); }

Done!

Now you would use it as:

Point3D p {1,2,3};
x(p) = 10; // changing the x component of p!
z(p) = 10; // changing the z component of p!

Means instead of px , you write x(p) .

Hope that gives you some starting point as to how to reuse existing code.