友谊和继承

好友功能

原则，private和protected成员的类不能被同一类中，他们宣布从外面访问。 然而，这个规则不影响朋友 。 

朋友与friend关键字声明的函数或类。 

如果我们想声明一个外部函数作为一类的朋友，从而使这个功能有机会获得私营部门和保护这个类的成员，我们做到这一点，声明这个类的内外部函数的原型，前面加上关键字的朋友 ： 

 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  

 // friend functions #include <iostream> using namespace std; class CRectangle { int width, height; public : void set_values ( int , int ); int area () { return (width * height);} friend CRectangle duplicate (CRectangle); }; void CRectangle::set_values ( int a, int b) { width = a; height = b; } CRectangle duplicate (CRectangle rectparam) { CRectangle rectres; rectres.width = rectparam.width*2; rectres.height = rectparam.height*2; return (rectres); } int main () { CRectangle rect, rectb; rect.set_values (2,3); rectb = duplicate (rect); cout << rectb.area(); return 0; } 

  24 

重复的功能是CRectangle的一个朋友。 在该函数中，我们已经能够访问成员宽度和高度CRectangle的类型，不同的对象，这是私有成员。 请注意，无论是在声明中重复的（），也不在其后来在main（）的使用，我们认为复制 class CRectangle的成员。 它是不是！ 它只是访问private和protected成员的成员。 

朋友功能服务，例如，两个不同的类之间进行操作。 一般来说，使用友元函数是一个面向对象的编程方法，所以，只要有可能，最好是与他们使用同一个类的成员执行操作。 如前面的例子中，它会一直较短duplicate（）集成在class CRectangle的 。 

朋友班

正如我们有可能定义一个友元函数，我们也可以定义一个类，一个又一个的朋友，批准，一流的访问protected和private成员的第二个。 

 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  

 // friend class #include <iostream> using namespace std; class CSquare; class CRectangle { int width, height; public : int area () { return (width * height);} void convert (CSquare a); }; class CSquare { private : int side; public : void set_side ( int a) {side=a;} friend class CRectangle; }; void CRectangle::convert (CSquare a) { width = a.side; height = a.side; } int main () { CSquare sqr; CRectangle rect; sqr.set_side(4); rect.convert(sqr); cout << rect.area(); return 0; } 

  16 

在这个例子中，我们已经宣布CRectangle的CSquare的朋友CRectangle的成员函数，以便能有CSquare的 protected和private成员的访问，更具体地访问CSquare ::一面 ，它描述了边宽的平方。 

您还可以看到一些新的东西在开始的程序：CSquare的类空声明。 这是必要的，因为在CRectangle的声明中 ，我们参考了CSquare（ 转换（）作为参数）。 CSquare的定义后面，所以如果我们不包括先前的空CSquare的声明从CRectangle的定义，这个类将是不可见的。 

考虑友谊不符，如果我们不明确指定。 在我们的例子中，CRectangle视为朋友类CSquare的 ，但CRectangle的不考虑CSquare的是一个朋友，所以因为CRectangle可以访问CSquare的 protected和private成员，但不是反向的方式。 当然，我们也已经宣布CSquare的CRectangle的朋友，如果我们想。 

另一个属性是，他们的友谊是不可传递 ：不认为是朋友的朋友的朋友，除非明确指定。 

类之间的继承

C + +类的一个主要特点是继承。 继承允许创建从其他类派生的类，让他们自动包括一些它的“父母”的成员，再加上其自身。 例如，我们要假设我们要宣布了一系列的多边形，像我们的CRectangle的 ，或者像CTriangle类。 它们具有某些共同的属性，如既可以通过所述装置只有双方高度和基。 

这可以在世界上的类与类CPolygon从中我们会得到两个其他的： 类CRectangle和 CTriangle的代表。 


