Язык программирования C++. Пятое издание - Стенли Липпман

Наиболее распространенная форма дружественных отношений между шаблоном класса и другим шаблоном (класса или функции) подразумевает дружбу между соответствующими экземплярами класса и его друга. Например, класс Blob должен объявить дружественным класс BlobPtr и шаблонную версию оператора равенства класса Blob (первоначально определенную для класса StrBlob в упражнении раздела 14.3.1).

Чтобы обратиться к определенному экземпляру шаблона (класса или функции), следует сначала объявить сам шаблон. Объявление шаблона включает список параметров шаблона:

// для объявления дружественных отношений в шаблоне Blob нужны

// предварительные объявления

template <typename> class BlobPtr;

template <typename> class Blob; // необходимо для параметров operator==

template <typename T>

 bool operator==(const Blob<T>&, const Blob<T>&);

template <typename T> class Blob {

 // каждый экземпляр Blob предоставляет доступ к версии BlobPtr и

 // оператору равенства экземпляра, созданного с тем же типом

 friend class BlobPtr<T>;

 friend bool operator==<T>

  (const Blob<T>&, const Blob<T>&);

 // другие члены, как в разделе 12.1.1

};

Начнем с объявления Blob, BlobPtr и operator== шаблонами. Эти объявления необходимы для объявления параметра в функции operator== и дружественных объявлений в шаблоне Blob.

Объявления дружественными используют параметр шаблона Blob как собственный аргумент шаблона. Таким образом, дружба ограничивается этими экземплярами шаблона BlobPtr и оператора равенства, которые создаются с тем же типом:

Blob<char> ca; // BlobPtr<char> и operator==<char> друзья

Blob<int> ia;  // BlobPtr<int> и operator==<int> друзья

Члены класса BlobPtr<char> могут обращаться к не открытым членам объекта ca (или любого другого объекта класса Blob<char>), но объект ca не имеет никаких специальных прав доступа к объекту ia (или любому другому объекту класса Blob<int>) или любому другому экземпляру класса Blob.

Общие и специфические дружественные отношения шаблонов

Класс может также сделать дружественным каждый экземпляр шаблона или ограничить дружбу специфическим экземпляром:

// предварительное объявление необходимо для объявления дружественных

// отношений со специфическим экземпляром шаблона

template <typename Т> class Pal;

class С { // С - обычный, не шаблонный класс

 friend class Pal<C>; // экземпляр Pal создается с классом С как

                      // дружественным

 // все экземпляры Раl2 дружественны С;

 // при предоставлении дружественных отношений всем экземплярам

 // предварительное объявление не обязательно

 template <typename Т> friend class Раl2;

};

template <typename T> class C2 { // C2 - сам шаблон класса

 // у каждого экземпляра C2 есть тот же экземпляр Pal, что и у друга

 friend class Pal<T>; // объявление шаблона для Pal должно быть в

                      // области видимости

 // все экземпляры Раl2 - друзья каждого экземпляра C2; необходимо

 // предварительное объявление

 template <typename X> friend class Раl2;

 // Pal3 - не шаблонный класс, являющийся другом каждого экземпляра C2

 friend class Раl3; // предварительное объявление для Раl3

                    // не обязательно

};

Чтобы позволить создавать все экземпляры как дружественные, объявление дружественных отношений должно использовать параметры шаблона, которые отличаются от используемых самим классом.

Объявление параметра типа шаблона дружественным

По новому стандарту параметр типа шаблона можно сделать дружественным:

template <typename Type> class Bar {

 friend Type; // предоставить доступ к типу, используемому для создания

              // экземпляра Bar

 // ...

};

Здесь указано, что, независимо от используемого для создания экземпляра типа, класс Bar будет дружественным. Таким образом, для некоего типа под названием Foo он был бы другом для Bar<Foo>, а тип Sales_data — другом для Bar<Sales_data> и т.д.

Следует заметить, что хотя другом обычно бывает класс или функция, для класса Bar вполне допустимо создание экземпляра со встроенным типом. Такие дружественные отношения позволяют создавать экземпляры таких классов, как Bar со встроенными типами.

Псевдонимы типа шаблона

Экземпляр шаблона класса определяет тип класса, и, подобно любому другому типу класса, для экземпляра класса можно определить псевдоним при помощи ключевого слова typedef (см. раздел 2.5.1):

typedef Blob<string> StrBlob;

Это определение типа позволит выполнить код, написанный в разделе 12.1.1, используя текущую версию шаблона Blob, экземпляр которого создан для типа string. Поскольку шаблон не тип, ключевое слово typedef к шаблону неприменимо. Таким образом, нет никакого способа определить typedef для шаблона Blob<Т>.

Однако новый стандарт позволяет определять псевдоним типа для шаблона класса:

template<typename Т> using twin = pair<T, Т>;

twin<string> authors; // authors - это pair<string, string>

где имя twin определено как синоним для пар с одинаковыми типами членов. Пользователям типа twin достаточно определить его только однажды.

Псевдоним типа шаблона — это синоним для целого семейства классов:

twin<int> win_loss; // win_loss - это pair<int, int>

twin<double> area;  // area - это pair<double, double>

Как и при использовании шаблона класса, при использовании псевдонима twin следует указать, какой именно вид twin необходим.

При определении псевдонима типа шаблона можно зафиксировать один или несколько параметров шаблона:

template <typename Т> using partNo = pair<T, unsigned>;

partNo<string> books; // books - это pair<string, unsigned>

partNo<Vehicle> cars; // cars - это pair<Vehicle, unsigned>

partNo<Student> kids; // kids - это pair<Student, unsigned>

Здесь имя partNo определено как синоним семейства типов, которые являются парами, вторая переменная-член которого имеет тип unsigned. Пользователи partNo определяют тип первой переменной-члена пары, но не второй.

Статические члены шаблонов класса

Подобно любому другому классу, шаблон класса способен объявить статические члены (см. раздел 7.6):

template <typename T> class Foo {

public:

 static std::size_t count() { return ctr; }

 // другие члены интерфейса

private:

 static std::size_t ctr;

 // другие члены реализации

};

где Foo — шаблон класса, у которого есть открытая статическая функция-член count() и закрытая статическая переменная-член ctr. У каждого экземпляра шаблона Foo будет собственный экземпляр статических членов. Таким образом, для любого конкретного типа X будет по одной переменной Foo<X>::ctr и одной функции Foo<X>::count(). Все объекты типа Foo<X> будут совместно использовать ту же переименую ctr и функцию count(). Например:

// создает экземпляр статических членов Foo<string>::ctr

// и Foo<string>::count

Foo<string> fs;

// все три объекта совместно используют те же члены Foo<int>::ctr

// и Foo<int>::count

Foo<int> fi, fi2, fi3;

Подобно любой другой статической переменной-члену, у каждой статической переменной-члена шаблона класса должно быть только одно определение. Однако для каждого экземпляра шаблона класса будет отдельный объект. В результате статическую переменную-член шаблона определяют таким же образом, как и функции-члены этого шаблона:

template <typename Т>

size_t Foo<T>::ctr = 0; // определение и инициализация ctr

Подобно любым другим членам шаблона класса, начнем с определения списка параметров шаблона, сопровождаемого типом и именем определяемого члена. Как обычно, имя члена включает имя класса, которое включает для класса, созданного из шаблона, его аргументы шаблона. Таким образом, когда класс Foo создается как экземпляр для специфического типа аргумента шаблона, для этого класса будет создан отдельный экземпляр переменной ctr и инициализирован значением 0.