// 这个PERSON_H_是自己命名的，不必跟文件名一致
#ifndef PERSON_H_
#define PERSON_H_
// 以下内容会被原封不懂的插入#include "person.h"语句处
#include <iostream>
#include <string>
using namespace std;
// 基类
class Person
{
private:
string _name;
int _age;
// 静态数据成员：见下注释，记录类创建了多少个
static int count;
public:
// const静态数据成员：见下注释，记录创建对象的基类名字
static const string title;
// 常规构造函数，接收0、1、2个参数
Person(const string &name = "未命名", int age = 0);
~Person();
void show() const;
};
// 派生类：指明基类是Person，继承方式为public，
// 可访问public，protected，不可访问private
class Singer : public Person
{
private:
string _style;
public:
Singer(const string &name = "未命名", int age = 0,
const string &style = "无风格");
void show() const;
};
#endif
- 静态数据成员：
- 功能：作为声明变量的类所创建的对象的共享变量
- 声明及初始化：类声明中声明，在类方法文件中初始化，防止多次引入头文件,导致的多次初始化
- 静态const数据成员
- 声明及初始化：同静态数据成员
- 功能：创建的常量生命周期跟类同长，避免频繁创建销毁
// 注意路径的写法，同级目录可只写文件名
#include "./person.h"
// 基类中静态成员初始化
int Person::count = 0;
// 基类中const静态成员初始化
const string Person::title = "Person类";
// 基类的成员函数定义
// 类构造函数：分号后为成员初始化列表形式，只能用于构造函数
// 分号前括号内为形参，分号后_name(name)，意义同_name=name;
Person::Person(const string &name,
int age) : _name(name), _age(age) { count += 1; }
~Person(){ count -= 1; };
// 基类的常规成员函数
void Person::show() const
{
cout << "姓名是：" << _name << endl;
cout << "年龄是：" << _age << endl;
cout << "当前Person个数："<< count << endl;
}
// 派生类的成员函数定义
// 派生类构造函数：成员初始化列表，且调用了基类的构造函数
Singer::Singer(const string &name, int age,
const string &style) : Person(name, age), _style(style){};
// 派生类的常规成员函数
void Singer::show() const
{ // 派生类中调用基类的成员函数方法
Person::show();
cout << "风格为：" << _style << endl;
// 生成了15个*号
string s(15, '*');
cout << s << endl;
}
// 注意路径的写法，同级目录可只写文件名
#include "./person.h"
int main()
{
// 类数组列表初始化
Singer singer[3] = {Singer("小明", 15, "hip-hop"),
Singer("小李", 13, "blue")};
singer[0].show();
singer[1].show();
// 这里调用的是基类Person的show函数
singer[2].Person::show();
// 调用默认构造函数，生成一个对象，count增加1
Singer temp;
temp.show();
}
>> g++ main.cpp person.cpp person.h
>> ./a.out
姓名是：小明
年龄是：15
当前Person个数：3
风格为：hip-hop
***************
姓名是：小李
年龄是：13
当前Person个数：3
风格为：blue
***************
姓名是：未命名
年龄是：0
当前Person个数：3
姓名是：未命名
年龄是：0
当前Person个数：4
风格为：无风格
名词释义
| 名称 | 释义 |
|---|---|
| 多态 | 即具有多种形态，同一方法，在派生类和基类中的行为是不同的 |
| 多态用途 | 函数虚实参传递时可用这一特性，实参为派生类对象(singer)或地址(&singer)，虚参为基类绑定(&rp)或指针(*pp) |
| 重载问题 | 若有基类有重载声明，派生类不可单独重载其中一个，需全部重写 |
| 派生类不可继承函数 | 构造、析构、=(用目标对象修改已初始化对象) 函数 |
| 能默认生成函数 | 构造(空的)、析构(空的)、=(默认逐数据成员项复制，遇到指针浅浅复制)、& 函数 |
多态调用指向（见2.3.1代码）
派生类（&基类）
...
// 基类
class Person
{
private:
...
public:
...
// 只在基类增加virtual关键字即可
virtual void show() const;
...
// 虚析构函数：基类内声明，规范析构函数调用顺序，
// 先调用派生类析构函数，再调用基类析构函数
// 若无此句，在main.cpp中，a、b完成后将只调用基类的析构函数
virtual ~Person(){}
};
class Singer : public Person
{
...
}
...
#endif
#include "person.h"
int main()
{
Singer singer("小明", 15, "hip-hop");
// 以下三个都是调用派生类的show函数，若person.h中无virtual
// 以下前两个调用的是基类的show函数，最后个还是派生类的show函数
// 注意体会将其应用在函数虚实参传递中的效果
// a、基类引用可以绑定派生类
Person &rp = singer;
rp.show();
// b、基类指针可以指向派生类
Person *pp = &singer;
pp->show();
singer.show();
}
#include <iostream>
#include <string>
using namespace std;
// 基类：构造、析构、复制函数均采用默认
class Person
{
public:
// 纯虚函数:基类中，函数后加=0即可生成纯虚函数，同时将基类转换成ABC
// 允许：纯虚函数是否定义都可，=0也可以应用在非虚函数上
virtual void show() const = 0;
// 虚析构函数：规范析构函数调用顺序
virtual ~Person(){};
};
// 派生类Singer：构造、析构、复制函数均采用默认
class Singer : public Person
{
public:
// 派生类必须实现纯虚函数，否则报错
void show() const { cout << "这是singer类" << endl; };
};
// 派生类Actor：构造、析构、复制函数均采用默认
class Actor : public Person
{
public:
// 派生类必须实现纯虚函数，否则报错
void show() const { cout << "这是actor类" << endl; };
};
// 主函数
int main()
{
// ABC类指针数组：后续用于指向派生类
Person *p[3];
Singer singer;
Actor actor;
p[0] = &singer;
// 输出：这是singer类
p[0]->show();
p[1] = &actor;
// 输出：这是actor类
p[1]->show();
// 编译错误：ABC不可创建对象
// p[2]->show();
}
定义：能够使用两个或多个基类派生出新的类，组合功能
虚基类：使得从多个类（他们基类相同）派生出的对象只继承一个基类对象，防止二义性
构造函数规则：对虚基类，除默认构造函数，否则必须显式调用虚基类的某个构造函数
继承关系示例
代码示例
#include <iostream>
using namespace std;
class B{
public:
void show(){cout<<"B"<<endl;};
};
// 指定B为虚基类
class C:virtual public B{
public:
void show(){cout<<"C"<<endl;};
void cal(){cout<<"C"<<endl;};
};
class D:public C{};
// 指定B为虚基类
class E:virtual public B{
public:
void cal(){cout<<"E"<<endl;};
};
class F:public D,public E{};
int main() {
F m;
// 用的是类C的
m.show();
// m.cal()会产生二义性，
// 最好在类F中重写此方法
m.D::cal();
return 0;
}
#ifndef PERSON_H_
#define PERSON_H_
#include <iostream>
#include <string>
using namespace std;
class Person
{
private:
// 动态内存分配的核心：此处只声明指针，未分配内存
char *_name;
// 用于存储字符串长度，不包含结尾\0
int len;
public:
// 默认构造函数
Person();
// 重载默认构造函数
Person(const char *name);
// 复制构造函数
Person(const Person &p);
// 析构函数
~Person();
// 常规函数：显示对象名
void show() const;
// 重载赋值运算符=
Person &operator=(const Person &p);
};
#endif
#include "./person.h"
Person::Person()
{
// 赋值静态数据成员，见2.1节
static const char *s = "未命名";
// 字符串长度：传入字符串指针
len = strlen(s);
// new分配内存空间，此处用[]，对应于析构函数
_name = new char[len + 1];
// 字符串深拷贝
strcpy(_name, s);
cout << "默认构造函数被调用" << endl;
};
Person::Person(const char *name)
{
// 同构造函数
len = strlen(name);
_name = new char[len + 1];
strcpy(_name, name);
cout << _name << "的构造函数被调用" << endl;
};
Person::Person(const Person &p)
{
this->len = p.len;
_name = new char[len + 1];
strcpy(_name, p._name);
cout << _name << "的复制构造函数被调用" << endl;
};
Person::~Person()
{
// 析构函数对应与构造函数
delete[] _name;
cout << _name << "的析构函数被调用" << endl;
};
Person &Person::operator=(const Person &p)
{
// 检查是否为自我复制，若是且无此判断语句
// 则delete语句会先清空内存导致无值可赋
if (this == &p)
return *this;
// 若非自我复制，清空_name指向的内存
delete[] _name;
// 以下同构造函数写法
len = strlen(p._name);
_name = new char[len + 1];
strcpy(_name, p._name);
cout << _name << "赋值运算符被调用" << endl;
return *this;
};
void Person::show() const
{
cout << "姓名是：" << _name << endl;
};
// 注意路径的写法，同级目录可只写文件名
#include "./person.h"
int main()
{
// 复习下：在堆中创建对象，per？是指向对象Person的指针
// a、调用默认构造函数
Person *per1 = new Person;
// b、调用重载的默认构造函数
Person *per2 = new Person("per2");
// c、调用复制构造函数：注意传入的是*per2即Person对象
Person *per3 = new Person(*per2);
// 指针调用类方法的写法
per1->show();
per2->show();
per3->show();
// 此处调用重载的赋值运算符=
*per3 = *per1;
// 销毁类对象指针指向的内存空间，
// 即调用Person对象的析构函数
delete per1;
delete per2;
delete per3;
}
默认构造函数被调用
per2的构造函数被调用
per2的复制构造函数被调用
姓名是：未命名
姓名是：per2
姓名是：per2
未命名赋值运算符被调用
未命名的析构函数被调用
per2的析构函数被调用
未命名的析构函数被调用