使代码可以复用的最重要的手段
,它允许程序员在保class Person
{
public:
void Print()
{
cout << "name:" << _name << endl;
cout << "age:" << _age << endl;
}
protected:
string _name = "peter"; // 姓名
int _age = 18; // 年龄
};
// 继承后父类的Person的成员(成员函数+成员变量)都会变成子类的一部分。这里体现出了
//Student和Teacher复用了Person的成员。下面我们使用监视窗口查看Student和Teacher对象,可
//以看到变量的复用。调用Print可以看到成员函数的复用。
class Student : public Person
{
public:
void Print()
{
cout << "name:" << _name << endl;
cout << "age:" << _age << endl;
}
protected:
int _stuid; // 学号
};
class Teacher : public Person
{
protected:
int _jobid; // 工号
};
int main()
{
Student s;
Teacher t;
s.Print();
t.Print();
return 0;
}
下面我们看到Person是父类,也称作基类。Student是子类,也称作派生类
这里可以不写继承方式,默认式private私有继承。
类成员/继承方式 | public继承 | protected继承 | private继承 |
---|---|---|---|
基类的public成员 | 派生类的public成员 | 派生类的protected成员 | 派生类的private成员 |
基类的protected成员 | 派生类的protected成员 | 派生类的protected成员 | 派生类的private成员 |
基类的private成员 | 在派生类中不可见 | 在派生类中不可见 | 在派生类中不可 见 |
总结:
- 基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私
有成员还是被继承到了派生类对象中,但是语法上限制派生类对象不管在类里面还是类外面
都不能去访问它。- 基类private成员在派生类中是不能被访问,如果基类成员不想在类外直接被访问,但需要在
派生类中能访问,就定义为protected。可以看出保护成员限定符是因继承才出现的。- 实际上面的表格我们进行一下总结会发现,基类的私有成员在子类都是不可见。基类的其他
成员在子类的访问方式 == Min(成员在基类的访问限定符,继承方式),public > protected> private。- 使用关键字class时默认的继承方式是private,使用struct时默认的继承方式是public,不过
最好显示的写出继承方式。- 在实际运用中一般使用都是public继承,几乎很少使用protetced/private继承,也不提倡
使用protetced/private继承,因为protetced/private继承下来的成员都只能在派生类的类里
面使用,实际中扩展维护性不强。
class Person
{
public:
void Print()
{
cout << "name:" << _name << endl;
cout << "age:" << _age << endl;
}
//protected://这里把保护改成私有
private:
string _name = "peter"; // 姓名
int _age = 18; // 年龄
};
class Student : public Person
{
public:
Student()
{
cout << _name << endl;//改成私有之后派生类(子类)就访问不到基类(父类)的成员了,就会报错了
}
protected:
int _stuid; // 学号
};
切片 或者切割。寓意把派生类中父类那部分切来赋值过去。
这里为什么叫做赋值兼容转换呢?
int a = 10;
const double& b = a;
隐式类型转换是会生成临时变量,临时变量是具有常属性的,
所以上述代码的引用前面需要加上const修饰这个临时的变量。class Person
{
protected:
string _name; // 姓名
string _sex; // 性别
int _age; // 年龄
};
class Student : public Person
{
public:
int _No; // 学号
};
void Test()
{
Student sobj;
// 1.子类对象可以赋值给父类对象/指针/引用
Person pobj = sobj;
Person& rp = sobj;//从这里就可以看出,这里并没有生成临时变量,如果生成了,就要再最前面加上const进行修饰
}
子类成员将屏蔽父类对同名成员的直接访问
,这种情况叫隐藏,也叫重定义。
(在子类成员函数中,可以用 基类::基类成员 显示访问)需要注意的是如果是成员函数的隐藏,只需要函数名相同就构成隐藏。
class Parent
{
protected:
int _age = 20;
};
class Child : public Parent
{
public:
void func()
{
cout << _age << endl;
cout << Parent::_age << endl;
}
protected:
int _age = 21;
};
int main()
{
Child d;
d.func();
return 0;
}
class A
{
public:
void fun()
{
cout << "func()" << endl;
}
};
class B : public A
{
public:
void fun(int i)
{
A::fun();
cout << "func(int i)->" << i << endl;
}
};
问题:A类和B类中这两个fun函数构成什么关系。
a:没有关系。b:重载。c:重写。d:隐藏
这里a具有很大的疑惑性,同样的b也有同样的疑惑。
但是你说a没有关系吧,但是B继承了A,但是你说b吧,重载的其中一个条件就是再同一个作用域,显然两个fun分别再不同的作用域里面,所以可以排除a和b,c我们还没学也直接排除掉,所以只能选择d隐藏。
答案:如果是成员函数,只要函数名相同就构成隐藏,返回值和参数可以不相同
6个默认成员函数,“默认”的意思就是指我们不写,编译器会变我们自动生成一个,那么在派生类
中,这几个成员函数是如何生成的呢?
class Person
{
public:
Person(const char* name = "peter")
: _name(name)
{
cout << "Person()" << endl;
}
Person(const Person& p)
: _name(p._name)
{
cout << "Person(const Person& p)" << endl;
}
Person& operator=(const Person& p)
{
cout << "Person operator=(const Person& p)" << endl;
if (this != &p)
_name = p._name;
return *this;
}
~Person()
{
cout << "~Person()" << endl;
}
protected:
string _name; // 姓名
};
class Student : public Person
{
public:
protected:
int _id;
};
当派生类中什么多没写的时候
这会看到调用了基类的默认构造和析构。
class Student : public Person
{
public:
Student(const char* name, int id)//直接在派生类中构造基类中的成员变量。
:_name(name)
, _id(id)
{}
protected:
int _id;
};
但是报错了。
原因是,虽然派生类继承了基类的成员变量,但是派生类并不能对继承过来的成员变量进行初始化,而是要基类自己进行初始化,而如果要在派生类中初始化基类中的成员变量,就要显示调用基类的默认构造。
class Student : public Person
{
public:
Student(const char* name, int id)
: _id(id)
, Person(name)//显示调用基类的默认构造
{}
protected:
int _id;
};
那么,思考一个问题就是,先构造父类的还是先构造子类的呢?
再学初始化列表的时候我们学了,初始化列表初始化顺序是按照变量的声明顺序初始化的
,显然父类是比子类更先声明的,所以一定是先构造父类,再构造子类。
//基类的拷贝构造
Person(const Person& p)
: _name(p._name)
{
cout << "Person(const Person& p)" << endl;
}
//派生类的拷贝构造
Student(const Student& s)
:_id(s._id)
,Person(s)//直接传s本身过去,因为赋值兼容转换的缘故,这里会将s中基类的部分切割过去再实现基类的拷贝构造
{}
Student& operator=(const Student& s)
{
if (this != &s)
{
_id = s._id;
Person::operator=(s);//这里要注意要加上基类的作用域,因为派生类的operator=和基类的operator=构成隐藏关系
}
return* this;
}
~Student()
{
~Person(););//显示调用基类的析构函数(前面章节中我们讲过,析构函数是可以显示调用的)
}
但是这里我们调用不到基类的析构函数。
这里同样也是一个特殊处理。
这里子类和父类的析构函数构成隐藏关系。 由于后面多态的原因,析构函数别特殊处理,函数名都会被统一处理成destructor()
~Student()
{
Person::~Person(););//所以这里要加作用域显示调用基类的析构函数
}
但是这里会发现析构了两次Person。
这里同样做了特殊处理。
编译器为了先调用子类的析构在调用基类的析构函数,父类的析构函数会在子类析构后自动调用
构造:先父后子。
析构:先子后父。这样做是因为如果先清理了父类的数据,可能子类还需要用到父类的数据,就存在安全隐患。
友元关系不能继承,也就是说基类友元不能访问子类私有和保护成员
class Student;
class Person
{
public:
friend void Display(const Person& p, const Student& s);
protected:
string _name; // 姓名
};
class Student : public Person
{
public:
friend void Display(const Person& p, const Student& s);//如果要放访问派生类中的成员,也得成为派生类的朋友。
protected:
int _stuNum; // 学号
};
void Display(const Person& p, const Student& s)
{
cout << p._name << endl;
cout << s._stuNum << endl;
}
基类定义了static静态成员,则整个继承体系里面只有一个这样的成员。无论派生出多少个子
类,都只有一个static成员实例 。
这个方法可以用来计算实例化了多少个对象。
class Person
{
public:
Person() { ++_count; }
protected:
string _name; // 姓名
public:
static int _count; // 统计人的个数。
};
int Person::_count = 0;
class Student : public Person
{
protected:
int _stuNum; // 学号
};
class Graduate : public Student
{
protected:
string _seminarCourse; // 研究科目
};
int main()
{
Student s1;
Student s2;
Student s3;
Graduate s4;
cout << " 人数 :" << Person::_count << endl;
Student::_count = 0;
cout << " 人数 :" << Person::_count << endl;
return 0;
}
单继承:一个子类只有一个直接父类时称这个继承关系为单继承
多继承:一个子类有两个或以上直接父类时称这个继承关系为多继承
菱形继承:菱形继承是多继承的一种特殊情况
菱形继承的问题:从下面的对象成员模型构造,可以看出菱形继承有数据冗余和二义性的问题。
在Assistant的对象中Person成员会有两份
class Person
{
public:
string _name; // 姓名
};
class Student : public Person
{
protected:
int _num; //学号
};
class Teacher : public Person
{
protected:
int _id; // 职工编号
};
class Assistant : public Student, public Teacher
{
protected:
string _majorCourse; // 主修课程
};
int main()
{
Assistant a;
a._name = "peter"; // 这样会有二义性无法明确知道访问的是哪一个
// 需要显示指定访问哪个父类的成员可以解决二义性问题,但是数据冗余问题无法解决
a.Student::_name = "xxx";
a.Teacher::_name = "yyy";
return 0;
}
虽然加上作用域暂时解决了二义性的问题,但是并没有解决冗余性的问题。比如这里的Person类,如果不仅仅只有_name这一个成员变量呢?如果还有像_age年龄,_addr家庭住址这样的只有唯一性的数据呢?这样子还需要存放两份吗?
class Person
{
public:
string _name; // 姓名
};
class Student : virtual public Person
{
protected:
int _num; //学号
};
class Teacher : virtual public Person
{
protected:
int _id; // 职工编号
};
class Assistant : public Student, public Teacher
{
protected:
string _majorCourse; // 主修课程
};
int main()
{
Assistant a;
a.Student::_name = "xxx";
a.Teacher::_name = "yyy";
a._name = "peter";
}
从上面我们可以看到这个时候_name只存了一份,解决了代码冗余和二义性。
我们底层来了解一下虚继承的实现。
class A
{
public:
int _a;
};
class B : public A
//class B : virtual public A
{
public:
int _b;
};
class C : public A
//class C : virtual public A
{
public:
int _c;
};
class D : public B, public C
{
public:
int _d;
};
int main()
{
D d;
d.B::_a = 1;
d.C::_a = 2;
d._b = 3;
d._c = 4;
d._d = 5;
return 0;
}
如果我们写成虚继承的方式呢?
从上面我们确实看到了A中的变量只存了一份。
而且最奇怪的是3和4上面的是什么呢?
is-a的关系
。也就是说每个派生类对象都是一个基类对象。has-a的关系
。假设B组合了A,每个B对象中都有一个A对象。优先使用对象组合,而不是类继承 。
白箱复用(white-box reuse)
。术语“白箱”是相对可视性而言:在继承方式中,基类的黑箱复 用(black-box reuse)
,因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。