C++_继承

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了C++_继承，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含5508字，纯文字阅读大概需要8分钟。

内容图文

1、继承的定义

继承是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类称派生类。

#include<iostream>

using namespace std;

class Person
{
public:
	Person(const string& name = "", const int& age = 0)
		:_name(name), _age(age)
	{}

	void Print()
	{
		cout<<"name:"<<_name<<endl;
		cout<<"age:"<<_age<<endl;
	}
protected:
	string _name;
	int _age;
};

class Student:public Person
{	
public:
	Student(const string& name = "", const int& age = 0, const int& sid = 0)
		:Person(name, age), _sid(sid)
	{}

	void Print()
	{
		Person::Print();
		cout<<"sid:"<<_sid<<endl;
	}
protected:
	int _sid;
};

class Teacher:public Person
{
public:
	Teacher(const string& name = "", const int& age = 0, const int& tid = 0)
		:Person(name, age), _tid(tid)
	{}

	void Print()
	{
		Person::Print();
		cout<<"tid:"<<_tid<<endl;
	}
protected:
	int _tid;
};

int main()
{
	Student s("a", 22, 1111);
	Teacher t("b", 24, 2222);
	s.Print();
	t.Print();
	return 0;
}

继承基类成员访问方式的变化

• 基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
• 基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。
• 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。
• protetced/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。

2、基类和派生类对象赋值转换

• 派生类对象可以赋值给基类的对象/基类的指针/基类的引用。
• 基类对象不能赋值给派生类对象。
• 基类的指针可以通过强制类型转换赋值给派生类的指针。但是必须是基类的指针是指向派生类对象时才是安全的。
• 基类如果是多态类型，可以使用RTTI(Run-Time Type Information)的dynamic_cast 来进行识别后进行安全转换。

#include<iostream>

using namespace std;

class Person
{
protected:
	string _name;
	string _sex;
	int _age;
};

class Student:public Person
{
public:
	int _no;
};

int main()
{
	Student sobj;

	//子类对象赋值给父类对象/指针/引用
	Person pobj = sobj;
	Person* ppobj = &sobj;
	Person& rpobj = sobj;

	//sobj = pobj;基类对象不能赋值给派生类对象

	//基类的指针可以通过强制类型装换赋值给派生类指针
	ppobj = &sobj;
	Student* psobj1 = (Student *)ppobj;
	psobj1->_no = 123;

	//有时可能会出现越界访问
	ppobj = &pobj;
	Student* psobj2 = (Student *)ppobj;
	psobj2->_no = 234;
	return 0;
}

3、继承的作用域

• 在继承体系中基类和派生类都有独立的作用域。
• 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。(在子类成员函数中，可以使用"基类::基类成员"显示访问)
• 如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
• 在实际中在继承体系里面最好不要定义同名的成员。

4、派生类的默认成员函数

6个默认成员函数编译器会自己生成：构造函数、析构函数、拷贝构造、赋值重载、普通对象取地址、const对象取地址

#include<iostream>

using namespace std;

class Person
{
public:
	Person(const char * name = "Tom")
		:_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;
};

int main()
{
	Student s1("a", 20);
	Student s2(s1);
	Student s3 = s1;
	return 0;
}

• 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。
• 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
• 派生类的operator=必须要调用基类的operator=完成基类的复制。
• 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。这样才能保证派生类对象先清理派生类成员，再清理基类成员的顺序。
• 派生类对象初始化先调用基类构造再调派生类构造。派生类对象析构清理先调用派生类析构再调基类的析构。

实现一个不能被继承的类

#include<iostream>

using namespace std;

class NonInher
{
public:
	static NonInher GetInstance()
	{
		return NonInher();
	}
private:
	NonInher()
	{}
};

/*C++11:final关键字禁止继承
class NonInher final
{};
*/

/*
class Test:public NonInher
{};
*/

int main()
{
	return 0;
}

5、继承和友元

友元关系不能继承，也就是说基类友元不能访问子类私有和保护成员

#include<iostream>

using namespace std;

class Student;

class Person
{
public:
	friend void display(const Person& p, const Student& s);
protected:
	string _name;
};

class Student:public Person
{
protected:
	string _sno;
};

void display(const Person& p, const Student& s)
{
	cout<<p._name<<endl;
	//cout<<s._sno<<endl;
}

int main()
{
	Person p;
	Student s;
	display(p, s);
	return 0;
}

6、继承和静态成员

基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子类，都只有一个static成员实例。

#include<iostream>

using namespace std;

class Person
{
public:
	Person()
	{
		++_count;
	}
protected:
	string _name;
public:
	static int _count;
};

int Person::_count = 0;

class Student:public Person
{
protected:
	string _sno;
};

class Graduate:public Student
{
protected:
	string _course;
};

int main()
{
	Person p;
	Student s1;
	Student s2;
	Graduate g1;
	Graduate g2;
	cout<<"Person Number:"<<Person::_count<<endl;//5
	Student::_count = 0;
	cout<<"Person Number:"<<Person::_count<<endl;//0
	return 0;
}

7、复杂的菱形继承和菱形虚拟继承

8、小结

• 点赞
• 收藏
• 分享
• • 文章举报

内容总结

以上是互联网集市为您收集整理的C++_继承全部内容，希望文章能够帮你解决C++_继承所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端