第14章 C++中的代码重用

      公有继承是实现代码重用的机制之一，但并不是唯一的机制。本章介绍包含、私有继承和保护继承，他们用于实现has-a关系，即新的类包含另一个类的对象。而公有继承实现的是is-a关系。

1.包含对象成员的类

      包含(containment)，又叫组合(composition)或层次化(layering).

      Valarray类简介：https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091021/1.jpg

class Student { private: string name; //use a string object for name valarray<double> scores; //use a valarray<double> object for scores ... };

https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091021/2.jpg

       student类范例：

// studentc.h -- defining a Student class using containment #ifndef STUDENTC_H_ #define STUDENTC_H_ #include <iostream> #include <string> #include <valarray> class Student { private: typedef std::valarray<double> ArrayDb; std::string name; // contained object ArrayDb scores; // contained object // private method for scores output std::ostream & arr_out(std::ostream & os) const; public: Student() : name("Null Student"), scores() {} Student(const std::string & s) : name(s), scores() {} explicit Student(int n) : name("Nully"), scores(n) {} Student(const std::string & s, int n) : name(s), scores(n) {} Student(const std::string & s, const ArrayDb & a) : name(s), scores(a) {} Student(const char * str, const double * pd, int n) : name(str), scores(pd, n) {} ~Student() {} double Average() const; const std::string & Name() const; double & operator[](int i); double operator[](int i) const; // friends // input friend std::istream & operator>>(std::istream & is, Student & stu); // 1 word friend std::istream & getline(std::istream & is, Student & stu); // 1 line // output friend std::ostream & operator<<(std::ostream & os, const Student & stu); }; #endif

https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091021/3.jpg

https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091021/4.jpg

// studentc.cpp -- Student class using containment #include "studentc.h" using std::ostream; using std::endl; using std::istream; using std::string; //public methods double Student::Average() const { if (scores.size() > 0) return scores.sum()/scores.size(); else return 0; } const string & Student::Name() const { return name; } double & Student::operator[](int i) { return scores[i]; // use valarray<double>::operator[]() } double Student::operator[](int i) const { return scores[i]; } // private method ostream & Student::arr_out(ostream & os) const { int i; int lim = scores.size(); if (lim > 0) { for (i = 0; i < lim; i++) { os << scores[i] << " "; if (i % 5 == 4) os << endl; } if (i % 5 != 0) os << endl; } else os << " empty array "; return os; } // friends // use string version of operator>>() istream & operator>>(istream & is, Student & stu) { is >> stu.name; return is; } // use string friend getline(ostream &, const string &) istream & getline(istream & is, Student & stu) { getline(is, stu.name); return is; } // use string version of operator<<() ostream & operator<<(ostream & os, const Student & stu) { os << "Scores for " << stu.name << ":/n"; stu.arr_out(os); // use private method for scores return os; }

// use_stuc.cpp -- using a composite class // compile with studentc.cpp #include <iostream> #include "studentc.h" using std::cin; using std::cout; using std::endl; void set(Student & sa, int n); const int pupils = 3; const int quizzes = 5; int main() { Student ada[pupils] = {Student(quizzes), Student(quizzes), Student(quizzes)}; int i; for (i = 0; i < pupils; ++i) set(ada[i], quizzes); cout << "/nStudent List:/n"; for (i = 0; i < pupils; ++i) cout << ada[i].Name() << endl; cout << "/nResults:"; for (i = 0; i < pupils; ++i) { cout << endl << ada[i]; cout << "average: " << ada[i].Average() << endl; } cout << "Done./n"; return 0; } void set(Student & sa, int n) { cout << "Please enter the student's name: "; getline(cin, sa); cout << "Please enter " << n << " quiz scores:/n"; for (int i = 0; i < n; i++) cin >> sa[i]; while (cin.get() != '/n') continue; }

2.私有继承

      使用私有继承后，新版本的构造函数将使用成员初始化列表句法（同公有继承一样），而不是像包含那样用成员名来标识。

//包含 Student(const char * str, const double * pd, int n): name(str), scores(pd, n) {} //私有继承 Student(const char * str, const double * pd, int n): std::string(str), ArrayDb(pd, n) {}

