Discussion :

[Apocalipsia`]

Bonjour a tous !

Bon, j'ai un petit soucis de compréhension je pense... J'ai lu toutes les aides et tuto possible mais je n'ai pas trouvé ma réponse.

Pour un projet perso, je suis en train de recoder une liste chainée générique. Mon problème est le suivant :

J'utilise une structure :

Code :

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

1
2
3
4
5
6
7
8
 
template <typename T>
struct listC
{
  listC * prev;
  T v;
  listC * next;
};

J'ai une fonction "find" qui permet de me placer sur un élément passé en paramètre :

Code :

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

eListErr find (T &t);

(eListErr est un enum d'erreur...) La fonction find appel l'opérateur != qui doit etre surchargé pour le type T.

Jusque là tout va bien ! Ca marche très bien avec des int, des float, et touti quanti... Evidement, ca ne fonctionne pas pour les char * mais ca c'est normal... Le problème, c'est que je ne peux pas spécialiser mes template pour chaque classe que je vais utiliser... Or, dans mon cas, j'utilise une classe "Node" (qui représentent les noeuds d'un graph lui meme template aussi mais ca c'est pas un problème) J'instancie donc comme suit (je vous passe les templates du node pour plus de clareté...) :

Code :

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

TempList<Node *> *nodeList = new TempList<Node *>

Tout va bien... Sauf quand je fais un find... evidement, comme mon T est "Node *", il compare les adresses... Du coup ca fait pas ce qu'il faut... (l'opérateur != est évidement surchargé pour Node...)

L'astuce c'est que je ne veux pas lui mettre T=Node parce que j'ai plusieurs listes de noeuds et voudrais éviter les redondances... et si je met "T *v" dans la structure de base, c'est la meme chose... Je vais devoir faire l'allocation en interne et donc réallouer chaque noeud autant de fois qu'ils apparaissent dans une liste... S'il n'y a pas de solution, je ferais comme ca, tant pis pour la mémoire...

Merci d'avance si vous avez des idées !

Apo`

[JolyLoic]

Tu peux ajouter un élément template à ta liste (ou à ta fonction find) qui indique comment les objets sont comparés.

Autre solution, moins flexible, tu fais une spécialisation partielle de ta liste pour les T* qui compare sur les T.

[Apocalipsia`]

Et bhe justement, pour moi la surcharge de l'opérateur != c'est plus simple que de passer une fonction en paramètre... Mais si je peux pas j'y viendrais surement.

J'ai déja pensé a une spécialisation partielle, ca ne fonctionne pas pour simple raison que comme mon T est "Node *", de toute facon il n'appel pas la méthod "find(T *t)" puisque pour lui ca serait un "Node **" qu'il faut... (Ou alors je m'y suis mal pris...)


Merci pour la réponse rapide en tout cas ! J'attend d'autres avis, si certains ont des idées, sinon je ferais passer une fonction de comparaison... Tant pis pour l'opérateur !=

Apo`

[JolyLoic]

J'ai déja pensé a une spécialisation partielle, ca ne fonctionne pas pour simple raison que comme mon T est "Node *", de toute facon il n'appel pas la méthod "find(T *t)" puisque pour lui ca serait un "Node **" qu'il faut... (Ou alors je m'y suis mal pris...)

J'en ai l'impression. On peut avoir un extrait du code correspondant.

[Apocalipsia`]

Voici le code de ma liste chainée :

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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
#ifndef TEMPLIST_H
#define TEMPLIST_H
 
typedef enum eListErr
{
  LIST_ERR_NO_ERROR,
  LIST_ERR_MEMORY_ALLOCATION_ERROR,
  LIST_ERR_EMPTY_LIST_ERROR,
  LIST_ERR_NOT_FOUND,
  LIST_ERR_INDEX_OUT_OF_BOUND
 
};
 
template <typename T>
struct listC
{
  listC * prev;
  T v;
  listC * next;
};
 
template <typename T>
class TempList
{
public:
  // Constructor
  TempList();
  ~TempList();
 
  TempList(const TempList<T> &l);
 
  TempList &operator = (const TempList<T> &l);
 
  eListErr insert(T t);
  eListErr insert(unsigned long index, T t);
  eListErr del(bool freeValue);
  eListErr del(unsigned long index, bool freeValue);
  eListErr delAll(bool freeValue);
  eListErr change(T t, bool freeValue);
 
  eListErr find(T t);
  eListErr find(T *t);
  eListErr access(int index);
  T operator [] (int index);
 
  T getValue();
 
  inline unsigned int size() {return m_size;}
  inline bool isEmpty() {return !m_first;}
 
private:
  listC<T> * m_first;
  listC<T> * m_current;
  listC<T> * m_last;
  unsigned int m_size;
};
 
#include "tempList.tpp"
 
#endif

Et le code de find :

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
template <typename T>
eListErr TempList<T>::find(T t)
{
  if (isEmpty()) return LIST_ERR_EMPTY_LIST_ERROR;
 
  listC<T> * temp = m_first;
 
  printf("temp->v :%i\nt :%i\n", temp->v, t);
 
  while (temp != m_last && temp->v != t) 
  {
    printf("temp->v :%i\nt :%i\n", temp->v, t);
    temp = temp->next;
  }
  if (temp == m_last && temp->v != t) return LIST_ERR_NOT_FOUND;
 
  return LIST_ERR_NO_ERROR;
}
 
template <typename T>
eListErr TempList<T>::find(T *t)
{
  if (isEmpty()) return LIST_ERR_EMPTY_LIST_ERROR;
 
  listC<T> * temp = m_first;
 
  printf("temp->v :%i\nt :%i\n", temp->v, t);
 
  while (temp != m_last && *temp->v != *t) 
  {
    printf("temp->v :%i\nt :%i\n", temp->v, t);
    temp = temp->next;
  }
  if (temp == m_last && *temp->v != *t) return LIST_ERR_NOT_FOUND;
 
  return LIST_ERR_NO_ERROR;
}

Je pense que je n'ai pas bien saisi comment fonctionne la spécialisation en fait... :/ Un éclaircissement ?

Apo`

[koala01]

Salut,

Personnellement, je ne ferais pas renvoyer un code d'erreur à une fonction nommée find

En effet find signifie ... trouve
Dés lors, on est en droit de s'attendre à ce qu'une fonction find(quelque chose) nous renvoie... l'élément trouvé

Par contre, il n'est pas exclu d'envisager qu'une telle fonction... lance une exception si... l'élément n'est pas trouvé

J'aurais presque tendance à dire que ta fonction serait bien mieux nommée "exists", pour indiquer à l'utilisateur qu'elle vérifie l'existence de l'élément... mais on pourrait alors estimer qu'un simple booléen (oui, l'élément existe, non il n'existe pas) serait amplement suffisant

Maintenant, j'admet que ce n'est "qu'un détail" et que cela n'apporte pas la moitié d'une solution, mais j'estimais utile d'attirer ton attention sur l'importance de la "sémantique" que l'on donne aux noms de fonctions