N维向量的模板实现

code：

vectorBase.hpp：一些低维特化、

#include <iostream>

using namespace std;

// for any dimensions other than

// specified below, this struct will

// be used

template<class T,int N>

struct vector_base

{

T m_data[N];

};

// specialization for a 2D vector

// provides the vector with .x and .y variables

template<class T>

struct vector_base<T, 2>

{

union

{

struct

{

T x, y;

};

T m_data[2];

};

vector_base() { }

vector_base( const T& _x, const T& _y ) : x(_x), y(_y) { }

};

// specialization for a 3D vector

// provides the vector with .x, .y, and .z variables

template<class T>

struct vector_base<T,3>

{

union

{

struct

{

T x, y, z;

};

T m_data[3];

};

vector_base() { }

vector_base( const T& _x, const T& _y, const T& _z ) : x(_x), y(_y), z(_z) { }

};

// specialization for a 4D vector

// provides the vector with .w, .x, .y, and .z variables

template<class T>

struct vector_base<T,4>

{

union

{

struct

{

T w, x, y, z;

};

T m_data[4];

};

vector_base() { }

vector_base( const T& _w, const T& _x, const T& _y, const T& _z ) : w(_w), x(_x), y(_y), z(_z) { }

};

// a base for a vector that doesn't specialize vector_base

// provides the vector with .r, .g, .b, and .a variables

template<class T>

struct vector_color

{

union

{

struct

{

T r, g, b, a;

};

T m_data[4];

};

vector_color() { }

vector_color( const T& _r, const T& _g, const T& _b, const T& _a ) : r(_r), g(_g), b(_b), a(_a) { }

};

vectorTemplate.hpp

类的定义实现：

#include <cassert>

#include <cmath>

#include "vectorBase.hpp"

// the vector itself

// with its variable type: T

// its dimensions: N

// and its core: base

template<class T, int N, class base = vector_base<T,N> >

class vector_t : public base

{

public:

// handy typedef:

typedef vector_t<T,N> my_type;

// default constructor

vector_t() { }

// two-arg constructor for 2D vectors

vector_t( const T& x, const T& y ) : base(x,y) { }

// three-arg constructor for 3D vectors

vector_t( const T& x, const T& y, const T& z ) : base(x,y,z) { }

// four-arg constructor for 4D vectors

vector_t( const T& w, const T& x, const T& y, const T& z ) : base(w,x,y,z) { }

//

// Note, if the programmer tries to construct a 3D vector using a two-arg constructor,

// the compiler will complain that base does not have enough arguments. Nifty :)

//

// constructor for same-dimensional, differing-typed vectors

// use the keyword "explicit"

template<class T2, class B2>

vector_t( const vector_t<T2,N,B2>& rhs )

{

for ( int i = 0; i < N; i++ )

m_data[i] = static_cast<T>( rhs.m_data[i] );

}

// constructor with a same-dimensional array of a differing type

template<class T2>

// vector_t( const T2 data[N] )

vector_t( const T2 (&data)[N] )

{

for ( int i = 0; i < N; i++ )

m_data[i] = static_cast<T>( data[i] );

}

// assignment operation for same-dimensional, differing-typed vectors

template<class T2, class B2>

my_type& operator = ( const vector_t<T2,N,B2>& rhs )

{

for ( int i = 0; i < N; i++ )

m_data[i] = static_cast<T>( rhs.m_data[i] );

return *this;

}

// assignment operation for a an array of a differing type

template<class T2>

my_type& operator = ( const T2 data[N] )

{

for ( int i = 0; i < N; i++ )

m_data[i] = static_cast<T>( data[i] );

return *this;

}

//

// getters

//

T& operator [] ( const int idx )

{

assert( 0 <= idx && idx < N ); // or throw an exception

return m_data[ idx ];

}

const T& operator [] ( const int idx ) const

{

assert( 0 <= idx && idx < N );

return m_data[ idx ];

}

//

// overloads

//

// negation

my_type operator - () const

{

my_type result;

for ( int i = 0; i < N; i++ )

result.m_data[i] = -m_data[i];

return result;

}

// addition of two same-dimensional, differing-typed vectors

template<class T2,class B2>

my_type operator + ( const vector_t<T2,N,B2>& rhs ) const

{

my_type result;

for ( int i = 0; i < N; i++ )

result.m_data[i] = m_data[i] + rhs.m_data[i];

return result;

}

// subtraction of two same-dimensional, differing-typed vectors

template<class T2,class B2>

my_type operator - ( const vector_t<T2,N,B2>& rhs ) const

{

my_type result;

for ( int i = 0; i < N; i++ )

result.m_data[i] = m_data[i] - rhs.m_data[i];

return result;

}

// scalar multiplication of two same-dimensional, differing-typed vectors

template<class T2>

my_type operator * ( const T2& rhs ) const

{

my_type result;

for ( int i = 0; i < N; i++ )

result.m_data[i] = static_cast<T>( m_data[i] * rhs );

return result;

}

// scalar division of two same-dimensional, differing-typed vectors

template<class T2>

my_type operator / ( const T2& rhs ) const

{

my_type result;

for ( int i = 0; i < N; i++ )

result.m_data[i] = m_data[i] / rhs;

return result;

}

//

// operations:

//

// calculate the dot product of two differing-typed vectors

template<class T2,class B2>

T dot( const vector_t<T2,N,B2>& rhs ) const

{

T result = static_cast<T>( 0 );

for ( int i = 0; i < N; i++ )

result += static_cast<T>( m_data[i] * rhs.m_data[i] );

return result;

}

// squared length of the vector

T length_sq() const

{

return this->dot( *this );

}

// length of the vector

T length() const

{

return std::sqrt( this->dot( *this ) );

}

// return a normalized vector

my_type normalize() const

{

return *this / this->length();

}

// and for other operations not mentioned,

// you can provide a functor to do the rest

template<class F>

my_type predicate( const F& f ) const

{

my_type result;

for ( int i = 0; i < N; i++ )

result.m_data[i] = f( m_data[i] );

return result;

}

};

