comment relier deux classes de modèle dans de nombreux à plusieurs amitié?

Question

supposer que j'ai les deux classes de modèles suivants:

template <class _A>
class First
{
private:
    int a;
};

template <class _B>
class Second
{
private:
    int b;
};

comment puis-je les relier dans de nombreux à plusieurs amitié. par exemple, en ajoutant un procédé d'abord que les impressions B d'un objet de paramètre de seconde.

est ma question claire?

Answer 1

template <typename T>
class First {
   int a;
   template<typename> friend class Second;
};
template <typename T>
class Second
{
   int b;
   template<typename> friend class First;
};

Cela permettra à tous les First<T> pour accéder aux composants internes de chaque Second<U>. Maintenant, tout cela est la solution technique, vous voudrez peut-être examiner si une conception avec des dépendances cycliques et l'ouverture de l'interne à une instanciation de l'autre classe est la meilleure solution à votre problème particulier.

BTW, si vous ne souhaitez accorder un accès First<int> à Second<int> (et non Second<double>), vous pouvez le faire comme ceci:

template <typename> class Second;
template <typename T>
class First {
   int a;
   friend class Second<T>; // only befriend the same instantiation
};
template <typename T>
class Second {
   int b;
   friend class First<T>;
};

Dans cette deuxième version que vous avez besoin de la déclaration avant du modèle de Second avant amitié avec une instanciation particulière, mais cela vous permet d'accorder l'accès aux composants internes de la classe qu'à un instanciation particulier.

Answer 2

En supposant que vous comprenez la protection, est la question la déclaration avant de modèles:

#include <iostream>

template <class _B> class Second; // Forward declare

template <class _A>
class First
{
public:
    template<class _B>
    void print(const Second<_B>& b)
    {
        std::cout << b.b << std::endl;
    }
    int a;
};

template <class _B>
class Second
{
public:
    int b;
};

void testIt()
{
    Second<double> sd;
    First<int >fi;
    fi.print<double>(sd);
}

Answer 3

Vous pourriez commencer par une déclaration de chaque classe:

template< typename T > class First;
template< typename T > class Second;

Et maintenant, les deux classes sera au courant de l'autre dans leurs définitions. Vous pouvez les déclarer comme amis là-bas si vous avez besoin.

template< typename T > class First
{
   template< typename U> friend class Second;
};

et même en sens inverse.

Vous pouvez également mettre en œuvre des organes de fonction en vertu des définitions de classe si elles ont besoin de se voir détails pour, à savoir qu'ils ne peuvent pas utiliser une copie « de déclaration avant ».