好了，今天我们来看c++面向对象编程之继承，都坐好了，秋名山码神发车了，基操勿6
一：继承的基本框架及优点：
儿子继承父亲。。
继承的好处：可以减少重复的代码
*class A : public B;
A 类称为子类 或 派生类
B 类称为父类 或 基类*
派生类中的成员，包含两大部分：
一类是从基类继承过来的，一类是自己增加的成员。
从基类继承过过来的表现其共性，而新增的成员体现了其个性。
继承的语法：class 子类 : 继承方式 父类
下面是继承的一段c++代码
class Base1
{
public:
int m_A;
protected:
int m_B;
private:
int m_C;
};
//公共继承
class Son1 :public Base1
{
public:
void func()
{
m_A; //可访问 public权限
m_B; //可访问 protected权限
//m_C; //不可访问
}
};
void myClass()
{
Son1 s1;
s1.m_A; //其他类只能访问到公共权限
}
//保护继承
class Base2
{
public:
int m_A;
protected:
int m_B;
private:
int m_C;
};
class Son2:protected Base2
{
public:
void func()
{
m_A; //可访问 protected权限
m_B; //可访问 protected权限
//m_C; //不可访问
}
};
void myClass2()
{
Son2 s;
//s.m_A; //不可访问
}
//私有继承
class Base3
{
public:
int m_A;
protected:
int m_B;
private:
int m_C;
};
class Son3:private Base3
{
public:
void func()
{
m_A; //可访问 private权限
m_B; //可访问 private权限
//m_C; //不可访问
}
};
class GrandSon3 :public Son3
{
public:
void func()
{
//Son3是私有继承，所以继承Son3的属性在GrandSon3中都无法访问到
//m_A;
//m_B;
//m_C;
}
};
总的来说就是，公共的父类继承随子类，私有的不会变，保护的随机应变，子类私有全私有。
二：同名时的处理
- 变量同名
- 函数同名
#include<iostream>
using namespace std;
class Base
{
public:
Base()
{
m_A = 100;
}
int m_A;
void func()
{
cout << "Bace func的调用" << endl;
}
};
class Son :public Base
{
public:
Son()
{
m_A = 200;
}
int m_A;
void func()
{
cout << "Son func的调用" << endl;
}
};
void text01()
{
Son s;
cout << s.m_A << endl;
cout << s.Base::m_A << endl;//加作用域
}
void text02()
{
Son s;
s.func();
s.Base::func();
}
int main()
{
text01();
text02();
system("pause");
return 0;
}三.静态成员同名时的处理
#include<iostream>
using namespace std;
class Base
{
public:
static void func()
{
cout << "Base static func" << endl;
}
static int m_A;
static void func(int m_A)//函数重载
{
cout << "Base static m_A" << endl;
}
};
int Base::m_A = 200;
class Son :public Base
{
public:
static void func()
{
cout << "Son static func" << endl;
}
static int m_A;
};
int Son::m_A = 100;
void text01()
{
//对象访问
Son s;
cout << "Base" << s.Base::m_A << endl;
cout << "Son" << s.m_A << endl;
//类名直接
cout << "Base" << Son::Base::m_A << endl;
cout << "Son" << Son::m_A << endl;
}
void text02()
{
Son s;
s.func();
s.Base::func();
Son::func();
Son::Base::func();
}
int main()
{
text01();
text02();
system("pause");
return 0;
}可以看出静态成员同名时有俩种处理方式，但是记住：
无论是什么同名处理，用：：作用域一定可以处理
四：下面我们来看一下继承中父类与子类的顺序
提到顺序，不难想到函数的，构造与析构
#include<iostream>
using namespace std;
class Base
{
public:
Base()
{
cout << "父类构造函数" << endl;
}
~Base()
{
cout << "父类析构函数" << endl;
}
};
class Son :public Base
{
public:
Son()
{
cout << "子类构造函数" << endl;
}
~Son()
{
cout << "子类析构函数" << endl;
}
};
void test01()
{
//继承中先调用父类构造，再是子类构造
//先是父类析构，再是子类析构
Son s;
}
int main()
{
test01();
system("pause");
return 0;
}这里有点父类有点像栈的先进后出
五.多继承（但在实际开发中不建议使用）
#include<iostream>
using namespace std;
class Base1
{
public:
Base1()
{
m_A = 100;
}
int m_A;
};
class Base2
{
public:
Base2()
{
m_B = 200;
}
int m_B;
};
class Son :public Base1, public Base2
{
public:
Son()
{
m_C = 300;
m_D = 400;
}
int m_C, m_D;
};
void text01()
{
Son s;
cout << "son is size:" << sizeof(Son) << " " << sizeof(s) << endl;
//16
cout << s.Base1::m_A;
}
int main()
{
text01();
system("pause");
return 0;
}从代码中我们可以看出多继承的语法是
class Son :public Base1, public Base2
用“ ，”格开，其中子类Son，自身有俩个int为8，但是它又继承了俩个父类的int，所以输出为16