       使用包含时将使用对象名来调用方法，而使用私有继承时将使用类名和作用域解析操作符来调用方法。

//包含 double Student::Average() const { if (scores.size() > 0) return scores.sum()/scores.size(); else return 0; } //私有继承 double Student::Average() const { if (ArrayDb::size() > 0) return ArrayDb::sum()/ArrayDb::size(); else return 0; }

       使用作用域解析操作符可以访问基类的方法，但如果要使用基类对象本身，该如何做？包含里面Name()方法返回string对象成员name；但使用私有继承时，该string对象没有名称。答案是用强制类型转换，将Student对象转换为string对象。

const string & Student::Name() const { return (const string &) *this; }

        怎样访问基类的友元函数呢。用类名显式地限定并不适合，因为友元不属于类。不过可以显式地转换为基类来调用正确的函数。在下面，引用stu不会自动转换为string引用，根本原因是：私有继承中，在不进行显式类型转换的情况下，不能将指向派生类的引用或指针赋给基类引用或指针。

ostream & operator<<(ostream & os, const Student & stu) { os << "Scores for " << (const string &) stu << ":/n"; ... }

       修改后的student类：

// studenti.h -- defining a Student class using private inheritance #ifndef STUDENTC_H_ #define STUDENTC_H_ #include <iostream> #include <valarray> #include <string> class Student : private std::string, private std::valarray<double> { private: typedef std::valarray<double> ArrayDb; // private method for scores output std::ostream & arr_out(std::ostream & os) const; public: Student() : std::string("Null Student"), ArrayDb() {} Student(const std::string & s) : std::string(s), ArrayDb() {} Student(int n) : std::string("Nully"), ArrayDb(n) {} Student(const std::string & s, int n) : std::string(s), ArrayDb(n) {} Student(const std::string & s, const ArrayDb & a) : std::string(s), ArrayDb(a) {} Student(const char * str, const double * pd, int n) : std::string(str), ArrayDb(pd, n) {} ~Student() {} double Average() const; double & operator[](int i); double operator[](int i) const; const std::string & Name() const; // friends // input friend std::istream & operator>>(std::istream & is, Student & stu); // 1 word friend std::istream & getline(std::istream & is, Student & stu); // 1 line // output friend std::ostream & operator<<(std::ostream & os, const Student & stu); }; #endif

// studenti.cpp -- Student class using private inheritance #include "studenti.h" using std::ostream; using std::endl; using std::istream; using std::string; // public methods double Student::Average() const { if (ArrayDb::size() > 0) return ArrayDb::sum()/ArrayDb::size(); else return 0; } const string & Student::Name() const { return (const string &) *this; } double & Student::operator[](int i) { return ArrayDb::operator[](i); // use ArrayDb::operator[]() } double Student::operator[](int i) const { return ArrayDb::operator[](i); } // private method ostream & Student::arr_out(ostream & os) const { int i; int lim = ArrayDb::size(); if (lim > 0) { for (i = 0; i < lim; i++) { os << ArrayDb::operator[](i) << " "; if (i % 5 == 4) os << endl; } if (i % 5 != 0) os << endl; } else os << " empty array "; return os; } // friends // use String version of operator>>() istream & operator>>(istream & is, Student & stu) { is >> (string &)stu; return is; } // use string friend getline(ostream &, const string &) istream & getline(istream & is, Student & stu) { getline(is, (string &)stu); return is; } // use string version of operator<<() ostream & operator<<(ostream & os, const Student & stu) { os << "Scores for " << (const string &) stu << ":/n"; stu.arr_out(os); // use private method for scores return os; }

      通常，应使用包含来建立has-a关系；如果新类需要访问原有类的保护成员，或需要重新定义虚函数，则应使用私有继承。

https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091021/5.jpg

3.保护继承

      使用保护继承时，基类的公有成员和保护成员都将成为派生类的保护成员。和私有继承一样，基类的接口在派生类中也是可用的，但在继承层次结构之外是不可用的。当从派生类派生出另一个类时，私有继承和保护继承之间的主要区别就呈现出来了。使用私有继承时，第三代类将不能使用基类的接口，这是因为基类的公有方法在派生类中将变为私有方法；使用保护继承时，基类的公有方法在第二代中将变成受保护的，因此第三代派生类可用使用它们。