// handy write to ostream function:

template<class T, int N, class B>

std::ostream& operator << ( std::ostream& out, const vector_t<T,N,B>& v )

{

for ( int i = 0; i < N; i++ )

out << v.m_data[ i ] << ' ';

return out;

}

测试程序：

main.cpp

#include "TemplateFunctionVector.hpp"

#include "vectorTemplate.hpp"

int main( int c, char* v[] )

{

//

// the vector_t declaration is already looking ugly,

// provide some typedefs:

//

// simple geometric types:

typedef vector_t<double,2> v2;

typedef vector_t<int,2> v2i;

// graphics specific color types:

typedef unsigned char ui8;

typedef vector_t<float, 4, vector_color<float> > colorf;

typedef vector_t<int, 4, vector_color<int> > colori;

typedef vector_t<ui8, 4, vector_color<ui8> > color;

//

// begin some tests:

//

//

// test 1:

//

{

std::cout << "test1:/n";

v2 pt1_d = v2( 3.0, 3.0 );

v2i pt2_i( 1, 2 );

v2 pt2 = (pt1_d + pt2_i) * 0.5;

std::cout << pt2 << "/n/n";

}

//

// test 2:

//

{

std::cout << "test2:/n";

// v2 pt1 = v2( 1.0, 2.0, 3.0 ); // C2661: no overloaded function takes three arguments

v2 pt1 = v2( 1.0, 2.0 );

v2i pt2i = v2i( 3, 4 );

v2 pt3( pt1 ); // test copy constructor

std::cout << pt3 << '/n';

pt3 = pt1; // test assignment operator

std::cout << pt3 << '/n';

pt3 = pt2i; // test assignment operator

std::cout << pt3 << '/n';

pt3.y = pt3.x; // test aliases

std::cout << "/n/n";

}

//

// test 3:

//

{

std::cout << "test3:/n";

colorf my_color( 0.0, 1.0, 0.5, 1.0 );

std::cout << my_color << '/n';

// test alias:

my_color.r = 0.25;

std::cout << my_color << '/n';

color hardware_color( my_color * 255 );

std::cout << colori( hardware_color ) << '/n'; // cast to int to display ints instead of chars

std::cout << "/n/n";

}

//

// test 4:

//

{

std::cout << "test4:/n";

typedef vector_t<double,5> v5;

// vector_t doesn't have a five arg constructor, so

// we will have to use arrays, (or just implement a 5-arg constructor)

double arr[] = { 1.0, 2.0, 3.0, 4.0, 5.0 };

v5 p1( arr );

v5 p2 = arr;

std::cout << p1 << '/n' << p2 << '/n' << (p1 + p2).normalize() << '/n';

// v5 p3( { 1.0, 2.0, 3.0, 4.0, 5.0 } ); // error :(

std::cout << "/n/n";

}

system("PAUSE");

return 0;

}

测试输出：

test1:

2 2.5

test2:

1 2

1 2

3 4

test3:

0 1 0.5 1

0.25 1 0.5 1

63 255 127 255

test4:

1 2 3 4 5

1 2 3 4 5

0.13484 0.26968 0.40452 0.53936 0.6742

请按任意键继续. . .