//
// template class for 3D vectors, plus test main
//
// input:  none.
// output:  results of using some of class's functions.
//
#include <iostream>
#include <cstdlib>		// has EXIT_SUCCESS
using namespace std;

//
// template class for 3D vectors 
//
template <typename T>		// can use "typename" or "class"
class Vector {
public:

  // ---- constructors ----

  // post:  x = init_x, y = init_y, z = init_z
  Vector(T init_x = 0, T init_y = 0, T init_z = 0) 
  {
    x = init_x; y = init_y; z = init_z;
  }

  // ---- member functions ----

  // functions to read private variables

  // post:  return value is x coordinate
  T get_x(void) const { return x; }

  // post:  return value is y coordinate
  T get_y(void) const { return y; }

  // post:  return value is z coordinate
  T get_z(void) const { return z; }

private:
  T x, y, z;
};

// ---- nonmember functions ----
// (all must be template functions)

// overloaded "+"
// post:  return value is sum of v1 and v2
template <typename T>
Vector<T> operator+ (const Vector<T> & v1, const Vector<T> & v2);

// overloaded "-"
// post:  return value is difference of v1 and v2
template <typename T>
Vector<T> operator- (const Vector<T> & v1, const Vector<T> & v2);

// overloaded "<<"
// post:  v printed to out, in the form (x, y, z)
template <typename T>
ostream & operator<< (ostream & out, const Vector<T> & v);

//
// ---- main program to test a few things ----
//
int main(void)
{
  // vectors of ints

  Vector<int> v1(1, 2, 3);
  Vector<int> v2(2, 4, 6);

  cout << "v1 = " << v1 << endl;
  cout << "v2 = " << v2 << endl;

  Vector<int> vtemp = v1 + v2;
  cout << "v1 + v2 = " << vtemp << endl;

  cout << "v1 - v2 = " << v1 - v2 << endl;

  // vectors of doubles

  Vector<double> z1(1.1, 2.2, 3.3);
  Vector<double> z2(2.2, 4.4, 6.6);

  cout << "z1 = " << z1 << endl;
  cout << "z2 = " << z2 << endl;

  Vector<double> ztemp = z1 + z2;
  cout << "z1 + z2 = " << ztemp << endl;

  cout << "z1 - z2 = " << z1 - z2 << endl;

  return EXIT_SUCCESS;
}

// ---- function implementations (see declarations for comments) ----

template <typename T>
Vector<T> operator+ (const Vector<T> & v1, const Vector<T> & v2)
{
  return Vector<T>(v1.get_x() + v2.get_x(),
		v1.get_y() + v2.get_y(),
		v1.get_z() + v2.get_z());
}

template <typename T>
Vector<T> operator- (const Vector<T> & v1, const Vector<T> & v2)
{
  return Vector<T>(v1.get_x() - v2.get_x(),
		v1.get_y() - v2.get_y(),
		v1.get_z() - v2.get_z());
}

template <typename T>
ostream & operator<< (ostream & out, const Vector<T> & v)
{
  out << "(" << v.get_x() << ", " << v.get_y() << ", "
      << v.get_z() << ")";
  return out;
}