      下面是比较图，其中隐式向上转换意味着无须进行显式类型转换，就可以将基类指针或引用指向派生类对象。

https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091021/6.jpg

4.使用using重新定义访问权限

https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091021/7.jpg

https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091021/8.jpg

5.多重继承

      多重继承，MI，multiple interitance。 私有MI和保护MI可以表示has-a关系。这里主要讨论公有MI。

      虚基类技术：虚基类使得从多个类（它们的基类相同）派生出的对象只继承一个基类对象。通过在类声明中使用virtual，可以使Worker被用作Singer和Waiter的虚基类（virtual和public的次序无关紧要）。当类通过多条虚拟途径和非虚拟途径继承某个特定的基类时，该类将包含一个表示所有的虚拟途径的基类子对象和分别表示各条非虚拟途径的多个基类子对象。

class Singer: virtual public Worker { ... }; class Waiter: public virtual Worker { ... }; class SingingWaiter: public Singer, public Waiter { ... };

         新的构造函数规则：

https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091021/9.jpg

https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091021/10.jpg

       MI常使用模块化方式，构造组件的技术来处理重定义方法的一些问题，下面是一个MI的例子：

// workermi.h -- working classes with MI #ifndef WORKERMI_H_ #define WORKERMI_H_ #include <string> class Worker // an abstract base class { private: std::string fullname; long id; protected: virtual void Data() const; virtual void Get(); public: Worker() : fullname("no one"), id(0L) {} Worker(const std::string & s, long n) : fullname(s), id(n) {} virtual ~Worker() = 0; // pure virtual function virtual void Set() = 0; virtual void Show() const = 0; }; class Waiter : virtual public Worker { private: int panache; protected: void Data() const; void Get(); public: Waiter() : Worker(), panache(0) {} Waiter(const std::string & s, long n, int p = 0) : Worker(s, n), panache(p) {} Waiter(const Worker & wk, int p = 0) : Worker(wk), panache(p) {} void Set(); void Show() const; }; class Singer : virtual public Worker { protected: enum {other, alto, contralto, soprano, bass, baritone, tenor}; enum {Vtypes = 7}; void Data() const; void Get(); private: static char *pv[Vtypes]; // string equivs of voice types int voice; public: Singer() : Worker(), voice(other) {} Singer(const std::string & s, long n, int v = other) : Worker(s, n), voice(v) {} Singer(const Worker & wk, int v = other) : Worker(wk), voice(v) {} void Set(); void Show() const; }; // multiple inheritance class SingingWaiter : public Singer, public Waiter { protected: void Data() const; void Get(); public: SingingWaiter() {} SingingWaiter(const std::string & s, long n, int p = 0, int v = other) : Worker(s,n), Waiter(s, n, p), Singer(s, n, v) {} SingingWaiter(const Worker & wk, int p = 0, int v = other) : Worker(wk), Waiter(wk,p), Singer(wk,v) {} SingingWaiter(const Waiter & wt, int v = other) : Worker(wt),Waiter(wt), Singer(wt,v) {} SingingWaiter(const Singer & wt, int p = 0) : Worker(wt),Waiter(wt,p), Singer(wt) {} void Set(); void Show() const; }; #endif

// workermi.cpp -- working class methods with MI #include "workermi.h" #include <iostream> using std::cout; using std::cin; using std::endl; // Worker methods Worker::~Worker() { } // protected methods void Worker::Data() const { cout << "Name: " << fullname << endl; cout << "Employee ID: " << id << endl; } void Worker::Get() { getline(cin, fullname); cout << "Enter worker's ID: "; cin >> id; while (cin.get() != '/n') continue; } // Waiter methods void Waiter::Set() { cout << "Enter waiter's name: "; Worker::Get(); Get(); } void Waiter::Show() const { cout << "Category: waiter/n"; Worker::Data(); Data(); } // protected methods void Waiter::Data() const { cout << "Panache rating: " << panache << endl; } void Waiter::Get() { cout << "Enter waiter's panache rating: "; cin >> panache; while (cin.get() != '/n') continue; } // Singer methods char * Singer::pv[Singer::Vtypes] = {"other", "alto", "contralto", "soprano", "bass", "baritone", "tenor"}; void Singer::Set() { cout << "Enter singer's name: "; Worker::Get(); Get(); } void Singer::Show() const { cout << "Category: singer/n"; Worker::Data(); Data(); } // protected methods void Singer::Data() const { cout << "Vocal range: " << pv[voice] << endl; } void Singer::Get() { cout << "Enter number for singer's vocal range:/n"; int i; for (i = 0; i < Vtypes; i++) { cout << i << ": " << pv[i] << " "; if ( i % 4 == 3) cout << endl; } if (i % 4 != 0) cout << '/n'; cin >> voice; while (cin.get() != '/n') continue; } // SingingWaiter methods void SingingWaiter::Data() const { Singer::Data(); Waiter::Data(); } void SingingWaiter::Get() { Waiter::Get(); Singer::Get(); } void SingingWaiter::Set() { cout << "Enter singing waiter's name: "; Worker::Get(); Get(); } void SingingWaiter::Show() const { cout << "Category: singing waiter/n"; Worker::Data(); Data(); }

// workmi.cpp -- multiple inheritance // compile with workermi.cpp #include <iostream> #include <cstring> #include "workermi.h" const int SIZE = 5; int main() { using std::cin; using std::cout; using std::endl; using std::strchr; Worker * lolas[SIZE]; int ct; for (ct = 0; ct < SIZE; ct++) { char choice; cout << "Enter the employee category:/n" << "w: waiter s: singer " << "t: singing waiter q: quit/n"; cin >> choice; while (strchr("wstq", choice) == NULL) { cout << "Please enter a w, s, t, or q: "; cin >> choice; } if (choice == 'q') break; switch(choice) { case 'w': lolas[ct] = new Waiter; break; case 's': lolas[ct] = new Singer; break; case 't': lolas[ct] = new SingingWaiter; break; } cin.get(); lolas[ct]->Set(); } cout << "/nHere is your staff:/n"; int i; for (i = 0; i < ct; i++) { cout << endl; lolas[i]->Show(); } for (i = 0; i < ct; i++) delete lolas[i]; cout << "Bye./n"; return 0; }

