Discussion :

[ikeas]

bonjour

j'ai le code suivant

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
template <class T>
class XX {
	T ref;
public:
	XX(T ref) : ref(ref){
	};
	~XX(){
		//delete ref;
	}
};
 
template <class T>
class XX<T*> {
	T* ref;
public:
	XX(T* ref) : ref(ref){
	};
	~XX(){
		delete ref;
	}
};

j'aimerais savoir si je pourrais pas spécialiser le destructeur dans la première classe pour simplifier
en fait j'ai un classe qui as beaucoup de code et ça m'ennui de la spécialiser en deux classes...

évidement je pourrais faire une classe de base avec un destructeur virtuel et faire la spécialisation au dessus
mais si c'est possible dans la première classe ....

sinon j'avais pensé a faire 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
template <class T>
class YY {
	T ref;
public:
	YY(T ref) : ref(ref){
	};
	virtual ~YY(){
		//delete ref;
	}
	void toto(){};
};
 
template <class T>
class YY<T*> : public YY<T>{
	T* ref;
public:
	YY(T* ref) : ref(ref){
	};
	virtual ~YY(){
		delete ref;
	}
};

mais ça passe pas

[jo_link_noir]

Le problème avec la spécialisation de classe s'est qu'il faut tout redéfinir, même les membres qui ne changent pas. Dans les techniques possibles : traits, dispatchers, wrappers.

Par exemple, à l'intérieur de YY faire un using internal_type = std::conditional_t<std::is_pointer<T>(), std::unique_ptr<T>, T>; et utiliser internal_type plutôt que T.
Ou via la surcharge de fonction : destruct(std::true_type)/destruct(std::false_type) avec l'appel suivant : destruct(std::is_pointer<T>()).

[ikeas]

tu pourrais me mettre un code exemple que je vois ce que cela peut donner ?

[ternel]

Sinon, il y a la possibilité d'ajouter une classe de base, avec du CRTP si nécessaire.

[koala01]

Salut,

Ce que tu peux faire, c'est déléguer la destruction du membre à quelque chose qui sera prévu pour, sous une forme proche de

Code :

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

1
2
3
4
5
6
7
8
9
10
template <typename T, typename DELETER>
class XX {
	T ref;
public:
	XX(T ref) : ref(ref){
	};
	~XX(){
		DELETER()(ref);
        }
};

et créer différents traits pour la gestion des différentes possibilités, sous une forme proche de

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
 
template <typename T>
struct ValueDestructor{
    void operator()(T & value){
        // just does nothing ... values and refs are automatiquely destroied when leaving them scope
    }
}
template <typename T>
struct PointerDestructor{
    void operator()(T* ptr){
        delete ptr;
    }
};
template <typename T>
struct ArrayDestructor{
    void operator()(T* ptr){
        delete [] ptr;
    }
};

L'instanciation de ta classe prendrait alors une forme proche de

Code :

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

1
2
3
4
XX<UnType, ValueDestructor> x; // pas d'allocation dynamique, pas de delete
XX<Type2, PointerDestructor> pointer; // allocation dynamique, mais pas un tableau
 
XX<Type3, ArrayDestructor> array; // allocation dynamique d'un tableau

Note que je n'ai pris que le problème de la destruction des membre en ligne de compte... Pour que cela fonctionne, il faut que le trait de destruction choisi soit cohérent avec la politique de construction du membre