- 继承:子类继承父类,子类的对象可以直接访问父类公有或保护成员
继承最大特点提高代码重用,也体现代码的共性与个性
派生类:继承父类的子类
基类:被继承类(父类)
继承语法:
派生类 : [继承方式] 基类
继承方式:
1.private:私有继承.默认为此继承方式.不能继承基类的私有成员.
继承基类公有成员,在派生类中相当于是私有成员.
继承基类保护成员,在派生类中相当于是私有成员.
2.public:公有继承.不能继承基类的私有成员.
继承基类公有成员,在派生类中相当于是公有成员.
继承基类保护成员,在派生类中相当于是公有成员.
3.protected:保护继承,不能继承基类的私有成员.
继承基类公有成员,在派生类中相当于是保护成员.
继承基类保护成员,在派生类中相当于是保护成员.
- 继承基础验证
#include <iostream>
#include <stdio.h>
using namespace std;
class Base
{
public:
void fun()
{
cout<<"Base fun"<<endl;
}
};
//私有继承
class Child : Base
{
private:
//被私有继承时,基类的方法相当于是如下定义形式
// void fun()
// {
// cout<<"Base fun"<<endl;
// }
};
//公有继承方式
class Child1 : public Base
{
};
int main(int argc, char const *argv[])
{
Base b1;
b1.fun();
Child1 c;
c.fun();//基类里面的公有fun函数被继承啦
return 0;
}
- 继承结构
#include <iostream>
#include <stdio.h>
using namespace std;
class Base
{
private:
int a;
int b;
};
class Child : Base
{
private:
int c;
};
int main(int argc, char const *argv[])
{
cout<<sizeof(Base)<<endl;//输出 8
cout<<sizeof(Child)<<endl;//输出 12
//结论:
// 从sizeof(Child)大小看出,派生类必定存在一个基类对象
//与继承方式 基类成员访问模式无关
return 0;
}
- 实例化派生类对象,首先调用基类构造函数实例化一个匿名基类对象
如果是系统默认无参构造可以不写
#include <iostream>
#include <stdio.h>
using namespace std;
class Base
{
public:
Base(int _a)
{
a=_a;
cout<<"Base constructor"<<endl;
}
private:
int a;
int b;
};
class Child : Base
{
public:
Child(int _b):Base(1)
{
cout<<"Child constructor"<<endl;
}
//错误写法
// Child(int _b)
// {
// Base(1);//错在这样写。
// cout<<"Child constructor"<<endl;
// }
private:
int c;
};
int main(int argc, char const *argv[])
{
Child c1(1);//输出 Base constructor
// Child constructor 可以看出先构造了基类对象再构造子类对象。
return 0;
}
- 继承后用 实例化对象后 类的成员变量内存排列情况
- 用C指针的方式访问对象的私有成员。
#include <iostream>
#include <stdio.h>
using namespace std;
class Base
{
public:
Base(int _a,int _b)
{
a=_a;
b=_b;
cout<<"Base constructor"<<endl;
}
void fun()
{
cout<<"fun()"<<endl;
}
private:
int a;
int b;
};
class Child : public Base
{
public:
Child(int _c,int _a,int _b):Base(_a,_b)
{
c=_c;
cout<<"Child constructor"<<endl;
}
//错误写法
// Child(int _b)
// {
// Base(1);//错在这样写。
// cout<<"Child constructor"<<endl;
// }
private:
int c;
};
int main(int argc, char const *argv[])
{
Child c(100,200,300);
//如何用c指针的方式去访问对象的成员变量值:
int * ptr_int = (int*)&c;
cout<<*ptr_int<<endl; //输出200
cout<<*(ptr_int+1)<<endl; //输出300
cout<<*(ptr_int+2)<<endl; //输出100
//从上面的代码输出结果我们一目了然的看出 基类的成员变量和子类的成员变量排列顺序
//基类的成员变量在前面,子类的
c.fun();//这个访问可以看做:c.匿名对象.fun() 因为前面说过了,先构造一个基类对象。
return 0;
}
- 继承后 析构问题
#include <iostream>
#include <stdio.h>
using namespace std;
class Base
{
public:
Base(int _a,int _b)
{
a=_a;
b=_b;
cout<<"Base constructor"<<endl;
}
void fun()
{
cout<<"fun()"<<endl;
}
~Base()
{
cout<<"base disconstructor"<<endl;
}
private:
int a;
int b;
};
class Child : public Base
{
public:
Child(int _c,int _a,int _b):Base(_a,_b)
{
c=_c;
cout<<"Child constructor"<<endl;
}
//错误写法
// Child(int _b)
// {
// Base(1);//错在这样写。
// cout<<"Child constructor"<<endl;
// }
~Child()
{
cout<<"Child disconstructor"<<endl;
}
private:
int c;
};
int main(int argc, char const *argv[])
{
Child c(100,200,300);//输出 Child disconstructor
// base disconstructor
//由此可以看出 首先调用派生类析构函数,再调用基类析构函数
//同时也满足以前原理 先构造的后释放。
return 0;
}