Discussion :

[GMany]

Bonjour, j'aimerais faire une amitié d'un template avec un template spécialisé, est-ce possible ? Si oui, quelle est la syntaxe...

Pour exemple :

Code :

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

1
2
3
4
5
6
7
 
template<class A, class B>template_ami;
 
template<class T>un_template
{
  template<class U>friend class template_ami<T,U>;
};

Et GCC me refuse :
erreur: partial specialization ‘template_ami<T, U>’ declared ‘friend’

Parce qu'il est possible de faire :

Code :

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

1
2
3
4
5
6
7
 
template<class A, class B>template_ami;
 
template<class T>un_template
{
  template<class U, class V>friend class template_ami;
};

Mais ça n'a aucun intérêt puisque tous les template_ami peuvent être ami avec tous les un_template de n'importe quel type, l'intérêt étant de spécialiser l'amitié en fonction des types des deux templates...

[3DArchi]

Mais ça n'a aucun intérêt puisque tous les template_ami peuvent être ami avec tous les un_template de n'importe quel type, l'intérêt étant de spécialiser l'amitié en fonction des types des deux templates...

A mon avis la réponse est dans une question : montres un exemple qui compile de transgression que tu voudrais interdire (et où tu ne serais pas passé par une spécialisation au - partielle).

[GMany]

Un exemple qui compile je ne pense pas pouvoir vous le faire, parce que je développe avec mes propres librairies, qui ne sont pas en libre de droits.

Mais je peux faire un exemple avec une syntaxe générique type pseudo-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
template<class Obj, class Key>class manager
{
 
  private :
 
    List<Object<Obj> *,Key>;
 
};
 
template<class Obj>class Object
{
 
  template<class A, class B>friend class manager;
 
  private :
 
    Obj *;
 
};

(J'ai écris List je suppose que quelqu'un qui utilise STL écrira map)

Bien sûr les classes là sont très simples, on peut se demander l'utilité de la classe Object. Mais il suffit de rajouter plein de membres privés à Object en faire une classe utile.

L'essentiel c'est de voir que par exemple, manager<voiture,int> est aussi ami avec Object<batiment>, alors que voiture et batiment sont deux classes clairement différentes.

Ce qu'on voudrait, c'est que seules les classes manager<voiture,T> soient amies avec la classe Object<voiture>.

[3DArchi]

Salut,
Ce que je voulais dire, c'est que soit tu manipules en permanence du générique et alors template<class U, class V>friend class template_ami; suffit. Soit tu es amené à faire une spécialisation partielle et alors c'est dans cette spécialisation partielle qu'il te faut positionner ton amitié.
C'est pourquoi je te demandais un exemple (pas forcément de ton code) où tu ne spécialises pas partiellement (ou totalement) et où l'amitié te permet de transgresser une encapsulation que tu ne souhaiterais pas. J'avoue que je crois que c'est tout bonnement pas possible. D'où je pense que la question ne se pose pas en fait.

[GMany]

Pour faire une transgression c'est plutôt simple, il suffit de considérer deux instances d'une même classe mais pas du même type...

Je reprend mon exemple précédent, que je complète un peu...

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
template<class Obj, class Key>class manager
{

  private :

    List<Object<Obj> *,Key> list;
    Object<Obj> *GetKey(Key);

    template<class X, class Y>void methode(manager<X,Y> *, Y);

};

template<class Obj, class Key>template<class X, class Y>void manger<Obj,Key>::methode(manager<X,Y> *x, Y y)
{
   Object<X> *obj=x->GetKey(y);
   // [0] Je peux faire ce que je veux avec obj
}

template<class Obj>class Object
{

  template<class A, class B>friend class manager;

  private :

    Obj *p;

};

On voit très bien au commentaire [0] que le manager de type <voiture,int> peut accéder à tous les champs sans souci de Object<batiment> via la méthode manager::methode<batiment,int> par exemple...

Bien sûr, ce n'est qu'un exemple, mais l'intérêt d'une amitié template spécialisée est de restreindre l'accès de la classe à un template en fonction de son type. Et je suppose que ce n'est pas le seul exemple qu'on pourrait rencontrer...

Par ailleurs, c'est ce qui est fait implicitement, quand la spécialisation est totale. Par exemple, deux templates de même type, et une amitié :

Code :

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

1
2
3
4
5
6
template<class T>class A{};
 
template<class T>class B
{
  friend class A<T>;
};

Ici il n'est pas question que A<char> soit ami avec B<int>, par contre, A<int> et B<int> sont amis. Du coup, on fait exactement une amitié en fonction du type.
Et donc il devrait être logique qu'il soit possible de restreindre en fait l'amitié de B<T> à tous les templates de type A<T'=T,U,V,...>.

[3DArchi]

Salut,
J'ai trouvé ça dans la norme :

Friend declarations shall not declare partial specializations. [Example:
template<class T> class A { };
class X {
template<class T> friend class A<T*>; // error
};
—end example]

Et j'aurais tendance à dire que ce que tu veux faire est une amitié en déclarant une spécialisation partielle.
La réponse serait donc non c'est pas possible tel quel...