C++基础之继承

在C++中，继承的格式定义为：

class 派生类类名 : <访问限定符> 基类类名1 , <访问限定符> 基类类名2 ......{

//派生类特有的成员

};

访问限定符有3种：public 、protected 、 private。

如果为private ， 表示私有继承，即基类的所有公有或者保护成员成为派生类的私有成员 ；

如果为protected ，即基类的所有公有成员为派生类的保护成员，私有成员则依然是私有成员 ；

如果为public ，表示公有继承，基类的成员限定不变。

默认情况下是私有继承 。

]#include <iostream>
#include <stdio.h>
using namespace std;
class Base {
public:
int b1 ;
protected:
int b2 ;
private:
int b3 ;
};

class D1 : public Base{
public:
void test(){
b1 = 10 ;
b2 = 20 ;
// b3 = 30 ; 不可以访问
}
};

class D11 : public D1 {
public :
void test(){
b1 = 5 ;
b2 = 6 ;
// b3 = 7 ; 不可以访问
}
};
class D2 : private Base {
public :
void test(){
b1 = 8 ;
b2 = 9 ;
// b3 = 10 ; 不可以访问
}

};
class D22 : public D2 {
public :
void test(){
//		b1 = 11 ; 不可以访问,因为 D2 为private
//		b2 = 12 ; 不可以访问
//		b3 = 13 ; 不可以访问
}
};

class D3 : protected Base{
public:
void test(){
b1 = 15 ;
b2 = 16 ;
// b3 = 17 ; 不可以访问
}
};
class D33 : public D3{
public :
void test(){
b1 = 18 ;
b2 = 19 ;
// b3 = 20 ; 不可以访问
}
};
int main() {
D11 d1 ;
d1.b1 = 1 ;
// d1.b2 = 2 ; b2 为protected 只能由类及其派生类的成员函数所访问
//d1.b3 = 3 ;  b3 为private 只能由类的成员函数所访问

D22 d2 ;
/*
d2.b1 = 4 ; b1 为 private，所以不能访问，只能由本类的成员桉树来访问
d2.b2 = 5 ; b2为 private，所以不能访问，只能由本类的成员桉树来访问
d2.b3 = 6 ; b3 为 private，所以不能访问，只能由本类的成员桉树来访问
*/
D33 d3 ;
/*
d3.b1 = 4 ; b1 为 protected，所以不能访问，只能由本类及其派生类的成员函数来访问
d3.b2 = 5 ; b2为 protected，所以不能访问，只能由本类及其派生类的成员函数来访问
d3.b3 = 6 ; b3 为 protected，所以不能访问，只能由本类及其派生类的成员函数来访问
*/
}

访问限定的总结如下：

·公有继承时，基类中的公有成员和保护成员可被派生类中的成员函数访问，基类中仅有公有成员才可呗派生类的对象访问。

·保护继承时，将使基类中的公有成员和保护成员成为派生类的保护成员；这使得派生类的对象不能访问基类中的任何成员，而派生类的成员函数可以访问基类中的公有成员和保护成员。

·私有继承时，派生类的成员函数可访问基类中的公有成员和保护成员；派生类的对象不能访问基类中的任何成员。

不过，通过访问声明，有时候可以绕过这个限定，如下面的例子所示：

]#include <iostream>
#include <stdio.h>
using namespace std;

class Base{
public:
void func1(int i){
cout<<i<<endl ;
}
void func2(){
cout<<"A/n" ;
}
};
class Derived : private Base{
public:
void func3(){
cout<<"B/n" ;
}
Base :: func1 ;//将A中的成员声明为B的公有成员
};
int main() {
Derived b ;

b.func1(10) ;//成功
//	b.func2() ;  //错误，不能访问私有成员
b.func3() ;  //成功，可以访问类自己的公有成员
return 0;
}

对于积累的静态成员而言，不管哪种继承方式都不影响对静态成员的访问。不过，再访问时需要用“类名 :: 成员”的方式显示说明，例如：