5.1.1.1.3 : Implementation PAbstractVect3_impl.h
First, we have to avoid multiple include :

1
2
3
4

#ifndef __PABSTRACT_VECT_3_IMPL_H__
#define __PABSTRACT_VECT_3_IMPL_H__

#include "PAbstractVect3.h"


Constructors implementation :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

///constructeur de PAbstractVect3
template <typename T>
PAbstractVect3<T>::PAbstractVect3(){}

///constructeur de PAbstractVect3
/**	@param x : première composante
 * 	@param y : deuxième composante
*/
template <typename T>
PAbstractVect3<T>::PAbstractVect3(const T & x, const T & y){
	p_values[0] = x;
	p_values[1] = y;
}

///constructeur de PAbstractVect3
/**	@param x : première composante
 * 	@param y : deuxième composante
 * 	@param z : troisième composante
*/
template <typename T>
PAbstractVect3<T>::PAbstractVect3(const T & x, const T & y, const T & z){
	p_values[0] = x;
	p_values[1] = y;
	p_values[2] = z;
}

///constructeur de copie de PAbstractVect3
/**	@param other : PAbstractVect3 à copier
*/
template <typename T>
PAbstractVect3<T>::PAbstractVect3(const PAbstractVect3<T> & other){
	copyPAbstractVect3(other);
}


Destructors implementation (nothing to do) :

1
2
3
4
5

///destructeur de PAbstractVect3
template <typename T>
PAbstractVect3<T>::~PAbstractVect3(){
	
}


Equal operators :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

///Equal operator
/**	@param vect : vector to be copied
 * 	@return copied vector
*/
template <typename T>
typename PAbstractVect3<T>::PAbstractVect3 & PAbstractVect3<T>::operator = (const PAbstractVect3<T> & vect){
	copyPAbstractVect3(vect);
	return *this;
}

///redéfinition de l'opérateur +=
/**	@param vect : PAbstractVect3
 * 	@return PAbstractVect3
*/
template <typename T>
typename PAbstractVect3<T>::PAbstractVect3 & PAbstractVect3<T>::operator += (const PAbstractVect3<T> & vect){
	p_values[0] += vect.p_values[0];
	p_values[1] += vect.p_values[1];
	p_values[2] += vect.p_values[2];
	return *this;
}

///redéfinition de l'opérateur -=
/**	@param vect : PAbstractVect3
 * 	@return PAbstractVect3
*/
template <typename T>
typename PAbstractVect3<T>::PAbstractVect3 & PAbstractVect3<T>::operator -= (const PAbstractVect3<T> & vect){
	p_values[0] -= vect.p_values[0];
	p_values[1] -= vect.p_values[1];
	p_values[2] -= vect.p_values[2];
	return *this;
}

///redéfinition de l'opérateur *= avec un T
/**	@param scal : scalaire
 * 	@return PAbstractVect3
*/
template <typename T>
typename PAbstractVect3<T>::PAbstractVect3 & PAbstractVect3<T>::operator *= (const T & scal){
	p_values[0] *= scal;
	p_values[1] *= scal;
	p_values[2] *= scal;
	return *this;
}

///redéfinition de l'opérateur /= avec un T
/**	@param scal : scalaire
 * 	@return PAbstractVect3
*/
template <typename T>
typename PAbstractVect3<T>::PAbstractVect3 & PAbstractVect3<T>::operator /= (const T & scal){
	p_values[0] /= scal;
	p_values[1] /= scal;
	p_values[2] /= scal;
	return *this;
}

///définition de l'opérateur -
/**	@return opposé du vecteur courant
*/
template <typename T>
typename PAbstractVect3<T>::PAbstractVect3 PAbstractVect3<T>::operator -() const{
	PAbstractVect3<T> result(-p_values[0], -p_values[1], -p_values[2]);
	return result;
}


Some setters :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

///fonction qui permet d'initialiser les composantes du PAbstractVect3
/**	@param x : première composante
*/
template <typename T>
void PAbstractVect3<T>::setComposante(const T & x){
	p_values[0] = x;
}

///fonction qui permet d'initialiser les composantes du PAbstractVect3
/**	@param x : première composante
 * 	@param y : deuxième composante
*/
template <typename T>
void PAbstractVect3<T>::setComposante(const T & x, const T & y){
	p_values[0] = x;
	p_values[1] = y;
}

///fonction qui permet d'initialiser les composantes du PAbstractVect3
/**	@param x : première composante
 * 	@param y : deuxième composante
 * 	@param z : troisième composante
*/
template <typename T>
void PAbstractVect3<T>::setComposante(const T & x, const T & y, const T & z){
	p_values[0] = x;
	p_values[1] = y;
	p_values[2] = z;
}

///fonction qui initialise la première composante du PAbstractVect3
/**	@param x : première composante du PAbstractVect3
*/
template <typename T>
void PAbstractVect3<T>::setX(const T & x){p_values[0] = x;}

