Discussion :

[la_urre]

Bonjour,

Je cherche à instancier un type générique de cette manière :

Code :

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

1
2
3
4
template <class T>
void function(){
    T *t = new T();
}

Est-ce possible ? Je souhaiterais mettre en place ce mécanisme de manière récursive, c'est-à-dire que T peut être la classe générique elle-même :

Code :

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

1
2
3
4
5
6
7
8
9
10
template <class T>
class Tab{
    void function();
};
 
void Tab<class T>::function(){
    T *t = new T();
}
 
Tab<Tab<int>> *t = new Tab<Tab<int>>();

J'ai certains problèmes à mettre ça en place.

Merci d'avance.

[Arzar]

Bonjour,
La syntaxe n'est pas bonne.
Essaye :

Code :

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

1
2
3
4
5
template <typename T>
void Tab<T>::function()
{
    T *t = new T();
}

[la_urre]

Merci !

Et est-ce possible d'instancier le type avec un autre constructeur que celui par défaut ?

La réponse semble être oui.

Maintenant j'ai un autre souci. Ma classe template est Tab qui permet de déclarer un tableau. J'ai un souci lorsque je veux avoir des pointeurs :

Code :

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

1
2
Tab<Tab<int>> tab1;
Tab<Tab<int>*> *tab2;

Lorsque j'ai la deuxième forme, l'instanciation ne fonctionne plus car le new T() se transforme en new Tab<int>*(), et j'ai un problème à la compil. Mais cela m'intéresserait vraiment d'utiliser des pointeurs. Comment faire ? Y'a-t-il un moyen d'identifier que le type générique est en fait un pointeur ?

Merci encore!

[koala01]

Salut,

D'abord, je voudrais t'inciter à réfléchir sereinement à la nécessité réelle de manipuler des pointeurs.

S'il y a, effectivement, des cas dans lesquels il n'y a pas vraiment d'autre solution, il faut savoir qu'il est largement préférable de les éviter autant possible si rien ne nous oblige à les utiliser (entre autres, si on ne souhaite pas manipuler des objet polymorphes en profitant justement de leur capacité polymorphique )

Ceci dit, il est tout à fait possible d'envisager une spécialisation partielle de ta classe afin de prévoir des comportement selon que tu manipule des objets ou des pointeurs:

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
/* le comportement par défaut: on manipule des objets :D */
template <typename T>
class Tab
{
    /*...*/
};
/* la même classe, spécialisée pour manipuler des pointeurs...
 * même si on ne sait pas quel type nous manipulons: c'est une
 * "spécialisation partielle" :D
 */
template <typename T>
class Tab<T*>
{
    /*...*/
    // ATTENTION, il s'agira de t'assurer que les différents comportements
    // seront REELLEMENT adaptés à l'utilisation de pointeurs :D
};

[la_urre]

Merci beaucoup koala01, c'est exactement ce qu'il me fallait. Je savais qu'on pouvait spécialiser avec des types particuliers, int, char, etc, mais pas avec des pointeurs. Cela donne à peu près ceci pour moi, si jamais quelqu'un a besoin de faire la même chose :

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
template <typename MonType>
class Tab
{
public:
	Tab(int size);
	MonType operator[](int pos) const;
	MonType& operator[](int pos);
};
 
template <typename MonType>
class Tab<MonType*>
{
public:
	Tab(int size);
	MonType* operator[](int pos) const;
	MonType*& operator[](int pos);
};
 
template <typename MonType>
MonType Vecteur<MonType>::operator[](int pos) const{
	return ...;
}
 
template <typename MonType>
MonType* Vecteur<MonType*>::operator[](int pos) const{
	return ...;
}

Merci encore pour votre aide !

[3DArchi]

Salut,
Et quelle différence entre tes 2 spécialisations ? Perso, je n'en vois aucune.

(L'idée derrière ma remarque est que tu as peut être besoin de classes traits à un moment et pas forcément d'une spécialisation car pour au vu de la déclaration ta spécialisation n'en est pas une).