I am encountering a strange issue when attempting to build my project for release mode. It works fine in debug mode, but my Vector3D object seems to be returning garbage when I am setting one vector equal to the other.

I've been wondering if it has something to do with not having a operator=, except the default one given by the compiler, but I'm not sure. It is strange. I was also initially wondering if the compiler was executing my code out of order due to release mode compiler optimizations, but then I noticed that my Vector3D was just garbage values for some reason.

This is what I am doing:

Vector3D playerPos = mainPlayer->getObjectPosition(); // Doesn't do anything in release mode (playerPos remains as garbage)
playerPos = this->WorldToScreen(&playerPos);

All that getObjectPosition() does is:

Vector3D& GameObject::getObjectPosition()
{
  return this->position;
}

Thank you for any insight you can give me on solving this issue.

Is it possible that mainPlayer->position hasn't actually been initialized at that point in the program? When I see an accessor appearing to spit out garbage in release but not debug, that's usually the first thing I check.

Also, how are you checking for these garbage values? If you're only seeing them in the debugger and the program is otherwise behaving as expected (or even if it isn't), that's not too unexpected. Very optimized code can make a debugger very confused.

I just checked, I added a std::cout statement above to check, and it is initialized to the expected result. It seems to be having issues placing the result into the Vector3D for some reason.

The problem seems to be duplicated within debug mode when I create a custom assignment operator:

Vector3D& Vector3D::operator=(const Vector3D& rhs)
{
  this->set(rhs.x, rhs.y, rhs.z);
  return *this;
}

If I get rid of that assignment operator it works fine in debug mode.

Here is some more code on what I am doing:

  float x = mainPlayer->getObjectPosition().x, y = mainPlayer->getObjectPosition().y, z = mainPlayer->getObjectPosition().z;
  std::cout << x << " | " << y << " | " << z << std::endl;
  Vector3D playerPos(x, y, z);// = mainPlayer->getObjectPosition();
  std::cout << playerPos.x << " | " << playerPos.y << " | " << playerPos.z << std::endl;
  Vector3D nPlayerPos = this->WorldToScreen(&playerPos);
  std::cout << nPlayerPos.x << " | " << nPlayerPos.y << " | " << nPlayerPos.z << std::endl; // INVALID RESULT

I was inspecting the matrices within WorldToScreen and they appeared out of order in the release mode, however, that may have just been the compiler debug mode in release confusion.

That looks fine to me given the context you've provided. What happens inside of set()? What are you expecting to see and what sort of "garbage values" are you seeing, exactly?

set() sets the x y and z component of the Vector.

void Vector3D::set(float x, float y, float z)
{
  this->x = x;
  this->y = y;
  this->z = z;
}

The value I'm expecting to see after the WorldToScreen is: | 512 | 384 | 0, which is what I get in debug mode without the custom assignment operator, but in release mode I'm getting:
| 4.57501e+013 | 2.47714e-039 | 4.26061e+013

I can't help but wonder now if the release mode is shifting my matrices around for some reason, I'm not sure tho, I don't think they would be nor how. I'll print those out to see if they are for some reason.

There definitely seems to be something wrong with my library when my project is accessing it. I call the WorldToScreen function in my library and get those invalid results, but if I pull out that code from within my library and execute it manually in my other project it produces the correct results.

Thanks for the insightful posts. It turns out the problem was definitely in the WorldToScreen function, I was returning a local variable as a reference, which I should have known not to do, but that was the problem.

I changed the function to:

Vector3D GameZone::WorldToScreen(const Vector3D& worldPos);

Instead of:

Vector3D& GameZone::WorldToScreen(const Vector3D& worldPos);