该的类CPolygon会包含成员，是常见的两种类型的多边形。 在我们的例子： 宽度和高度 。 CRectangle的和 CTriangle将其派生类，具有特定的功能是不同的，从一种类型的多边形。 

来自他人的类继承基类的所有可访问的成员。 这意味着，如果一个基类，包括的成员和我们推导到另一个类称为B的另一名成员，派生类将包含两个成员A和 B。 

为了从另一个派生一个类，我们使用一个冒号（：）在声明中派生类使用以下格式： 

类：公共derived_class_name的base_class_name 
{/ * ... * /}; 

derived_class_name派生类的名字是，和base_class_name的类名，它是基于。 公共访问控制符可以被替换的任何一个其他访问protected和private修饰符。 此访问控制符限制最方便的从基类继承的成员：继承的成员一个更方便的水平，而这个水平，而不是与同等或更严格的访问级别的成员在派生类中保持自己的限制级别。 

 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  

 // derived classes #include <iostream> using namespace std; class CPolygon { protected : int width, height; public : void set_values ( int a, int b) { width=a; height=b;} }; class CRectangle: public CPolygon { public : int area () { return (width * height); } }; class CTriangle: public CPolygon { public : int area () { return (width * height / 2); } }; int main () { CRectangle rect; CTriangle trgl; rect.set_values (4,5); trgl.set_values (4,5); cout << rect.area() << endl; cout << trgl.area() << endl; return 0; } 

  20   10 

每个类CRectangle和 CTriangle的对象包含成员从CPolygon的继承。 它们是： 宽度 ， 高度和的函数set_values（）。 

受保护的访问控制符是类似于私人 。 发生在其唯一的区别其实与继承。 当一个类继承自另一个成员在​​派生类可以访问从基类继承的受保护的成员，但不是它的私有成员。 

既然我们想要的宽度和高度从派生类类CRectangle和 CTriangle的成员访问，而不是仅由CPolygon的成员，我们已经使用，而不是私人的访问保护 。 

根据谁可以访问它们，以下列方式，我们可以总结不同的接入类型： 

访问公众保护私人同一个类的成员是是是派生类中的成员是是没有不是会员是没有没有
“成员”指任何从类的外部访问，如从main（），从另一个类或函数。 

在我们的例子中，由类CRectangle和 CTriangle的继承的成员具有相同的访问权限，因为他们有他们的基类CPolygon： 

 1  2  3  4  5  

 CPolygon::width // protected access CRectangle::width // protected access CPolygon::set_values() // public access CRectangle::set_values() // public access 

这是因为我们已经使用了公共关键字来定义每个派生类的继承关系： 

 class CRectangle: public CPolygon { ... } 

这public关键字后的冒号（：）表示类，如下（在这种情况下，CPolygon的 ）继承的成员将拥有最方便的水平。 由于公众是最容易到达的水平，通过指定此关键字的派生类会继承所有成员具有相同的水平，他们不得不在基类中。 

如果我们像保护指定一个更严格的访问级别，所有公共基类成员在派生类中继承保护。 而如果我们指定最限制的所有访问级别： 私人 ，所有的基类成员继承为私有。 

例如，如果女儿是来自母亲 ，我们定义为一类： 

 class daughter: protected mother; 

这将设置保护的最大访问级别的成员，它继承自母亲的女儿 。 也就是说，所有成员都将成为公众母亲在女儿的保护。 当然，这不会限制女儿申报其自身的公共成员。 只从母亲继承的成员，最大的访问级别。 

如果我们没有明确指定任何继承的访问级别，编译器假定私人对于那些用struct声明类的关键字和公众声明的类。 

从基类继承的是什么？

原则上，一个派生类继承基类，除了每一个成员： 

• 它的构造函数和析构函数
• 它的运算符=（）成员
• 它的朋友

虽然基类的构造函数和析构函数是不能继承自己，它的默认构造函数（即不带参数的构造函数），析构函数总是被称为当一个新的派生类的对象被创建或销毁。