一、类与类之间关系:
- 1、类与类之间可能会存在共性。
- 2、类与类之间必定会有差异。
- 3、为了节约开发时间和代码量,我们在设计类时可以把类的共享代码,抽象出来形成一个基础类(基类)。
- 4、使用基类+差异生成一个新的类的叫派生类
二、继承的语法
- 1、在设计一个类时如果已有的类中有它需要的成员,它可以从已有的类中继承那些成员
- 被继承的类叫 父类 或 基类
- 继承类叫作 子类 或 派生类
class 类名 : 继承方式 基类1,继承方式 基类2,...
{
}
- 2、子类会完全继承父类中的所有成员(包括哪些能访问的和不能访问的)。
3、在设计类时如何形成继承的关系?
类的设计:
a、根据问题找对象
b、把对象中我们需要的属性和行为抽象出来
c、把抽象出的结果记录在一个class中形成一个类
d、把class类实例化构造对象
e、对象调用成员函数解决问题
继承就是在对对象抽象的结果进行归纳总结,找出它们的共性形成基类,再把基类+差异派生出子类。
4、 继承的优点:代码复用。
子类在继承父类后可以节约大量的代码、节省开发时间、缩短开发周。5、 继承的缺点:
a、继承会提高类与类之间的耦合度
b、会降低代码的安全性和可维护性
三、使用继承要注意的问题
1、继承虽然可以获取父类中的所有成员,但子类中可以隐藏父类中的同名成员。
2、父子类中的函数不可以形成重载,只有在同一个作用域下的同名不同参、const属性的函数才能形成重载。
3、父类中的成员在子类的访问属性。
- 父类中的 public 在子类中 可以访问
- 父类中的 protected 在子类中 可以访问
- 父类中的 private 在子类中 不可以访问
4、继承的方式
- 不同的继承方式会影响父类成员变量成子类成员后它们的访问属性,也就是继承来的成员在类外的访问属性。
下面的图中的 继承方式不会影响基类在子类中的访问属性 因为在子类的访问属性 是由基类中的访问属性决定的继承方式的不同 只会影响 继承过来的在类外的访问属性。
public 不变
protected 公有变保护,其它不变
private 全部变成私有的
总结:
- 1)基类的私有成员在派生类中不能被访问,如果一些基类成员不想被基类对象直接访问,可以定义为保护成员,这样子类还可以访问
- 2)public继承是一个接口继承,保持is-a原则(2.是什么??),每个父类可用的成员对子类也可用,因为每个子类对象也是一个父类对象。
- 3)protect/private继承基类的部分成员并未成为子类的一部分,是has-a的关系原则(3.是什么?)这种继承关系很少用,一般用public继承关系。
- 4)不管哪种继承关系,在派生类内部都可以访问基类中的公有成员和保护成员,但是子类中的成员不能访问父类中的私有成员。
- 5)使用struct时的默认继承关系是public,而class时的默认继承关系是private,最好是把继承方式写出来。
5、继承与转换
- 1)子类对象可以赋值给父类对象。
- 2)父类对象不可以赋值给子类对象。
- 3)父类对象的指针和引用可以指向子类对象。
- 4)子类对象的指针和引用不能指向父类对象,但是可以通过强制转化完成 代码测试
6、继承体系中的作用域
- (1)在继承体系中基类和派生类都有独立的作用域。
- (2)子类和父类中有同名成员,子类成员将屏蔽父类成员的直接访问。(在子类成员函数中,可以使用基类::基类成员访问)
- (3)注意尽量不要在继承体系中定义同名的成员。 代码测试
7、派生类的默认成员函数
- 在继承关系里,派生类中如果没有显示定义这六个成员函数,编译系统则会默认合成六个成员函数,即构造函数、拷贝构造函数、析构函数、赋值操作符重载、取地址操作符重载、const修饰的取地址操作符重载。 代码测试
8、单继承和多重继承
- (1)单继承:一个子类只有一个直接父类
- (2)多继承:一个子类有两个或以上个直接父类
9、菱型继承
菱形继承对象模型:
10、基类定义了static成员,则整个继承体系里面只有一个这样的成员。无论派生出多少个子类,都只有一个static成员实例
五、虚函数
1、子类中会隐藏父类中的同名函数,这种关系叫作隐藏。(详解请看 成员函数的重载、覆盖与隐藏)
2、在同一作用域下的同名函数,这种关系叫作重载。(详解请看 成员函数的重载、覆盖与隐藏)
3、如果父类中的函数添加 virtual 关键字,这种函数就叫作虚函数,子类中会覆盖父类同名的虚函数。
4、虚函数是实现多态的基础。
六、继承的构造、析构、拷贝
1、在继承时先调用父类的构造函数,再调用子类的构造函数
2、在继承中先调用子类的析构,再调用父类的析构。
3、在调用拷贝构造时会先调用父类的拷贝构造,再调用子类的拷贝构造。
4、在C++中继承可以有多个父类,在构造时会按继承的顺序调用父类的构造函数。
5、在析构时子类会先调用自己的析构函数,然后按照继承表的逆序调用析构函数。
课前准备:
实现一个学生类
成员变量:姓名、性别、年龄、学号
成员函数:吃饭、睡觉、学习
实现一个教师类
成员变量:姓名、性别、年龄、工号
成员函数:吃饭、睡觉、授课
实现一个班长:
#include <iostream>
#include <string.h>
using namespace std;
class Man
{
public:
char name[20];
char sex;
short age;
Man(const char* _name="",char _sex='f',short _age=1)
{
strcpy(name,_name);
sex = _sex;
age = _age;
}
void eat(const char* food = "饭")
{
cout << "我在吃:" << food << endl;
}
virtual void sleep(void)
{
cout << "我累了,我要休息"<< endl;
}
};
class Student : public Man
{
int stu_id;
public:
Student(const char* _name="",char _sex='m',
short _age=8,int _stu_id=180601)
{
strcpy(name,_name);
sex = _sex;
age = _age;
stu_id = _stu_id;
}
void sleep(void)
{
cout << "我学习累了,我要休息"<< endl;
}
void study(void)
{
cout << "怕什么真理无穷,进一步有进一步的欢喜" << endl;
}
};
class Teacher : public Man
{
int work_id;
public:
Teacher(const char* _name="",char _sex='m',
short _age=26,int _work_id=161001)
{
strcpy(name,_name);
sex = _sex;
age = _age;
work_id = _work_id;
}
void lecture(void)
{
cout << "传道、授业、解惑" << endl;
}
void sleep(void)
{
cout << "我上课累了,我要休息"<< endl;
}
};
int main()
{
Man* m = new Student;
m->eat();
m->sleep();
m = new Teacher;
m->eat();
m->sleep();
}
#include <iostream>
#include <string.h>
using namespace std;
class Zoon
{
protected:
char type[20];
char name[20];
public:
Zoon(const char* type,const char* name)
{
strcpy(this->type,type);
strcpy(this->name,name);
cout << "构造一只动物" << endl;
}
void eat(void)
{
cout << name << "在吃食物" << endl;
}
~Zoon()
{
cout << "一只动物去世了" << endl;
}
};
class Dog : public Zoon
{
public:
Dog(const char* type,const char* name):Zoon(type,name)
{
cout << "构造一条狗" << endl;
}
void cry(void)
{
cout << name << ":汪汪" << endl;
}
~Dog()
{
cout << "一只狗去世了" << endl;
}
};
class Mall : public Zoon
{
public:
Mall(const char* type,const char* name):Zoon(type,name)
{
}
void cry(void)
{
cout << name << ":买买买" << endl;
}
};
int main()
{
//Mall t("波斯","天猫");
//t.cry();
Dog g("博美","樱桃");
g.cry();
}
#include <iostream>
using namespace std;
class A
{
public:
void func1()
{
cout << "func1" << endl;
}
void func2()
{
cout << "func2" << endl;
}
int i;
};
class B: protected A
{
public:
B(int a)
{
//想要访问 i变量 要加域限定符
A:: i= a;
}
void func3()
{
//同理
A::func1();
cout << "func3" << endl;
}
void func4()
{
//当继承方式为protected 继承时 公有-> 保护 外部无法访问 要给一个接口
cout << i << endl;
cout << "func4" << endl;
}
};
int main()
{
B b(5);
//b.func1();
//b.func2();
b.func3();
b.func4();
}
#include <iostream>
using namespace std;
class Person
{
public:
void Display()
{
cout << _name << endl;
}
protected:
string _name;
};
class Student : public Person
{
public:
int _num;
};
void Test()
{
Person p;
Student s;
//子类对象可以赋值给父类对象
p = s;
//父类对象不可以赋值给子类对象
//s = p;//error
//父类对象的指针和引用可以指向子类对象
Person *p1 = &s;
Person& r1 = s;
//子类对象的指针和引用不能指向父类的对象(但是可以通过强制类型转化完成)
Student *p2 = (Student*)&p;
Student& r2 = (Student&)p;
}
int main()
{
Test();
}
扫描二维码关注公众号,回复:
2720835 查看本文章
#include <iostream>
using namespace std;
class Person
{
public:
Person(const char* name = "", int id = 0):_name(name), _num(id)
{
}
protected:
string _name; //姓名
int _num; //身份证
};
class Student : public Person
{
public:
Student(const char *name, int id, int stuNum):Person(name, id), _num(stuNum)
{
}
void DisplayNum()
{
cout << "身份证:" << Person::_num << endl;
cout << "学号" << _num << endl;
}
protected:
int _num; //学号
};
void Test()
{
Student s1("paul", 110, 1);
s1.DisplayNum();
}
int main()
{
Test();
return 0;
}
#include <iostream>
using namespace std;
class Person
{
public:
Person(const char* name):_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 operatpr = (const Person& p)" << endl;
if (this != &p)
{
_name = p._name;
}
return *this;
}
~Person()
{
cout << "~person()" << endl;
}
protected:
string _name;//姓名
};
class Student : public Person
{
public:
Student(const char* name, int num):Person(name), _num(num)
{
cout << "student()" << endl;
}
Student(const Student& s):Person(s),_num(s._num)
{
cout << "Student(const Student& s)" << endl;
}
Student& operator = (const Student& s)
{
cout << "Student& operator = (const Student& s)" << endl;
if (this != &s)
{
Person::operator=(s);
_num = s._num;
}
return *this;
}
~Student()
{
cout << "~Student()" << endl;
}
private:
int _num; //学号
};
void Test()
{
Student s1("jack", 18);
Student s2(s1);
Student s3("rose", 17);
s1 = s3;
}
int main()
{
Test();
return 0;
}
//程序运行结果
/*
Person() s1先调用基类构造函数
student() s1然后调用子类构造函数
Person(const Person& p) s2基类拷贝构造
Student(const Student& s) s2子类拷贝构造
Person() s3先调用基类构造函数
student() s3然后调用子类构造函数
Student& operator = (const Student& s) 赋值构造
Person operatpr = (const Person& p) 赋值构造
~Student() s1先调用派生类析构函数
~person() 再调用基类析构函数
~Student() s2先调用派生类析构函数
~person() 再调用基类析构函数
~Student() s3先调用子类析构函数
~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 _majorCorse; //主修课程
};
void Test()
{
Assistant a;
a.Student::_name = "xxx";
a.Teacher::_name = "yyy";
}
int main()
{
Test();
system("pause");
return 0;
}