///fonction qui initialise la deuxième composante du PAbstractVect3
/**	@param y : deuxième composante du PAbstractVect3
*/
template <typename T>
void PAbstractVect3<T>::setY(const T & y){p_values[1] = y;}

///fonction qui initialise la troisième composante du PAbstractVect3
/**	@param z : troisième composante du PAbstractVect3
*/
template <typename T>
void PAbstractVect3<T>::setZ(const T & z){p_values[2] = z;}


Some modifiers :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

///fonction qui ajoute une valeur à la première composante du PAbstractVect3
/**	@param dx : valeur à ajouter à la première composante
*/
template <typename T>
void PAbstractVect3<T>::addX(const T & dx){p_values[0] += dx;}

///fonction qui ajoute une valeur à la deuxième composante du PAbstractVect3
/**	@param dy : valeur à ajouter à la deuxième composante
*/
template <typename T>
void PAbstractVect3<T>::addY(const T & dy){p_values[1] += dy;}

///fonction qui ajoute une valeur à la troisième composante du PAbstractVect3
/**	@param dz : valeur à ajouter à la troisième composante
*/
template <typename T>
void PAbstractVect3<T>::addZ(const T & dz){p_values[2] += dz;}

///fonction qui soustrait une valeur à la première composante du PAbstractVect3
/**	@param dx : valeur à soustraire à la première composante
*/
template <typename T>
void PAbstractVect3<T>::sousX(const T & dx){p_values[0] -= dx;}

///fonction qui soustrait une valeur à la deuxième composante du PAbstractVect3
/**	@param dy : valeur à soustraire à la deuxième composante
*/
template <typename T>
void PAbstractVect3<T>::sousY(const T & dy){p_values[1] -= dy;}

///fonction qui permet de changer l'échelle de la composante x du vecteur courant
/**	@param sx : échelle sur l'axe Ox
*/
template <typename T>
void PAbstractVect3<T>::scaleX(const T & sx){
	p_values[0] /= sx;
}

///fonction qui permet de changer l'échelle de la composante y du vecteur courant
/**	@param sy : échelle sur l'axe Oy
*/
template <typename T>
void PAbstractVect3<T>::scaleY(const T & sy){
	p_values[1] /= sy;
}

///fonction qui permet de changer l'échelle de la composante z du vecteur courant
/**	@param sz : échelle sur l'axe Oz
*/
template <typename T>
void PAbstractVect3<T>::scaleZ(const T & sz){
	p_values[2] /= sz;
}

///fonction qui permet de changer l'échelle du vecteur courant
/**	@param sx : échelle sur l'axe Ox
 * 	@param sy : échelle sur l'axe Oy
 * 	@param sz : échelle sur l'axe Oz
*/
template <typename T>
void PAbstractVect3<T>::scale(const T & sx, const T & sy, const T & sz){
	p_values[0] /= sx;
	p_values[1] /= sy;
	p_values[2] /= sz;
}

///fonction qui soustrait une valeur à la troisième composante du PAbstractVect3
/**	@param dz : valeur à soustraire à la troisième composante
*/
template <typename T>
void PAbstractVect3<T>::sousZ(const T & dz){p_values[2] -= dz;}


Some getters :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

///fonction qui renvoie la valeur de la première composante
/**	@return valeur de la première composante
*/
template <typename T>
T PAbstractVect3<T>::getX() const{return p_values[0];}

///fonction qui renvoie la valeur de la première composante
/**	@return valeur de la première composante
*/
template <typename T>
T & PAbstractVect3<T>::getX(){return p_values[0];}

///fonction qui renvoie la valeur de la deuxième composante
/**	@return valeur de la deuxième composante
*/
template <typename T>
T PAbstractVect3<T>::getY() const{return p_values[1];}

///fonction qui renvoie la valeur de la deuxième composante
/**	@return valeur de la deuxième composante
*/
template <typename T>
T & PAbstractVect3<T>::getY(){return p_values[1];}

///fonction qui renvoie la valeur de la troisième composante
/**	@return valeur de la troisième composante
*/
template <typename T>
T PAbstractVect3<T>::getZ() const{return p_values[2];}

///fonction qui renvoie la valeur de la troisième composante
/**	@return valeur de la troisième composante
*/
template <typename T>
T & PAbstractVect3<T>::getZ(){return p_values[2];}


//////////////////////////////////////////////////////////////////
//                                                              //
//         Fonctions privées de la classe PAbstractVect3        //
//                                                              //
//////////////////////////////////////////////////////////////////


Copy function :

1
2
3
4
5
6
7
8
9
10
11
12

///fonction qui copie un PAbstractVect3
/**	@param other : PAbstractVect3 à copier
*/
template <typename T>
void PAbstractVect3<T>::copyPAbstractVect3(const PAbstractVect3<T> & other){
	p_values[0] = other.p_values[0];
	p_values[1] = other.p_values[1];
	p_values[2] = other.p_values[2];
}


#endif