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 : Sélectionner tout - Visualiser dans une fenêtre à part
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 : Sélectionner tout - Visualiser dans une fenêtre à part
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.