拷贝构造函数，深浅拷贝，类的继承和派生，继承的权限，继承构造函数和析构函数调用规则

---

前言

本篇文章主要介绍
拷贝构造函数，深拷贝和浅拷贝
类的继承和派生
继承的权限
继承构造函数和析构函数调用规则

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、拷贝构造函数，深拷贝和浅拷贝

1.作用

当一个对象赋值给另外一个新的对象的时候，就会自动调用拷贝构造函数（给另外对象初始化赋值）

语法规则：

                  类名(类的对象引用)
                {
                
                }
                小结：
                         Animal  a;
                         Animal  b=a; //等价于  Animal b(a);

2.深拷贝和浅拷贝

系统默认的拷贝构造函数遇到申请堆空间，那么所有拷贝得到的对象全部都共享同一个堆空间–》这种拷贝称之浅拷贝。

3.浅拷贝代码实例：

#include <iostream>
#include <cstring>
using namespace std;

class Animal
{
public:
	Animal(int newage,const char *newname)
	{
		cout<<"构造函数"<<endl;
		age=newage;
		//给指针name分配堆空间
		name=new char[20];
		strcpy(name,newname);
	}

	void show()
	{
		cout<<"age :  "<<age<<"name  :  "<<name<<endl;
		cout<<"&age :  "<<&age<<endl;
		cout<<"name 地址:  "<<(int *)name<<endl;
		
	}
	void setAge(int newage)
	{
		age=newage;
	}
	void setName(const char *newname)
	{
		strcpy(name,newname);
	}
	//析构函数
	~Animal()
	{
		cout<<"对象被析构了"<<endl;
		//释放name的堆空间
		delete []name;  //由于你使用的是默认拷贝构造函数(浅拷贝),name是共用的，析构多次会出现段错误
	}
private:
	int age;
	char *name;  
};

int main()
{
	Animal a(18,"xiaohuang");
	Animal b=a;  //把对象a赋值给一个新的对象b，调用的是系统默认拷贝构造函数
	Animal c=a;
	
	cout<<"a b c三个都是独立的对象，地址不一样:  "<<&a<<"   "<<&b<<"   "<<&c<<endl;
	a.show();
	b.show();
	c.show();
	//b对象打算修改自己的年龄和自己的名字
	b.setAge(8);
	b.setName("wangcai");
	a.show();
	b.show();
	c.show();
}

4.不会调用拷贝构造函数的例子

第一种： Animal a;
Animal *p=&a; //不会调用
第二种： Animal a;
Animal &p=a; //没有产生新对象，并给新对象赋值，不会调用
第三种： Animal a;
Animal b; //b在这里已经调用了构造函数，拷贝构造函数不会再调用
b=a;

二、类的继承和派生

1.继承的作用

为了扩展原来类的功能，提高代码的复用性

2.语法规则

A继承了B，A被称为派生类（子类），B被称为A的基类（父类）

      class 派生类名字:public 基类名字  //公有继承
      class  派生类名字:private 基类名字  //私有继承
      class  派生类名字:protected 基类名字  //保护继承
      {

      } 

三、继承的权限

 第一种：派生类公有继承父类
       父类                                public           private         protected
    派生类(类的外面)                        yes                 no            no
    派生类(类的内部)                        yes                 no            yes
     第二种：派生类私有继承父类
          父类                             public           private         protected
    派生类(类的外面)                        no                  no             no
    派生类(类的内部)                        yes                 no            yes
    第三种：派生类保护继承父类
          父类                             public           private         protected
    派生类(类的外面)                        no                  no             no
    派生类(类的内部)                        yes                 no            yes

四、继承构造函数和析构函数调用规则

1.构造函数：

	先构造父类(无论何种情况，默认都是调用父类的无参构造函数)，然后再构造子类
                          如果程序员想要指定调用父类的特定构造函数--》可以的
                                           Dog(int newnum,string newstr):Animal(newnum,newstr)   //指定要调用父类Animal(newnum,newstr)版本的构造函数
                             {
	                       cout<<"子类有参构造"<<endl;
                             }

2.析构函数：

先析构子类，然后再析构父类

3.调用规则代码实例

#include <iostream>
using namespace std;
class Animal
{
public:
	Animal(int _num)
	{
		num=_num;
		cout<<"父类有参数构造  "<<_num<<endl;
	}
	Animal()
	{
		cout<<"父类无参构造"<<endl;
	}
	~Animal()
	{
		cout<<"父类析构"<<endl;
	}
private:
	int num;
	
};

class Dog:public Animal
{
public:
	Dog()
	{
		cout<<"子类无参构造"<<endl;
	}
	Dog(int _age)
	{
		age=_age;
		cout<<"子类有参构造"<<endl;
	}
	~Dog()
	{
		cout<<"子类析构"<<endl;
	}
private:
	int age;
};

int main()
{
	//定义一个Dog对象
	Dog dog1;  //先构建父类对象的一个副本，然后在创建子类对象
	Dog dog2(8);
}

总结

以上就是今天要讲的内容，本文仅仅简单介绍了拷贝构造函数以及继承构造函数和析构函数调用规则，其他内容请各位大神移步本博客的其他文章，或是关注博主，等待后续发布