The following code works on my machine, but is it good practice / guaranteed to work?
struct MyStruct {
MyStruct(int x, int y, int z) :
x(x),
y(y),
z(z) {
}
int x;
int y;
int z;
};
Specifically, is x(x) guaranteed to do what I want? (that is, does the variable in an initialization list always look at that struct/class' member?)
I don't want to use leading or trailing underscores since x is a public member of the struct.
Thanks!
Yes, that is guaranteed to do what you expect.
The only thing that can exist "outside" the parentheses in an initializer list are member variables. And inside the parentheses, the usual rules apply; local variables hide member variables.
As to whether it's good practice, well, consider what happens if you accidentally remove one or more of the arguments from the constructor argument list. The code will still compile fine! But it will break horribly at runtime. Nevertheless, I still use this pattern fairly frequently.
The code will still compile fine! i tried this and i don't understand why. You said that outside the parentheses there are member variables. If a remove the argument from my constructor list, that is the local variable doesn't exist anymore. Will that mean that MyStruct(int x, int y):x(x),y(y),z(z){} will do what on the z member?While it expects what you do, imagine this situation by extension:
class MyStruct {
public:
MyStruct(int x, int y, int z)
: x(x),
y(y),
z(z)
{ }
int x() const;
int y() const;
int z() const;
private:
int x;
int y;
int z;
};
Which will not work. That's why I prefix my class members with m_. This allows very readable code with a hint to the reader that the identifier in question is part of the class. Non-prefixed identifiers are either function arguments (like in the constructor initializer list: m_x(x), or function local variables).
Yes, x(x) does exactly what you want. x(x) is a name of the member, and x(x) is a formal argument.
:-/