Discussion :

[Trademark]

Bonsoir.

Je bug sur une undefined reference. J'ai une classe template grid_graph qui contient une méthode template. J'ai une autre classe (non template) héritant de grid_graph, et je voudrais surcharger cette méthode template mais lors de la compilation il me lance un beau "undefined reference to". La méthode est bien implémenté dans le cpp...

Merci de votre aide.

[koala01]

Salut,

Bonsoir.

Je bug sur une undefined reference. J'ai une classe template grid_graph qui contient une méthode template. J'ai une autre classe (non template) héritant de grid_graph, et je voudrais surcharger cette méthode template mais lors de la compilation il me lance un beau "undefined reference to". La méthode est bien implémenté dans le cpp...

Merci de votre aide.

C'est, justement, là l'erreur...

A moins d'avoir recours à l'instanciation explicite, les fonctions (membres de classes) templates doivent etre définies dans le fichier d'en-tête...

En effet, le compilateur ne saura générer le code binaire qu'une fois qu'il disposera d'un type pour l'ensemble des paramètres template attendus, ce qui revient à dire qu'il ne pourra le faire que... lors de l'utilisation réelle de la classe ou de la fonction

Pour qu'il puisse arriver à générer le code binaire, il faut, en outre, qu'il dispose du code C++ de la fonction

Or, si tu mets l'implémentation de la fonction dans un fichier *.cpp, comme tu n'incluras jamais un *.cpp dans n'importe quel fichier, le compilateur ne trouvera jamais le code au départ duquel il doit créer le code binaire

Résultat des courses: le compilateur considère que la fonction existe (vu qu'il en a trouvé la déclaration) mais l'éditeur de liens ne trouve pas le symbole correspondant dans le binaire, et tu as une erreur de type "undefined reference"

[3DArchi]

Salut,
F.A.Q. : Pourquoi mes templates ne sont-ils pas reconnus à l'édition des liens ?

je voudrais surcharger cette méthode template

Les fonctions génériques ne pouvant être virtuelles, dans ta classe dérivée tu masques ta fonction dans ta classe de base. A priori, cela ne me semble pas super comme truc.

[Trademark]

Bonjour et merci beaucoup pour votre aide. J'avais déjà posté une erreur similaire mais c'était à cause d'une classe template. Je ne savais pas que toutes les méthodes templates devaient également être dans le .hpp.

fonctions génériques ne pouvant être virtuelles, dans ta classe dérivée tu masques ta fonction dans ta classe de base. A priori, cela ne me semble pas super comme truc.

Je vais essayer de mieux expliquer ce "design".
J'ai une classe template grid_graph, elle représente un graphe en 2 dimensions et possède la propriété intéressante qu'il n'est pas nécessaire de stocker les arcs (car ils sont implicites). Le template de cette classe est le type de la valeur qu'on souhaite stocker sur les sommets.

C'est donc une classe générique, elle offre une fonction qui permet d'insérer dans un container les voisins d'un noeud donné :

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
template <typename value_type>
template <typename neighbor_container>
void grid_graph<value_type>::neighbor(vertex_type &vertex, neighbor_container &neighbors)
{
  for(int d=0; d < 4; ++d)
    try{
      neighbors.push_back(next(vertex, direction(d)));
    }catch(std::out_of_range &oor){}
}
 
template <typename value_type>
typename grid_graph<value_type>::vertex_type grid_graph<value_type>::next(vertex_type &vertex, direction x)
{
 
  static const std::size_t x_shift[4] = {0, 1, 0, -1};
  static const std::size_t y_shift[4] = {-1, 0, 1, 0};
 
  std::size_t new_x = vertex.first + x_shift[x];
  std::size_t new_y = vertex.second + y_shift[x];
 
  if(new_x >= x_max || new_y >= y_max)
    throw std::out_of_range("");
  return std::make_pair<std::size_t, std::size_t>(new_x, new_y);
}

La classe dérivé s'appelle maze. Je vous donne l'entête :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
struct maze_vertex
{
  char walls;
  int altitude;
};
 
class maze : public grid_graph<maze_vertex>
{
//...
};

Mais il faut donc surcharger les deux méthodes (et d'autres) précédemment citées, car il ne faut plus renvoyer tous les voisins mais seulement ceux qui ne sont pas séparés par un mur. La méthode neighbor reste la même mais la méthode next change. Un des problèmes, c'est qu'il a quand même fallu ré-implémenter neighbor à l'identique de la classe mère, pour qu'il se serve de la bonne fonction next...

Si vous avez des suggestions d'améliorations, n'hésitez pas

Merci

[3DArchi]

Salut,

Si vous avez des suggestions d'améliorations, n'hésitez pas

Va jusqu'au bout du CRTP :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
template <typename value_type>
template <typename neighbor_container>
void grid_graph<value_type>::neighbor(vertex_type &vertex, neighbor_container &neighbors)
{
  for(int d=0; d < 4; ++d)
    try{
      neighbors.push_back(static_cast<value_type*>(this)->next(vertex, direction(d)));
    }catch(std::out_of_range &oor){}
}

[Trademark]

EDIT : Après relecture du lien, j'ai bien compris, on "sauvegarde" bien le type en le passant en paramètre template à la classe. Merci du conseil.

Il s'agit d'un cast d'un objet de type grid_graph<maze_vertex>*, soit this, en maze_vertex*, qui est la donnée, et qui par conséquence ne contient pas de méthode next.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

error: invalid static_cast from type ‘grid_graph<maze_vertex>* const’ to type ‘maze_vertex*’

En fait, mais je ne sais pas si c'est possible, il faudrait redescendre dans la classe fille. C'est-à-dire que :

(1) Regarde si neighbor est implémenté dans maze.
(2) Non, donc va voir dans la classe mère grid_graph<maze_vertex>.
(3) Le trouve donc lance l'exécution de la méthode.
(4) Quand l'instruction next arrive, retourne dans la classe fille.

En fait il faudrait pouvoir "sauvegarder" le type de la classe fille pour pouvoir faire le cast sur this ? Enfin ça me semble alambiqué.

[3DArchi]

Salut,
J'avais lu trop rapidement ton code et je ne m'étais pas aperçu que ce n'était pas un CRTP que tu avais mis en œuvre.

Ce que tu veux faire (quoique assez tordu donc un peu suspect) est fort possible :
1/ Tu utilises bien le CRTP :

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
// avec un regroupement
template<class params>
class grid_graph
{
//....
};
 
template<class value_t, class type_t>
struct grid_graph_trait
{
   typedef type_t type;
   typedef value_t value;
};
 
struct maze_vertex
{
//...
};
 
class maze : public grid_graph<grid_graph_trait<maze_vertex, maze> >
{
//...
};

2/ Tu utilises l'introspection pour savoir si la classe dérivée contient la fonction ou non.