       虚基类和支配：

https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091021/11.jpg

https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091021/12.jpg

6.类模板

     关键点：模板类的定义和实现要放在同一文件中。现在的编译器还不支持模板类的定义和实现分开。

http://hi.baidu.com/woiwojia/blog/item/d5ef994ee2499aced0c86a24.html

       一个类模板的例子：

// stcktp1.h -- modified Stack template #ifndef STCKTP1_H_ #define STCKTP1_H_ template <class Type> class Stack { private: enum {SIZE = 10}; // default size int stacksize; Type * items; // holds stack items int top; // index for top stack item public: explicit Stack(int ss = SIZE); Stack(const Stack & st); ~Stack() { delete [] items; } bool isempty() { return top == 0; } bool isfull() { return top == stacksize; } bool push(const Type & item); // add item to stack bool pop(Type & item); // pop top into item Stack & operator=(const Stack & st); }; template <class Type> Stack<Type>::Stack(int ss) : stacksize(ss), top(0) { items = new Type [stacksize]; } template <class Type> Stack<Type>::Stack(const Stack & st) { stacksize = st.stacksize; top = st.top; items = new Type [stacksize]; for (int i = 0; i < top; i++) items[i] = st.items[i]; } template <class Type> bool Stack<Type>::push(const Type & item) { if (top < stacksize) { items[top++] = item; return true; } else return false; } template <class Type> bool Stack<Type>::pop(Type & item) { if (top > 0) { item = items[--top]; return true; } else return false; } template <class Type> Stack<Type> & Stack<Type>::operator=(const Stack<Type> & st) { if (this == &st) return *this; delete [] items; stacksize = st.stacksize; top = st.top; items = new Type [stacksize]; for (int i = 0; i < top; i++) items[i] = st.items[i]; return *this; } #endif

      原型将赋值操作符函数的返回类型声明为Stack引用，而实际的模板函数定义将类型定义为Stack<Type>。前者是后者的缩写，但只能在类中使用。即可以在模板声明或模板函数定义内使用Stack，但在类的外面，即指定返回类型或使用作用域解析操作符时，必须使用完整的Stack<Type>.

