Discussion :

[polonain2]

Bonjour, j'ai sûrement un problème de conception mais j'aimerai comprendre pourquoi.

J'ai défini la classe suivante

Code :

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

1
2
3
4
5
6
7
8
9
10
 
template <class T>
class Property
{
public:
	Property(unsigned int i_type_mask, T i_value, int i_array_size = -1);
	~Property(void);
private:	
	Property(void);
};

et je voudrais faire ça:

Code :

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

1
2
3
4
5
6
 
Property<int> prop1(INT, 10, -1);
Property<int> prop2(INT, 20, -1);
Property<int> *prop3 = new Property<int>[2];
prop3[0] = prop1;
prop3[1] = prop2;

Voilà, c'est simple mais ça ne compile pas car le constucteur par défaut est privé (donc je peux pas créer mon tableau prop3) + j'ai le même résultat si j'enlève la déclaration du constucteur par défaut.

Je sais que je pourrais m'en sortir avec une liste ou un vecteur mais j'aimerai comprendre pourquoi je ne peux pas le faire. Je veux interdire l'utilisation du constructeur par défaut car je ne peux pas initialiser par défaut les variables membres.
Est-ce qu'il existe un design pattern ou autre chose permettant de faire ça?
Je pense que c'est possible si ma classe elle-même constuit le tableau (à la manière d'un singleton) mais y'a-t'il une autre solution? est-ce que j'utilise mal les templates?

merci

[atttchoum]

Je veux interdire l'utilisation du constructeur par défaut car je ne peux pas initialiser par défaut les variables membres.

tu es pourtant bien forcé de le faire ici :

Code :

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

Property<int> *prop3 = new Property<int>[2];

Tu crées deux objets de type Property<int> et ils vont utiliser le constructeur par défaut (qui leur sera indisponible car privé) pour s'initialiser.
Pourquoi ne pas utiliser un vector ?

Sinon ton problème ne semble pas lié au template.

EDIT :sinon une solution est de créer une fonction static qui s'occupera d'allouer ton tableau (j'ai un peu simplifier le code) :

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 <class T>
	class Property
{
public:
    Property(T i_value): i(i_value) {}
 
    ~Property(void){}
    T i;
 
    static Property<T> * creerTableau(unsigned int nb){
	return new Property<T>[nb];
    }
 
private :
	Property(): i(0){}
};
 
int main(){
 
    Property<int> prop1( 10);
    Property<int> prop2( 20);
    Property<int> * prop3 = Property<int>::creerTableau(2);
 
    cout << "prop1 " << prop1.i << endl;
    cout << "prop2 " << prop2.i << endl;
    cout << "prop3 avant [" << prop3[0].i << " " << prop3[1].i << "]" << endl;
 
    prop3[0] = prop1;
    prop3[1] = prop2;
 
    cout << "prop3 apres [" << prop3[0].i << " " << prop3[1].i << "]" << endl;
 
    delete [] prop3;
 
    return 0;
}

qui affiche :

Code :

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

1
2
3
4
5
 
prop1 10
prop2 20
prop3 avant [0 0]
prop3 apres [10 20]

[polonain2]

sinon une solution est de créer une fonction static qui s'occupera d'allouer ton tableau (j'ai un peu simplifier le code)

c'est ce que je viens de coder merci.

[koala01]

Salut,

En fait, ton problème n'a strictement rien à voir avec les template...

Ton problème vient du fait que le compilateur ne fournit le constructeur par défaut que si... il ne rencontre aucun constructeur

Lorsque tu écris:

Code :

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

1
2
3
4
5
6
7
class MaClass
{
    public:
        /*...*/
    private:
        MaClass(){/*...*/}
};

Le problème vient de ce que le constructeur n'est accessible qu'aux fonctions de MaClass (par exemple, à un autre constructeur, déclaré publique, celui-là, ce qui est vraiment d'un intérêt plus que douteux ou à une... fonction statique déclarée publique de la classe) et lorsque tu écris

Code :

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

1
2
3
4
5
6
class MaClass
{
    public:
        MaClass(/* une liste de paramètres */){/*...*/}
    /*...*/
};

le problème vient de la "fainéantise" du compilateur qui se dit que, comme tu a défini un constructeur, c'est que tu n'as pas besoin du constructeur "par défaut", et qui décide donc de ne pas l'implémenter

Si, pour une raison ou une autre, tu as besoin d'un constructeur ne prenant pas d'arguments (entre autres, pour pouvoir créer un tableau "C style"), tu dois donc... le fournir en visibilité publique.

Cependant, il faut attirer ton attention sur plusieurs points:

1- Il est, finalement, assez rare de trouver une situation dans laquelle un constructeur ne prenant pas d'argument est intéressant lorsque... l'on décide de fournir un constructeur qui en a besoin.

La raison est simple: on essaye généralement de respecter le principe du RAII. Si tu estimes devoir passer des arguments au constructeur pour être en mesure de respecter ce principe, il y a au final peu de chances (bien que cela puisse arriver) que tu puisse estimer qu'un objet créé sans les fournir puisse être considéré comme "correctement initialiser", quelles que soient les valeurs que tu donne par défaut.

2- Il est vraiment préférable d'éviter l'utilisation de tableaux C style, surtout si c'est dans une optique de gestion d'un nombre d'éléments qui n'est connu qu'à l'exécution.

En effet, dans un tel contexte, on se retrouve facilement à devoir jouer avec la gestion dynamique de la mémoire, et donc à courir le risque de... mal le faire.

Mais, de plus, nous devons nous rappeler qu'un tableau "C style" ne... connait pas le nombre d'éléments qu'il peut contenir, ce qui nous oblige à coté de cela à maintenir une valeur qui représente... le nombre d'éléments effectifs (si on envisager d'amortir le besoin de réallocation) et une autre qui représente... le nombre maximal d'éléments que l'on peut avoir à un instant T.

Tout cela nous fait courir le risque, si on n'est pas suffisamment attentif à ce que l'on fait, d'essayer d'accéder... à un élément qui n'existe pas, et donc d'envoyer le système "dans les roses"

Par chance, le standard nous fournit tout ce qu'il faut avec la classe vector, disponible dans l'espace de noms std grâce à l'inclusion du fichier d'en-tête <vector>, qui gère ces différents aspect de manière tout à fait transparente pour l'utilisateur, et dont il est donc vivement recommande d'user et d'abuser (du moins, lorsqu'il est opportun d'avoir une collection d'objets contigus en mémoire)