Struct Question

Hey,

What if I wanted a constructor that would take arguments to define its internals, but sometimes I didn't want to define the internals such as in a header.

ex:

Code:

---

struct Vector3{
  Vector3(float x, float y, float z);
  float X, Y, Z;
};

---

Now that works as I had hoped to set all the varables in one statement, but in a class declaration I really don't want to set the variables until its constructor definition.

I was told a long time ago to only declare in a .h and only define in .cpp so when doing something like.

Code:

---

class Camera{
  private:
    Vector3 Location;  // trying to not define here but my above example requires it
  public:
    Camera(Vector3 location); // or here
};

---

I know I'm missing something simple. Thanks for your time!

Code:

---

struct Vector3{
  Vector3();
  Vector3(float x, float y, float z);
  float X, Y, Z;
};

---

seemed to work by my compiler, but will this behave properly?

If I understand your question correctly, yes, your second iteration should work the way you expect. Also, it's not required to declare in .h and define in .cpp. In fact, you could write your entire project in either .h or .cpp with no problems. The only reason the two exist separately is to make code clearer, more organized, and easier to maintain. It's preferred that you use the two extensions as described, but definately not required.

Why would you wish to create a Vector with uninitialised members? The only thing you can usefully do with it is initialise the members (anything access of the value of an uninitialised member gives undefined behaviour).

Quote:

---

Why would you wish to create a Vector with uninitialised members? The only thing you can usefully do with it is initialise the members (anything access of the value of an uninitialised member gives undefined behaviour).

---

Yea I realized I was leaving that hole open and that was where I was concerned about the method.

I initialize everything a class owns inside its constructor religiously thats why initializing in the declaration was annoying me. I only want to adjust the code in one place if I want the defaults of that class to change rather than changing some in the .cpp and some in the .h.

I am also passing large amounts of floats between functions and wrapping them up in Vectors Lets me use the same X, Y, Z description while still talking about many different things.

Since the struct doesn't require you to initialize it I made the classes that own vectors require you to pass them values in their constructors.

I realize I could probably also add a boolean called Initialized that is set as false in the constructor with no arguments, and set as true inside the constructor that initializes and then just check this boolean before accessing (but I figured that would be tedious so I stuck with the class requiring arguments in its constructor).

There is probably a better method, but I think I closed off the hole for undefined behavior.

Quote:

---

Why would you wish to create a Vector with uninitialised members? The only thing you can usefully do with it is initialise the members (anything access of the value of an uninitialised member gives undefined behaviour).

---

Yea I realized I was leaving that hole open and that was where I was concerned about the method.

I initialize everything a class owns inside its constructor religiously thats why initializing in the declaration was annoying me. I only want to adjust the code in one place if I want the defaults of that class to change rather than changing some in the .cpp and some in the .h.

I am also passing large amounts of floats between functions and wrapping them up in Vectors Lets me use the same X, Y, Z description while still talking about many different things.

Since the struct doesn't require you to initialize it I made the classes that own vectors require you to pass them values in their constructors.

I realize I could probably also add a boolean called Initialized that is set as false in the constructor with no arguments, and set as true inside the constructor that initializes and then just check this boolean before accessing (but I figured that would be tedious so I stuck with the class requiring arguments in its constructor).

There is probably a better method, but I think I closed off the hole for undefined behavior.

Code:

---

Vector3::Vector3(){
  X = 0.0f;
  Y = 0.0f;
  Z = 0.0f;
}

---

also works.

Then why not use default arguments?

Quote:

---

Then why not use default arguments?

---

Wouldn't I lose the functionality of being able to initialize a Vector3 within a function call that requires a Vector3?

What do you think this does?

Code:

---

void SomeFunc(const Vector3 &);

int main()
{
    SomeFunc(Vector3());
}

---

This would work whether Vector3 has a constructor with no arguments, or it has multiple arguments each with a default value.

I think I lost you. I just read that c++11 allows non-static data member initializers, should I just assign the defaults in the declaration?

I did all this to get around doing that as I had been told it was bad practice.

Unless you know very clearly and precisely what you have been informed is bad practice, and why, then just forget it.
Half understood advice is often of less value than being ignorant of it.
Just do what you want to do and post the code, then we can tell you exactly what is good or bad.

Quote:

---

Unless you know very clearly and precisely what you have been informed is bad practice, and why, then just forget it.
Half understood advice is often of less value than being ignorant of it.

---

Alright so its not as big a deal as I treated it, though it has, over the years, become part of my coding style. Initializing every variable of a class inside it's constructor has as well.

Quote:

---

Just do what you want to do and post the code, then we can tell you exactly what is good or bad.

---

Its a glut/openGL program with a couple hundred lines of code I really felt like it would be rude to request ya'll to read through hundreds of lines of code when the struct was the only thing in question.

I also was worried someone would tell me that Glut wasn't purely native C++ code, but if you are curious I attached the source code. I put it all in one file with declarations at the top and definitions at the bottom.

Requires: -lglut -lGLU and -std=c++11 to compile.

