One line functions in headers, bad?

A class:

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));}
};

---

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.

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.

I would suggest:

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);
    }
};

---

You might also consider if the member variables should actually be private.

Initialize them to what? They'll just be 0, right?

Code:

---

pos(int a, int b, int c) : x(a), y(b), z(c) {}

---

Whoa... What's that called?

Quote:

---

Originally Posted by User Name:

Initialize them to what? They'll just be 0, right?

---

No.

Quote:

---

Code:

---

pos(int a, int b, int c) : x(a), y(b), z(c) {}

---

Whoa... What's that called?

---

Initializer list.
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.

Quote:

---

Originally Posted by User Name:

Initialize them to what? They'll just be 0, right?

---

If you do not initialise them in the constructor, they may well have "garbage" values when the object is constructed.

Quote:

---

Originally Posted by User Name:

Whoa... What's that called?

---

Constructor and its initialisation list.

Code:

---

pos() : x(0), y(0), z(0) {}

---

Would that work?

EDIT: Nevermind, it works. :)

Quote:

---

Originally Posted by User Name:

Code:

---

pos() : x(0), y(0), z(0) {}

---

Would that work?

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:

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

---

One catch with hk_mp5kpdw's suggestion is that you can then write:

Code:

---

pos foo5 = 7;

---

unless you declare that constructor as explicit.

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) {}
};

---

Which would be used with pos_t(1)?

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.