# C plus plus:Tutorials:Vectors

A general-purpose templated two-dimensional vector in C++. Supports most operations you'd expect in a vector. The internal array representation is meant to make passing it to OpenGL easier. Just do for example glVertex2iv(my_vector_var).

There is also an alternate version of a math vector.

```#ifndef VECTOR2_HPP
#define VECTOR2_HPP

#include <cmath>
#include <iosfwd>

template<class T>
class Vector2
{
public:
Vector2()
{
set(T(), T());
}
Vector2(T new_x, T new_y)
{
set(new_x, new_y);
}
explicit Vector2(T value)
{
set(value, value);
}

void set(T new_x, T new_y)
{
x() = new_x;
y() = new_y;
}

T& x(){return _c[0];}
T& y(){return _c[1];}
T x() const{return _c[0];}
T y() const{return _c[1];}

void operator=(T value)
{
set(value, value);
}

void operator+=(const Vector2& other)
{
set(x() + other.x(), y() + other.y());
}
void operator-=(const Vector2& other)
{
set(x() - other.x(), y() - other.y());
}
void operator*=(T factor)
{
set(x() * factor, y() * factor);
}
void operator/=(T factor)
{
set(x() / factor, y() / factor);
}

T lengthSquared() const
{
return x()*x() + y()*y();
}
T length() const
{
return std::sqrt(lengthSquared());
}
void normalize()
{
operator/=(length());
}
void invert()
{
x() = -x();
y() = -y();
}

operator const T*() const
{
return _c;
}

template <class U>
Vector2<U> convert() const
{
return Vector2<U>(static_cast<U>(x()), static_cast<U>(y()));
}

private:
T _c[2];
};

template<class T>
inline const Vector2<T> operator+(const Vector2<T>& one, const Vector2<T>& two)
{
return Vector2<T>(one.x() + two.x(), one.y() + two.y());
}
template<class T>
inline const Vector2<T> operator-(const Vector2<T>& one, const Vector2<T>& two)
{
return Vector2<T>(one.x() - two.x(), one.y() - two.y());
}
template<class T>
inline const Vector2<T> operator-(const Vector2<T>& one)
{
return Vector2<T>(-one.x(), -one.y());
}
template<class T>
inline const Vector2<T> operator*(const Vector2<T>& one, T factor)
{
return Vector2<T>(one.x() * factor, one.y() * factor);
}
template<class T>
inline const Vector2<T> operator*(T factor, const Vector2<T>& one)
{
return Vector2<T>(one.x() * factor, one.y() * factor);
}
template<class T>
inline const Vector2<T> operator/(const Vector2<T>& one, T factor)
{
return Vector2<T>(one.x() / factor, one.y() / factor);
}

template<class T>
inline T operator*(const Vector2<T>& one, const Vector2<T>& two){ //dotproduct
return one.x() * two.x() + one.y() * two.y();
}

template<class T>
inline bool operator==(const Vector2<T>& one, const Vector2<T>& two)
{
return one.x() == two.x() and one.y() == two.y();
}
template<class T>
inline bool operator!=(const Vector2<T>& one, const Vector2<T>& two)
{
return !(one == two);
}

template<class T>
std::ostream& operator<<(std::ostream& os, const Vector2<T>& vec)
{
os << '(' << vec.x() << ',' << ' ' << vec.y() << ')';
return os;
}

typedef Vector2<float> Vector2f;
typedef Vector2<int> Vector2i;
typedef Vector2<size_t> Vector2u;

#endif //VECTOR2_HPP```

And it's three-dimensional brother.