The way I understand the standard for this feature is that if non-static data member initialization is present, and constructor initialization is present, then the non-static data member initialization doesn't even take place. I have to admit not liking the feature very much, but the use that makes the most sense to me is when data members which are frequently initialized to the same things. You may need to provide a constructor where these members are conspicuously absent and another one where they are included so they can be called according to whatever whim. It isn't really about choosing one way or another way. What I would avoid is writing a default constructor if you were going to use this feature, because it is redundant.

Quote:

---

Originally Posted by Lesshardtofind

Hey,

What if I wanted a constructor that would take arguments to define its internals, but sometimes I didn't want to define the internals such as in a header.

---

This question makes absolutely no sense. What does a header have to do with anything?

Quote:

---

Now that works as I had hoped to set all the varables in one statement, but in a class declaration I really don't want to set the variables until its constructor definition.

I was told a long time ago to only declare in a .h and only define in .cpp so when doing something like.

Code:

---

class Camera{
  private:
    Vector3 Location;  // trying to not define here but my above example requires it
  public:
    Camera(Vector3 location); // or here
};

---

I know I'm missing something simple. Thanks for your time!

---

Neither place requires you do anything. The member variable declaration doesn't need an initializer (and until C++11, cannot have one), and the constructor declaration doesn't need one either.

The constructor definition is a different matter, but you can put that in a .cpp file.

Code:

---

Camera::Camer(Vector3 location) : Location(location) {}

---

Quote:

---

Neither place requires you do anything. The member variable declaration doesn't need an initializer (and until C++11, cannot have one), and the constructor declaration doesn't need one either.

---

My compiler begged to differ saying no constructor in Vector3 matches a constructor with 0 arguments, until I added the no argument constructor. (Maybe because I have -std=c++11?) As far as why? I explained that twice and Imalc answered that I was originally informed of something that did not matter much.

Quote:

---

My compiler begged to differ saying no constructor in Vector3 matches a constructor with 0 arguments

---

Not about the code you posted. The code you posted was perfectly fine. The problem is in the way you implement constructors:

Code:

---

Camera::Camera(float angle, Vector3 center, Vector3 Los){
  Angle = angle;
  Center = center;
  VectorLOS = Los;
}

---

This is wrong. You should always use constructor initializers when you can. The problem here is that it first tries to default-initialize the vectors (but can't, because there is no default constructor) and then reassigns them. This constructor should look like this:

Code:

---

Camera::Camera(float angle, Vector3 center, Vector3 Los)
  : Angle(angle), Center(center), VectorLOS(Los)
{}

---

This will work without giving Vector3 a default constructor. It can also save typing by removing the component-wise assignment you sometimes do.

Code:

---

Triangle::Triangle(Vector3 center, float width, float height)
  Center(center), Width(width), Height(height)
{}

---

For that matter, why do you ever do a component-wise assignment?

Code:

---

void Triangle::MoveTo(Vector3 newCenter){
  //Center.X = newCenter.X;
  //Center.Y = newCenter.Y;
  //Center.Z = newCenter.Z;
  Center = newCenter;
}

---

The last triangle was from the first tutorial, and before I added the Vector3 constructor, I will change it.

Thanks for the information about the constructors though I don't understand exactly what you are saying if I just did it without writing a 3 argument constructor I would not be able to do this...

Code:

---

Triangle ThisTriangle(Vector3(0.0f, 0.0f, 10.0f), 1.0f, 1.0f);

---

Which was the whole reason I added the constructor.

I will definitely adjust the class initializations to the way you suggested. Mind if I ask what scenario would break my implementation?

Quote:

---

Originally Posted by Lesshardtofind

The last triangle was from the first tutorial, and before I added the Vector3 constructor, I will change it.

Thanks for the information about the constructors though I don't understand exactly what you are saying if I just did it without writing a 3 argument constructor I would not be able to do this...

Code:

---

Triangle ThisTriangle(Vector3(0.0f, 0.0f, 10.0f), 1.0f, 1.0f);

---

Which was the whole reason I added the constructor.

---

The 3-arg constructor is fine. I'm saying that you don't really need the 0-arg constructor.

Quote:

---

I will definitely adjust the class initializations to the way you suggested. Mind if I ask what scenario would break my implementation?

---

Well, as you found out, with the implementation you have, you need the 0-arg constructor. There's also the chance that it's a bit slower. (Depends on the inlining and dead store elimination behavior of your compiler, really.) Also, if you ever have a const member, there is no other way to initialize it.

In the end it's simply good, idiomatic C++ to use the constructor initializers.

You need to expicitly write the default constructor if you:
A. Use it (intentionally or not), and
B. The class has other constructors which suppresses creation of the default contructor.

Definitely use constructor initialisation lists where you can.

Quote:

---

Originally Posted by iMalc

You need to expicitly write the default constructor if you:
A. Use it (intentionally or not), and
B. The class has other constructors which suppresses creation of the default contructor.

---

B2. or the compiler-generated default constructor doesn't do what you want (e.g. value-initialize built-in types - the compiler-generated default constructor leaves them uninitialized).

You either need to specify a default location in the declaration of the constructor, or to declare (and define) a constructor with no arguments.

There are some exceptions, generation of the no-argument constructor by the compiler is suppressed if you supply another constructor.