【C++】类和对象之继承
目录
继承的概念和定义
继承的概念
继承的定义
继承的定义格式
继承关系和访问限定符
继承基类成员访问方式的变化
访问权限实例
基类和派生类对象赋值转换
继承中的作用域
派生类的默认成员函数
继承与友元
继承与静态成员
复杂的菱形继承及菱形虚拟继承
继承的概念和定义
继承的概念
继承 (inheritance) 机制是面向对象程序设计 使代码可以复用 的最重要的手段,它允许程序员在 保 持原有类特性的基础上进行扩展 ,增加功能,这样产生新的类,称派生类。继承 呈现了面向对象 程序设计的层次结构 ,体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用, 继 承是类设计层次的复用。
简单来说就是类似于在一个类中包含了另一个类的成员函数和成员变量以及对应的访问权限。
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
{
protected:int _stuid; // 学号
};
class Teacher : public Person
{
protected:int _jobid; // 工号
};
int main()
{Student s;Teacher t;s.Print();t.Print();return 0;
}
下面是调试结果
可以看到子类中继承的父类的_name和_age,s和t是两个不同的类;他们各自继承的父类的内存空间也是不同的,就像每个孩子继承父亲的家产一样。
继承的定义
继承的定义格式
继承关系和访问限定符
继承基类成员访问方式的变化
总结:
访问权限实例
class Person
{
public:void Print(){cout << _name << endl;}
protected:string _name; // 姓名
private:int _age; // 年龄
};
//class Student : protected Person
//class Student : private Person
class Student : public Person
{void fun(){cout << _stunum << " " << _age << " " << _name; 这里_age显示无法访问}
protected:int _stunum; // 学号
};int main()
{Student s; s.Print(); return 0;
}
在上述代码中,Student是以public的形式继承的父类person,最父类成员函数、成员变量的访问权限依次是public.protected和private。protected的对象是可以进行访问的。
class Person
{
public:void Print(){cout << _name << endl;}
protected:string _name; // 姓名
private:int _age; // 年龄
};
//class Student : protected Person
//class Student : private Person
class Student : protected Person
{void fun(){cout << _stunum << " " << _age << " " << _name; //显示不可访问_name = 6; }
protected:int _stunum; // 学号
};int main()
{Student s; s.Print(); //显示不可访问 return 0;
}
在上述代码中,以protected的形式继承父类时,对父类的成员函数。成员变量的访问权限依次是protected.protected和private。print()函数无法再类外进行调用。
如果以private 的形式继承父类,那么父类的所有成员的访问权限都是private,在子类中都无法进行访问;
基类和派生类对象赋值转换
派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用 。这里有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去。基类对象不能赋值给派生类对象。基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针是指向派生类对象时才是安全的。这里基类如果是多态类型,可以使用 RTTI(RunTime Type Information) 的 dynamic_cast 来进行识别后进行安全转换。
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* pp = &sobj;Person& rp = sobj;//2.基类对象不能赋值给派生类对象sobj = pobj; // 3.基类的指针可以通过强制类型转换赋值给派生类的指针pp = &sobj;Student * ps1 = (Student*)pp; // 这种情况转换时可以的。ps1->_No = 10; pp = &pobj;Student* ps2 = (Student*)pp; // 这种情况转换时虽然可以,但是会存在越界访问的问题ps2->_No = 10;
}
继承中的作用域
// Student的_num和Person的_num构成隐藏关系,可以看出这样代码虽然能跑,但是非常容易混淆
class Person
{
protected:string _name = "小李子"; // 姓名int _num = 111; // 身份证号
};
class Student : public Person
{
public:void Print(){cout << " 姓名:" << _name << endl;cout << " 身份证号:" << Person::_num << endl;cout << " 学号:" << _num << endl;}
protected:int _num = 999; // 学号
};
void Test()
{Student s1;s1.Print();
};
子类和父类中都有_num但是他们的作用域不同,在子类中只能访问子类的_num,当然也可以通person类访问父类的_num,
// B中的fun和A中的fun不是构成重载,因为不是在同一作用域
// B中的fun和A中的fun构成隐藏,成员函数满足函数名相同就构成隐藏。
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;}
};
void Test()
{B b;b.fun(10);
};
在子类中,只能直接访问带参数的fun,可以通过person::fun()来访问无参数的fun。
派生类的默认成员函数
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: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;}
protected:int _num; //学号
};
void Test()
{Student s1("jack", 18);Student s2(s1); Student s3("rose", 17); s1 = s3;
}
其实可以把父类当成一个自定义类型的成员变量,如果父类有默认构造函数,那么就是自己自动调用,如果没有需要手动在子类的构造函数的初始化列表中进行传参数初始化。析构函数会自动调用。拷贝构造需要再子类的拷贝构造函数中的初始化列表中进行调用。
继承与友元
class Student;
class Person
{
public:friend void Display(const Person& p, const Student& s);
protected:string _name; // 姓名
};
class Student : public Person
{
protected:int _stuNum; // 学号
};
void Display(const Person& p, const Student& s)
{cout << p._name << endl;cout << s._stuNum << endl;
}
void main()
{Person p;Student s;Display(p, s);
}
在父类中的友元只能访问父类的成员变量,无法访问子类的成员变量。
继承与静态成员
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; // 研究科目
};
void TestPerson()
{Student s1;Student s2;Student s3;Graduate s4;cout << " 人数 :" << Person::_count << endl;Student::_count = 0;cout << " 人数 :" << Person::_count << endl;
}
所有的实例化的继承类都公用这一个静态成员变量。
复杂的菱形继承及菱形虚拟继承
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; // 主修课程
};
void Test()
{// 这样会有二义性无法明确知道访问的是哪一个Assistant a;a._name = "peter";// 需要显示指定访问哪个父类的成员可以解决二义性问题,但是数据冗余问题无法解决a.Student::_name = "xxx";a.Teacher::_name = "yyy";
}
Teacher和Student类中各有一份person父类,实际上只需要有一分就可以了,
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; // 主修课程
};
void Test()
{Assistant a;a._name = "peter";
}
在重复的父类访问前加上virtual,进行虚拟化,Student和Teacher就会公用person类了,就解决了继承的二义性和数据冗余的问题。
总结: