A class:
Is it wrong to do that? I'm working on my first sizable C++ project and I'm doing this for most small functions to save clutter in my .cpp files.Code:struct pos{ int x; int y; int z; pos(){} pos(int a, int b, int c){x = a;y = b;z = c;} pos(const pos& p){x = p.x;y = p.y;z = p.z;} pos operator=(pos p){x = p.x;y = p.y;z = p.z;} bool operator==(pos p) {return bool((x == p.x) && (y == p.y) && (z == p.z));} };
The more you do that, the harder it becomes to read it.
Usually, IDEs support outlining. If you want to avoid clutter, I would suggest using that instead.
Originally Posted by Adak
I would suggest:
You might also consider if the member variables should actually be private.Code:struct pos { int x; int y; int z; pos() {} // perhaps you should zero initialise the member variables? pos(int a, int b, int c) : x(a), y(b), z(c) {} bool operator==(const pos& p) const { return (x == p.x) && (y == p.y) && (z == p.z); } };
Look up a C++ Reference and learn How To Ask Questions The Smart Way
Initialize them to what? They'll just be 0, right?
Whoa... What's that called?Code:pos(int a, int b, int c) : x(a), y(b), z(c) {}
No.
Initializer list.Whoa... What's that called?Code:pos(int a, int b, int c) : x(a), y(b), z(c) {}
Effectively calls the constructor instead of assignment operator. Has little to no effect on built-in types, but on classes and complex types it can be night or day.
If you do not initialise them in the constructor, they may well have "garbage" values when the object is constructed.
Constructor and its initialisation list.
Look up a C++ Reference and learn How To Ask Questions The Smart Way
Would that work?Code:pos() : x(0), y(0), z(0) {}
EDIT: Nevermind, it works.
And... just another one to throw you for a loop, you could use default arguments to eliminate one of those constructors so you'd have just one doing the job of both:Would that work?Code:pos() : x(0), y(0), z(0) {}
EDIT: Nevermind, it works.
Code:struct pos { int x; int y; int z; pos(int a = 0, int b = 0, int c = 0) : x(a), y(b), z(c) {} }; ... pos foo1; // Creates default pos object with x/y/z initialized to 0 pos foo2(1,2,3); // Create pos object with x/y/z initialized to 1/2/3 pos foo3(4,5); // Create pos object with x/y/z initialized to 4/5/0 pos foo4(6); // Create pos object with x/y/z initialized to 6/0/0
"Owners of dogs will have noticed that, if you provide them with food and water and shelter and affection, they will think you are god. Whereas owners of cats are compelled to realize that, if you provide them with food and water and shelter and affection, they draw the conclusion that they are gods."
-Christopher Hitchens
One catch with hk_mp5kpdw's suggestion is that you can then write:
unless you declare that constructor as explicit.Code:pos foo5 = 7;
Look up a C++ Reference and learn How To Ask Questions The Smart Way
Which would be used with pos_t(1)?Code:struct pos_t{ int x, y, z; pos_t(int a) : x(a), y(a), z(a) {} explicit pos_t(int a = 0, int b = 0, int c = 0) : x(a), y(b), z(c) {} };
Why not try it?
Sorry. I wasn't close to being able to debug at the time.
call of overloaded ‘pos_t(int)’ is ambiguous
Yes, that's what I figured. Your first constructor is redundant.
