std::math::vector3< T > Template-Klassenreferenz

#include <vector3.hpp>

Klassendiagramm für std::math::vector3< T >:

Zusammengehörigkeiten von std::math::vector3< T >:

Öffentliche Typen
typedef T	value_type
typedef vector3< T >	self_type
typedef T *	pointer

Öffentliche Methoden
	vector3 ()
	vector3 (value_type _x, value_type _y, value_type _z)
	vector3 (value_type _f)
	vector3 (const self_type &vec)
	vector3 (const vector2< T > &vec)
	vector3 (const pointer lpvec)
	operator pointer ()
	operator void * ()
self_type &	operator= (const self_type &v)
self_type &	operator= (const vector2< T > &v)
self_type &	operator+= (const self_type &v)
self_type &	operator-= (const self_type &v)
self_type &	operator*= (const self_type &v)
self_type &	operator/= (const self_type &v)
self_type &	operator/= (const value_type &f)
self_type &	operator*= (const value_type &f)
template<typename E = char, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>
std::basic_string< E, TAllocator, TStorage >	to_string ()

Öffentliche Attribute
union {
struct {
value_type   x
value_type   y
value_type   z
}
value_type   c [3]
};

Ausführliche Beschreibung

template<typename T>
class std::math::vector3< T >

Dokumentation der benutzerdefinierten Datentypen

pointer

template<typename T>

typedef T* std::math::vector3< T >::pointer

self_type

template<typename T>

typedef vector3<T> std::math::vector3< T >::self_type

value_type

template<typename T>

typedef T std::math::vector3< T >::value_type

Beschreibung der Konstruktoren und Destruktoren

vector3() [1/6]

template<typename T>

std::math::vector3< T >::vector3 ( )

inline

{}

vector3() [2/6]

template<typename T>

std::math::vector3< T >::vector3 ( value_type  _x, value_type  _y, value_type  _z  )

inline

: x(_x), y(_y), z(_z)   {}

vector3() [3/6]

template<typename T>

std::math::vector3< T >::vector3 ( value_type  _f )

inline

: x(_f), y(_f), z(_f)           {}

vector3() [4/6]

template<typename T>

std::math::vector3< T >::vector3 ( const self_type &  vec )

inline

: x(vec.x), y(vec.y), z(vec.z)  {}

vector3() [5/6]

template<typename T>

std::math::vector3< T >::vector3 ( const vector2< T > &  vec )

inline

: x(vec.x), y(vec.y), z(0)  {}

vector3() [6/6]

template<typename T>

std::math::vector3< T >::vector3 ( const pointer  lpvec )

inline

: x(lpvec[0]), y(lpvec[1]), z(lpvec(2)) {}

Dokumentation der Elementfunktionen

operator pointer()

template<typename T>

std::math::vector3< T >::operator pointer ( )

inline

{ return (pointer)(c); }

operator void *()

template<typename T>

std::math::vector3< T >::operator void * ( )

inline

{ return (void*)(c); }

operator*=() [1/2]

template<typename T>

self_type& std::math::vector3< T >::operator*= ( const self_type &  v )

inline

                                                        { 
                x *= v.x; y *= v.y; z *= v.z; return *this; }

operator*=() [2/2]

template<typename T>

self_type& std::math::vector3< T >::operator*= ( const value_type &  f )

inline

                                                            { 
                x *= f; y *= f; z *= f; return *this; }

operator+=()

template<typename T>

self_type& std::math::vector3< T >::operator+= ( const self_type &  v )

inline

                                                        {
                x += v.x; y += v.y; z += v.z; return *this; }

operator-=()

template<typename T>

self_type& std::math::vector3< T >::operator-= ( const self_type &  v )

inline

                                                        { 
                x -= v.x; y -= v.y; z -= v.z; return *this; }

operator/=() [1/2]

template<typename T>

self_type& std::math::vector3< T >::operator/= ( const self_type &  v )

inline

                                                        { 
                x /= v.x; y /= v.y; z /= v.z; return *this; }

operator/=() [2/2]

template<typename T>

self_type& std::math::vector3< T >::operator/= ( const value_type &  f )

inline

                                                            { 
                x /= f; y /= f; z /= f; return *this; }

operator=() [1/2]

template<typename T>

self_type& std::math::vector3< T >::operator= ( const self_type &  v )

inline

                                                        { 
                x = v.x; y = v.y; z = v.z; return *this; } 

operator=() [2/2]

template<typename T>

self_type& std::math::vector3< T >::operator= ( const vector2< T > &  v )

inline

                                                            {
                x = v.x; y = v.y; z = 0; return *this; }

to_string()

template<typename T>

template<typename E = char, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

std::basic_string<E, TAllocator, TStorage> std::math::vector3< T >::to_string ( )

inline

                                                                 {   
                return std::frmstring<E, TAllocator, TStorage>("{ %.3f %.3f %.3f }", 
                        x, y, z ); }

Dokumentation der Datenelemente

@34

union { ... }

c

template<typename T>

value_type std::math::vector3< T >::c[3]

x

template<typename T>

value_type std::math::vector3< T >::x

y

template<typename T>

value_type std::math::vector3< T >::y

z

template<typename T>

value_type std::math::vector3< T >::z

---

Die Dokumentation für diese Klasse wurde erzeugt aufgrund der Datei:

• include/math/vector3.hpp