class Vertex: array member ou héritage de valarray ?
Salut les C++,
Après avoir terminer mon dernier projet: la version 2 de it-edit (Integrated Terminals Editor) que je vous invite a tester si vous êtes sous Linux.
---
J'ai et suis en train, je continue, d'écrire une petite library personnelle pour OpenGL.
Et donc mon ancienne implémentation de la classe Vertex ressemble a cela:
Code:
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
|
#ifndef GL_UTILS_VERTEX_H
#define GL_UTILS_VERTEX_H
#include <array>
#include <iostream>
#include <ostream>
using namespace std ;
template <typename T>
class Vertex {
std::array<T, 4> vertex ;
public :
Vertex() { vertex = {T(0), T(0), T(0), T(0)} ; } ;
Vertex(const Vertex<T> &val) { vertex = val.vertex ; } ;
Vertex(const T x, const T y, const T z, const T w=1) { vertex={x,y,z,w} ;} ;
Vertex<T>& operator = (const Vertex<T> &val) { vertex = val.vertex ; return *this ; } ;
T& operator [] ( const int idx) { return vertex.at(idx) ; } ;
Vertex& operator -() {
vertex[0] = -vertex[0] ;
vertex[1] = -vertex[1] ;
vertex[2] = -vertex[2] ;
return *this ;
}
// ...
} ;
#endif |
Et la nouvelle implémentation de la classe Vertex ressemble a ceçi:
Code:
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
|
#ifndef GL_UTILS_VERTEX_H
#define GL_UTILS_VERTEX_H
#include "./../../headers/includes.h"
// #include "./../../headers/defines.h" #define GL_UTILS_TYPE float // defined in this file.
#include <valarray>
using namespace std ;
class Vertex : valarray<GL_UTILS_TYPE> {
public :
//GL_UTILS_TYPE x = valarray[0] ; this doesn't work i don't know how to implement it.
Vertex() : valarray(3) {} ;
Vertex(const GL_UTILS_TYPE x, const GL_UTILS_TYPE y, const GL_UTILS_TYPE z) : valarray{x,y,z} {} ;
friend ostream& operator<<(ostream &os, Vertex &vertex) {
os << "Vertex at x: " << vertex[0] << ", y: " << vertex[1] << ", z: " << vertex[2] << endl ;
return os ;
} ;
// Is this right to get a pointer on the start of valarray ?
GL_UTILS_TYPE *get_vertex() { return (GL_UTILS_TYPE *) this ; }
// To be continued...
} ;
#endif |
Quel est la meilleur solution d'implémentation a votre humble avis:
1. un membre array de la classe Vertex et écrire tous l'overloading d'opérateur ?
ou
2. une classe Vertex héritant de la classe valarray, héritant de tous les bienfaits du valarray.
---
Sinon vous aurez sans doute remarquer que la première implémentation de la classe Vertex est une `template class`.
Le problème est que je n'arrive pas a compiler en fichier objet une classe template, pour des classes ayant plus de méthodes complexes.
Que j'aimerai séparer du *.h en fichier *.cpp compilable en fichier objet.
Est-ce parce que un template n'est pas compilable en fichier objet et sinon dans le cas contraire alors comment faire ???
---
Merci pour vos réponses et votre précieuse aide illuminant les ténèbres de mon ignorance.
