Thread: Quaternion class problem

I am starting a Quaternion class, and this is what I have so far:

Code:

class Vector3D;
class Matrix3X3;
class EulerAngle;

class Quaternion {
 public:
  float x, y, z, w;

  Quaternion(float a, float b, float c, float d) : x(a), y(b), z(c), w(d) {}
/*
  Quaternion(float d, const Vector3D &v) : x(v.x), y(v.y), z(v.z), w(d) {}
*/
  Quaternion(const Quaternion &q) : x(q.x), y(q.y), z(q.z), w(q.w) {}

 ~Quaternion() {}
};

EVERY file is included. When you uncomment the second constructor, i get 3 errors (edited a bit):
1. x is not a member of Vector3D, as the type is not yet defined in the second contructor.
2. y is not a member of Vector3D, as the type is not yet defined in the second contructor.
3. z is not a member of Vector3D, as the type is not yet defined in the second contructor.

x, y, and z are all public. Any ideas on the problem? Thanks .

They are in different files, and it isnt a problem in other files.

I HAVE included other files, and in other classes I do the same thing, with no problems.

This is the complete header, the only compilation problem is the one I was talking about:

Code:

#ifndef __QUATERNION_H_INCLUDED__
#define __QUATERNION_H_INCLUDED__
#include <cmath>
#include "matrix.h"
#include "vector.h"
#include "euler.h"
using namespace std;

class Vector3D;
class Matrix3X3;
class EulerAngle;

class Quaternion {
 public:
  float x, y, z, w;

  Quaternion(float a, float b, float c, float d) : x(a), y(b), z(c), w(d) {}

  Quaternion(float d, const Vector3D &v) : x(v.x), y(v.y), z(v.z), w(d) {}

  Quaternion(const Quaternion &q) : x(q.x), y(q.y), z(q.z), w(q.w) {}

  ~Quaternion() {}

  const Quaternion operator*(float m) const;
  const Quaternion operator/(float m) const;
  Quaternion &operator*=(float m);
  Quaternion &operator/=(float m);
  bool operator==(const Quaternion &q) const;
  bool operator!=(const Quaternion &q) const;

  float length() const;
  Quaternion normalize() const;
  Quaternion conjugate() const;
};

#endif

And no, none of my classes are templates.

I removed them, and got these errors:

Is what declared in vector.h? Vector3D? Yes, most definetly!

Vector.h:

Code:

#ifndef __VECTOR3D_H_INCLUDED__
#define __VECTOR3D_H_INCLUDED__
#include <cmath>
#include "matrix.h"
#include "euler.h"
#include "quaternion.h"
using namespace std;

class Matrix3X3;
class Quaternion;
class EulerAngle;

class Vector3D {
 public:
  float x, y, z;

/*Constructors / Deconstructors:
 Vector3D v: x, y, and z are all undefined.
 Vector3D v2(1, 2, 3): x, y, and z are set to 1, 2, and 3, respectivly.
 Vector3D v3(Vector3D v4): v3.x, v3.y, and v3.z are all set to v4.x, v4.y, and v4.z, respectivly.
 ~Vector3D(): Deconstructs the vector.
*/
  Vector3D() {}

  Vector3D(float a, float b, float c) : x(a), y(b), z(c) {}

  Vector3D(const Vector3D &v) : x(v.x), y(v.y), z(v.z) {}

  ~Vector3D() {}

/*Operator overloadings:
 Vector3D operator+(const Vector3D &v): x, y, and z are added to v.x, v.y, and v.z, respectivly.
 Vector3D operator-(const Vector3D &v): x, y, and z are subtracted from v.x, v.y, and v.z, respectivly.
 Vector3D operator*(float w): x, y, and z are all multiplied by w.
 Vector3D operator/(float w): x, y, and z are all divided by w.
 Vector3D operator-(): negate the vector - x, y, and z are set to -x, -y, and -z, respectivly
 Vector3D &operator+=(const Vector3D &v): x, y, and z are added to v.x, v.y, and v.z, respectivly, and vector is set with new values.
 Vector3D &operator-=(const Vector3D &v): x, y, and z are subtracted from v.x, v.y, and v.z, respectivly, and vector is set with new values.
 Vector3D &operator*=(float w): x, y, and z are all multiplied by w, and vector is set with new values.
 Vector3D &operator/=(float w): x, y, and z are all divided by w, and vector is set with new values.
 Vector3D &operator=(const Vector3D &v): this vector is set to v.
 bool operator==(const Vector3D &v): returns true if Vector3Ds' are equal, false otherwise.
 bool operator!=(const Vector3D &v): returns true if Vector3Ds' are not equal, false otherwise.
*/
  const Vector3D operator+(const Vector3D &v) const;
  const Vector3D operator-(const Vector3D &v) const;
  const Vector3D operator*(float w) const;
  const Vector3D operator/(float w) const;
  Vector3D operator-() const;
  Vector3D &operator+=(const Vector3D &v);
  Vector3D &operator-=(const Vector3D &v);
  Vector3D &operator*=(float w);
  Vector3D &operator/=(float w);
  Vector3D &operator=(const Vector3D &v);
  bool operator==(const Vector3D &v) const;
  bool operator!=(const Vector3D &v) const;

/*Other functions:
 float length(): returns the length of the vector.
 Vector3D normalize(): normalize the vector, vector / length of vector
 float dotProduct(const Vector3D &v): returns the dotProduct, x * v.x + y * v.y + z * v.z
 Vector3D crossProduct(const Vector3D &v): returns cross product between this vector and v.
 float distance(const Vector3D &v): returns distance between this vector and v.
 float angleBetween(const Vector3D &v): returns the angle (in radians) between the 2 vectors.
*/
  float length() const;
  Vector3D normalize() const;
  float dotProduct(const Vector3D &v) const;
  Vector3D crossProduct(const Vector3D &v) const;
  float distance(const Vector3D &v) const;
  float angleBetween(const Vector3D &v) const;
};

#endif

This is euler.h, and it compiles without error:

Code:

#ifndef __EULER_H_INCLUDED__
#define __EULER_H_INCLUDED__
#include <cmath>
#include "matrix.h"
#include "vector.h"
#include "quaternion.h"
using namespace std;

class Vector3D;
class Matrix3X3;
class Quaternion;

class EulerAngle {
 public:
  float h, p, b;

/*Constructors / Deconstructors:
 EulerAngle e: all variables are undefined.
 EulerAngle e2(1, 2, 3): heading is set to 1, pitch is set to 2, bank is set to 3.
 EulerAngle e3(Vector3D v): h is set to v.x, p is set to v.y, and b is set to v.z.
 EulerAngle e4(EulerAngle e): h, p, and b are set to e.h, e.p, and e.b, respectivly.
*/
  EulerAngle(float a, float b, float c) : h(a), p(b), b(c) {}

  EulerAngle(const Vector3D &v) : h(v.x), p(v.y), b(v.z) {}

  EulerAngle(const EulerAngle &ea) : h(ea.h), p(ea.p), b(ea.b) {}

  ~EulerAngle() {}
};

#endif

Ahhhhhh, yay . Thanks, I'm EXTREMELY grateful .