目录
C++三种继承方式
C++有三种继承方式:public protected private
属性方式为
class [派生类名称] : [继承方式] [继承类名称]
{
//继承类中做相应动作
};
构造函数
1.子类继承父类时,如果父类没有定义构造函数,则编译器会后台添加无参构造函数,且子类默认使用父类的无参构造函数,此时子类构造函数可以任意书写
2.子类继承父类,父类仅有一个无参构造函数,则子类默认使用父类无参构造函数,且此时子类构造函数可以任意书写
class A
{
public:
// A(){} //写与不写,对子类继承时构造函数书写无影响。
//写无参构造函数目的是实现一些初始化等工作,如果没有则可以不写
int m;
};
class B : public A
{
public:
// B(int a){n = a;}//默认继承基类的无参构造函数
//如果不写构造函数,则后台对B类生成一个无参构造函数,且继承基类A的无参构造函数
int n;
}
3.子类继承父类,父类有有参构造函数,则子类必须显示指定继承方式且对父类构造函数初始化
class A
{
public:
A(int m){ n = m;}//因写了构造函数,编译器不在生成默认的无参构造函数
int n;
}
class B : public A
{
public:
// B(int i) { j = i; } //报错,提示 “A” 没有合适的默认构造函数可用
B(int i):A(i){ j = i; } //子类的构造函数必须显式调用父类的有参构造函数
int j;
};
析构
先构造的后析构,后构造的先析构
继承
基类A,后续以此基类进行讨论继承关系。
class A
{
public:
A(int t){ j = t; cout << "基类A" << endl;};
void pubA(){ k = 0;}//正确,private只能本类成员函数访问
int i;
protected:
void proA(){cout << "基类proA! " << endl;};
int j;
private:
void priA();
int k;
};
public继承
派生类继承的基类中的 public 和 protected成员变量仍旧是 public 和 protected,派生类不能访问基类的private成员变量,派生类定义的变量不能访问基类的protected成员(其实就是protected成员函数只能在本类和其子类访问,而不能在其类实例访问一样)
class B : public A
{
public:
B(){
cout << "派生类B!" << endl;
i = 0;//正确
j = 0;//正确
k = 0;//错误,无法访问基类的private成员
}
void pubB();
int iB;
protected:
void proB();
int jB;
private:
void priB();
int kB;
};
int main()
{
B b;
b.pubA(); //正确,继承之后为public
// b.proA(); //报错,无法访问protected成员(在"A"类中声明)
}
protected继承
派生类继承的基类 public 和 protected 成员变量后变为自己 protected,即基类的成员变量只能在派生类的成员函数中访问,而不能在实例中访问。派生类不能访问基类的private成员变量
class B : protected A
{
public:
void pubB(){cout << "派生类pubB;" << endl;}
int iB;
protected:
void proB(){ cout << "派生类proB;" << endl; proA(); }//正确
// void proB_priA() { iB = k; } //错误,不能访问基类的private成员变量或函数
};
int main(void)
{
B b;
// b.pubA(); //报错,A::pubA不可访问,因为“B”使用“protected”从“A”继承
b.proB(); //正确,打印 派生类proB; 基类proA!
}
private继承
派生类继承的基类 public 和 protected 成员变量后变为自己的 private 成员变量,但派生类仍不能访问基类的 private 成员变量和函数,虽然是以 private 继承的
class B : private A
{
public:
void pubB(void){ pubA(); proA(); } //正确,相当于访问自己类的private成员函数
void pubB_priA(void){ priA(); } //错误,不能访问基类的private成员函数
};
组合
组合其实就是一个类调用另外一个类,并对其进行实例化
访问权限
组合只能访问调用类的public
class A
{
public:
A(){ cout << "基类A!" << endl;}
void pubA(void){ cout << "pubA~~~" << endl; }
protected:
void proA(void) { cout << "proA~~~" << endl; }
private:
void priA(void) { cout << "priA~~~" << endl; }
}
class B
{
public:
B() { cout << "继承类B!" << endl; }
void pubB(void) { a.pubA(); cout << "pubB~~~" << endl; }//正确,可以访问public成员函数
protected:
void proB(void) { a.proA(); cout << "proB~~~" << endl; }//错误,不能访问A类的public以外的成员变量和函数。报错信息:“A::proA”: 无法访问 protected 成员(在“A”类中声明)
private:
A a;
};
构造/析构函数调用顺序
组合调用构造函数的顺序是:先依次调用内嵌类的构造函数(依次是按定义顺序,而非赋值顺序),在调用本类的构造函数。输出时正好以相反的顺序调用析构函数
class A
{
public:
A() { cout << "A" << endl; }
~A() { cout << "~A" << endl; }
};
class B
{
public:
B() { cout << "B" << endl; }
~B() { cout << "~B" << endl; }
};
class C
{
public:
C() { cout << "C" << endl; }
~C() { cout << "~C" << endl; }
private:
A a;
B b;
};
int main(void)
{
C c;
return 0;
}
输出
初始化
当调用内嵌类的含参构造函数时,需对其初始化。初始化必须在构造函数的初始化列表中完成
string s = "Hello";
class A
{
public:
A(int a) { iA = a; }
A(string s) { iS = s; cout << "A:iS : " << iS << endl;}
private:
int iA;
string iS;
};
class C
{
public:
C(int b) : a(b) { iB = b; } //a(b)进行类实例初始化
C(string s) : a(::s) { iS = s; cout << "C:cS :" << iS << endl;} //::s 表示使用全局变量s
private:
int iB;
string iS;
A a;
};
int main(void)
{
C c("World!");
return 0;
}
输出