      指定数组大小的数组模板，一种方法是在类中使用动态数组和构造函数参数来提供元素数目，另一种是使用模板参数来提供常规数组的大小。如下面这个例子：

//arraytp.h -- Array Template #ifndef ARRAYTP_H_ #define ARRAYTP_H_ #include <iostream> #include <cstdlib> template <class T, int n> class ArrayTP { private: T ar[n]; public: ArrayTP() {}; explicit ArrayTP(const T & v); virtual T & operator[](int i); virtual T operator[](int i) const; }; template <class T, int n> ArrayTP<T,n>::ArrayTP(const T & v) { for (int i = 0; i < n; i++) ar[i] = v; } template <class T, int n> T & ArrayTP<T,n>::operator[](int i) { if (i < 0 || i >= n) { std::cerr << "Error in array limits: " << i << " is out of range/n"; std::exit(EXIT_FAILURE); } return ar[i]; } template <class T, int n> T ArrayTP<T,n>::operator[](int i) const { if (i < 0 || i >= n) { std::cerr << "Error in array limits: " << i << " is out of range/n"; std::exit(EXIT_FAILURE); } return ar[i]; } #endif

https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091022/1.jpg

      可以递归使用模板。例如对于上面的声明，这样使用它： ArrayTP< ArrayTP<int,5>, 10> twodee; 与之等价的常规数组声明如下： int twodee[10][5];

      可以将用于常规类的技术用于模板类。模板类可以用作基类，也可用作组件类，还可用作其他模板的类型参数。如：

template <class T> class Array { ... } template <class Type> class GrowArray: public Array<Type> { ... } template <class Tp> class Stack { Array<Tp> ar; ... } ... Array < Stack<int> > asi; //an array of stacks of int

      模板可以包含多个类型参数，如：

 template <class T1,class T2> class Pair { T1 a; T2 b; ... }

      还有一项特性是，可以为类型参数提供默认值：template <class T1,class T2=int> class Topo {...}.   虽然可以为类模板类型参数提供默认值，但不能为函数模板参数提供默认值。不过，可以为非类型参数提供默认值，这对于类模板和函数模板都是适用的。

7. 模板的具体化

      类模板与函数模板很相似，可以有隐式实例化，显式实例化和显式具体化，它们统称为具体化。

https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091022/2.jpg

https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091022/3.jpg

https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091022/4.jpg

https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091022/5.jpg

8. 成员模板

     模板可用作结构、类或模板类的成员。下面是一个简单的例子，该模板类将另一个模板类和模板函数作为其成员。

// tempmemb.cpp -- template members #include <iostream> using std::cout; using std::endl; template <typename T> class beta { private: template <typename V> // nested template class member class hold { private: V val; public: hold(V v = 0) : val(v) {} void show() const { cout << val << endl; } V Value() const { return val; } }; hold<T> q; // template object hold<int> n; // template object public: beta( T t, int i) : q(t), n(i) {} template<typename U> // template method U blab(U u, T t) { return (n.Value() + q.Value()) * u / t; } void Show() const { q.show(); n.show();} }; int main() { beta<double> guy(3.5, 3); guy.Show(); cout << guy.blab(10, 2.3) << endl; cout << "Done/n"; return 0; }

https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091022/6.jpg

      有些编译器接受类外面的定义，上述代码和下面的代码等价：

template <typename T> class beta { private: template <typename V> class hold; hold<T> q; hold<int> n; public: beta( T t, int i) : q(t), n(i) {} template<typename U> U blab(U u, T t); void Show() const { q.show(); n.show();} }; template <typename T> template <typename V> class hold { private: V val; public: hold(V v = 0) : val(v) {} void show() const { cout << val << endl; } V Value() const { return val; } }; template <typename T> template<typename U> U blab(U u, T t) { return (n.Value() + q.Value()) * u / t; }

