Thread: My 3D Vector class

I'm working on a test 3D engine, and have started on a 3D vector class. I'm looking for opinions, feel free to use it in your code if you wish (probably not enough there to use anyway :p ) . *NOTE: If this is in the wrong place, please tell me where to move it :D .* Also, this is not completed, so please don't yell at me for that :) . If something is wrong, PLEASE correct me. Anyway, here it is:

Code:

/*
The Vector3D class: represents a 3 dimensional vector. Only has 3 variables: x, y, and z for displacement.
*/

class Vector3D {
 public:

/*Variables:
 I didn't make x, y, and z private, as the programmer should already know the inner workings of a vector,
and would figure that there would be an x, y, and z variables. Plus, I hate the look of setX(int x) and getX() :D .
*/
  double x, y, z;

/*Constructors:
 Vector3D v: x, y, and z are all set to 0.
 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() {
   x = y = z = 0;
  }

  Vector3D(double a, double b, double c) {
   x = a;
   y = b;
   z = c;
  }

  Vector3D(const Vector3D &v) {
   x = v.x;
   y = v.y;
   z = v.z;
  }

/*Operator overloadings:
 Vector3D operator+(Vector v): x, y, and z are added to v.x, v.y, and v.z, respectivly.
 Vector3D operator-(Vector3D v): x, y, and z are subtracted from v.x, v.y, and v.z, respectivly.
 Vector3D operator*(double w): x, y, and z are all multiplied by w.
 Vector3D operator/(double w): x, y, and z are all divided by w.
 Vector3D operator=(Vector3D v): this vector is set to v.
*/
  Vector3D operator+(Vector3D v);
  Vector3D operator-(Vector3D v);
  Vector3D operator*(double w);
  Vector3D operator/(double w);
  Vector3D operator=(Vector3D v);

/*Other functions:
 void negate(): negate the vector - x, y, and z are set to -x, -y, and -z, respectivly
 double length(): returns the length of the vector.
 void normalize(): normalize the vector, vector / length of vector
*/
  void negate();
  double length();
  void normalize();
};

Vector3D Vector3D::operator+(Vector3D v) {
 return Vector3D((x + v.x), (y + v.y), (z + v.z));
}

Vector3D Vector3D::operator-(Vector3D v) {
 return Vector3D((x - v.x), (y - v.y), (z - v.z));
}

Vector3D Vector3D::operator*(double w) {
 return Vector3D((x * w), (y * w), (z * w));
}

Vector3D Vector3D::operator/(double w) {
 return Vector3D((x / w), (y / w), (z / w));
}

Vector3D Vector3D::operator=(Vector3D v) {
 x = v.x;
 y = v.y;
 z = v.z;
 return *this;
}

void Vector3D::negate() {
 x = -x;
 y = -y;
 z = -z;
}

double Vector3D::length() {
 return sqrt((x * x) + (y * y) + (z * z));
}

void Vector3D::normalize() {
 x /= length();
 y /= length();
 z /= length();
}