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

#include <vector2.hpp>

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

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

Öffentliche Typen
using	value_type = T
using	self_type = vector2< T >
using	pointer = T *

Öffentliche Methoden
	vector2 ()
	vector2 (value_type _x, value_type _y)
	vector2 (value_type _f)
	vector2 (const vector2 &vec)
	vector2 (const pointer lpvec)
	operator pointer ()
	operator void * ()
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 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   c [2]
};

Ausführliche Beschreibung

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

Dokumentation der benutzerdefinierten Datentypen

pointer

template<typename T>

using std::math::vector2< T >::pointer = T*

self_type

template<typename T>

using std::math::vector2< T >::self_type = vector2<T>

value_type

template<typename T>

using std::math::vector2< T >::value_type = T

Beschreibung der Konstruktoren und Destruktoren

vector2() [1/5]

template<typename T>

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

inline

{}

vector2() [2/5]

template<typename T>

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

inline

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

vector2() [3/5]

template<typename T>

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

inline

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

vector2() [4/5]

template<typename T>

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

inline

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

vector2() [5/5]

template<typename T>

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

inline

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

Dokumentation der Elementfunktionen

operator pointer()

template<typename T>

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

inline

{ return (pointer)(c); }

operator void *()

template<typename T>

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

inline

{ return (void*)(c); }

operator*=() [1/2]

template<typename T>

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

inline

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

operator*=() [2/2]

template<typename T>

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

inline

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

operator+=()

template<typename T>

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

inline

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

operator-=()

template<typename T>

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

inline

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

operator/=() [1/2]

template<typename T>

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

inline

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

operator/=() [2/2]

template<typename T>

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

inline

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

operator=()

template<typename T>

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

inline

                                                        { 
                x = v.x; y = v.y; 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::vector2< T >::to_string ( )

inline

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

Dokumentation der Datenelemente

@30

union { ... }

c

template<typename T>

value_type std::math::vector2< T >::c[2]

x

template<typename T>

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

y

template<typename T>

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

---

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

• include/math/vector2.hpp