      注意上面后面两个的嵌套句法。

9.将模板用作参数

https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091022/1633918160989840000.jpg

// tempparm.cpp -- templates as parameters #include <iostream> #include "stacktp.h" template <template <typename T> class Thing> class Crab { private: Thing<int> s1; Thing<double> s2; public: Crab() {}; // assumes the thing class has push() and pop() members bool push(int a, double x) { return s1.push(a) && s2.push(x); } bool pop(int & a, double & x){ return s1.pop(a) && s2.pop(x); } }; int main() { using std::cout; using std::cin; using std::endl; Crab<Stack> nebula; // Stack must match template <typename T> class thing int ni; double nb; cout << "Enter int double pairs, such as 4 3.5 (0 0 to end):/n"; while (cin>> ni >> nb && ni > 0 && nb > 0) { if (!nebula.push(ni, nb)) break; } while (nebula.pop(ni, nb)) cout << ni << ", " << nb << endl; cout << "Done./n"; return 0; }

https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091022/2633918160990777500.jpg

10.模板类和友元

      模板类声明也可以有友元。模板的友元分3类：非模板友元；约束(bound)模板友元，即友元的类型取决于类被实例化时的类型；非约束(unbound)模板友元，即友元的所有具体化都是类的每一个具体化的友元。

1)模板类的非模板友元函数

https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091022/3633918184763433750.jpg

// frnd2tmp.cpp -- template class with non-template friends #include <iostream> using std::cout; using std::endl; template <typename T> class HasFriend { private: T item; static int ct; public: HasFriend(const T & i) : item(i) {ct++;} ~HasFriend() {ct--; } friend void counts(); friend void reports(HasFriend<T> &); // template parameter }; // each specialization has its own static data member template <typename T> int HasFriend<T>::ct = 0; // non-template friend to all HasFriend<T> classes void counts() { cout << "int count: " << HasFriend<int>::ct << "; "; cout << "double count: " << HasFriend<double>::ct << endl; } // non-template friend to the HasFriend<int> class void reports(HasFriend<int> & hf) { cout <<"HasFriend<int>: " << hf.item << endl; } // non-template friend to the HasFriend<double> class void reports(HasFriend<double> & hf) { cout <<"HasFriend<double>: " << hf.item << endl; } int main() { cout << "No objects declared: "; counts(); HasFriend<int> hfi1(10); cout << "After hfi1 declared: "; counts(); HasFriend<int> hfi2(20); cout << "After hfi2 declared: "; counts(); HasFriend<double> hfdb(10.5); cout << "After hfdb declared: "; counts(); reports(hfi1); reports(hfi2); reports(hfdb); return 0; }

2)模板类的约束模板友元函数

https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091022/4633918185832965000.jpg

// tmp2tmp.cpp -- template friends to a template class #include <iostream> using std::cout; using std::endl; // template prototypes template <typename T> void counts(); template <typename T> void report(T &); // template class template <typename TT> class HasFriendT { private: TT item; static int ct; public: HasFriendT(const TT & i) : item(i) {ct++;} ~HasFriendT() { ct--; } friend void counts<TT>(); friend void report<>(HasFriendT<TT> &); }; template <typename T> int HasFriendT<T>::ct = 0; // template friend functions definitions template <typename T> void counts() { cout << "template size: " << sizeof(HasFriendT<T>) << "; "; cout << "template counts(): " << HasFriendT<T>::ct << endl; } template <typename T> void report(T & hf) { cout << hf.item << endl; } int main() { counts<int>(); HasFriendT<int> hfi1(10); HasFriendT<int> hfi2(20); HasFriendT<double> hfdb(10.5); report(hfi1); // generate report(HasFriendT<int> &) report(hfi2); // generate report(HasFriendT<int> &) report(hfdb); // generate report(HasFriendT<double> &) cout << "counts<int>() output:/n"; counts<int>(); cout << "counts<double>() output:/n"; counts<double>(); return 0; } https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091022/5633918186586715000.jpg

3)模板类的非约束模板友元函数

https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091022/6633918187675465000.jpg

// manyfrnd.cpp -- unbound template friend to a template class #include <iostream> using std::cout; using std::endl; template <typename T> class ManyFriend { private: T item; public: ManyFriend(const T & i) : item(i) {} template <typename C, typename D> friend void show2(C &, D &); }; template <typename C, typename D> void show2(C & c, D & d) { cout << c.item << ", " << d.item << endl; } int main() { ManyFriend<int> hfi1(10); ManyFriend<int> hfi2(20); ManyFriend<double> hfdb(10.5); cout << "hfi1, hfi2: "; show2(hfi1, hfi2); cout << "hfdb, hfi2: "; show2(hfdb, hfi2); return 0; }