```#ifndef VECTOR3_HPP
#define VECTOR3_HPP

#include <iosfwd>
#include <cmath>

template <class T>
class Vector3
{
public:
Vector3()
{
set(T(), T(), T());
}
Vector3(T new_x, T new_y, T new_z)
{
set(new_x, new_y, new_z);
}
explicit Vector3(T value)
{
set(value, value, value);
}

void set(T new_x, T new_y, T new_z)
{
x() = new_x;
y() = new_y;
z() = new_z;
}

T& x(){return _c[0];}
T& y(){return _c[1];}
T& z(){return _c[2];}
T x() const{return _c[0];}
T y() const{return _c[1];}
T z() const{return _c[2];}

void operator=(T value)
{
set(value, value, value);
}

void operator+=(const Vector3& other)
{
set(x() + other.x(), y() + other.y(), z() + other.z());
}
void operator-=(const Vector3& other)
{
set(x() - other.x(), y() - other.y(), z() - other.z());
}
void operator*=(T factor)
{
set(x() * factor, y() * factor, z() * factor);
}
void operator/=(T factor)
{
set(x() / factor, y() / factor, z() / factor);
}

T lengthSquared() const
{
return x()*x() + y()*y() + z()*z();
}
T length() const
{
return std::sqrt(lengthSquared());
}
void normalize()
{
operator/=(length());
}
void invert()
{
x() = -x();
y() = -y();
z() = -z();
}

operator const T*() const
{
return _c;
}

template <class U>
Vector3<U> convert() const
{
return Vector3<U>(static_cast<U>(x()), static_cast<U>(y()), static_cast<U>(z()));
}

private:
T _c[3];
};

template <class T>
inline const Vector3<T> operator+(const Vector3<T>& one, const Vector3<T>& two)
{
return Vector3<T>(one.x() + two.x(), one.y() + two.y(), one.z() + two.z());
}
template <class T>
inline const Vector3<T> operator-(const Vector3<T>& one, const Vector3<T>& two)
{
return Vector3<T>(one.x() - two.x(), one.y() - two.y(), one.z() - two.z());
}
template <class T>
inline const Vector3<T> operator-(const Vector3<T>& one)
{
return Vector3<T>(-one.x(), -one.y(), -one.z());
}
template <class T>
inline const Vector3<T> operator*(const Vector3<T>& one, T factor)
{
return Vector3<T>(one.x() * factor, one.y() * factor, one.z() * factor);
}
template <class T>
inline const Vector3<T> operator*(T factor, const Vector3<T>& one)
{
return Vector3<T>(one.x() * factor, one.y() * factor, one.z() * factor);
}
template <class T>
inline const Vector3<T> operator/(const Vector3<T>& one, T factor)
{
return Vector3<T>(one.x() / factor, one.y() / factor, one.z() / factor);
}

template <class T>
inline T operator*(const Vector3<T>& one, const Vector3<T>& two){ //dotproduct
return one.x()*two.x() + one.y()*two.y() + one.z()*two.z();
}
template <class T>
inline T boundedDot(const Vector3<T>& one, const Vector3<T>& two)
{
T dot = one * two;
if (dot < 0)
return 0;
if (dot > 1)
return 1;
return dot;
}
template <class T>
inline Vector3<T> operator%(const Vector3<T>& one, const Vector3<T> two){ //crossproduct
return Vector3<T>(one.y()*two.z() - one.z()*two.y(), one.z()*two.x() - one.x()*two.z(),
one.x()*two.y() - one.y()*two.x());
}

template <class T>
inline Vector3<T> normalize(const Vector3<T>& vec){return vec / vec.length();}

template <class T>
inline bool operator==(const Vector3<T>& one, const Vector3<T>& two)
{
return one.x() == two.x() and one.y() == two.y() and one.z() == two.z();
}
template <class T>
inline bool operator!=(const Vector3<T>& one, const Vector3<T>& two)
{
return !(one == two);
}

template<class T>
std::ostream& operator<<(std::ostream& os, const Vector3<T>& vec)
{
os << '(' << vec.x() << ',' << ' ' << vec.y() << ',' << ' ' << vec.z() << ')';
return os;
}

typedef Vector3<float> Vector3f;
typedef Vector3<int> Vector3i;
typedef Vector3<size_t> Vector3u;

#endif //VECTOR3_HPP```