拷贝构造函数

于 2022-10-23 17:18:49 发布
阅读量235 收藏
点赞数
分类专栏： C++ 面向对象 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62456756/article/details/127476983
版权

目录

1.拷贝构造函数

2.拷贝构造函数功能--用已有对象去构造本类的新对象（倒数两行）

3.如果程序员没有写，类会生成默认的拷贝构造函数，功能是用已有对象的值依次给新对象的值初始化

4.--拷贝构造函数调用的3种情况

5.默认拷贝构造--浅拷贝--值之间的拷贝

6.深拷贝

7.类会默认提供的函数--6个

1.拷贝构造函数

拷贝构造函数--本类旧对象去构造本类新对象 1--参数的类型 值类型(不行，会产生递归),指针类型(会出现歧义),引用类型（本类对象的const引用)

class A
{
public:
	A(int i = 0,int j = 0):m_i(i),m_j(j){cout<<"A"<<endl;}
	void Print()
	{
		cout<<"m_i = "<<m_i<<"  m_j = "<<m_j<<endl;
	}
 private:
    int m_i;
    iny m_j;
};
void main()
{
    A a(3,6);
    a.Print;//正常打印出m_i是3，m_j是6
    A b=a;//声明一个对象，想用对象a的值给b赋值
          //本质其实就是用a的数据成员去初始化b 的数据成员
    b.Print();
}

截图展示：

结论：由上图可知：b是一个对象，用a去初始化是成功的，但b的产生会调用构造函数，所以b调用了一个特别的构造函数.

1）值类型(不行，会产生递归) 

class A
{
public:
	A(int i = 0,int j = 0):m_i(i),m_j(j){cout<<"A"<<endl;}
	void Print()
	{
		cout<<"m_i = "<<m_i<<"  m_j = "<<m_j<<endl;
	}
	A(A s)//假设调用的是这个函数，第一步用a去给s初始化，那a是个对象，又要调这个函数，就构成递归了
	{
	
	}
 private:
    int m_i;
    iny m_j;
};
void main()
{
    A a(3,6);
    a.Print;//正常打印出m_i是3，m_j是6
    A b=a;//声明一个对象，想用对象a的值给b赋值
          //本质其实就是用a的数据成员去初始化b 的数据成员
    b.Print();
}

 2）指针类型

class A
{
public:
	A(int i = 0,int j = 0):m_i(i),m_j(j){cout<<"A"<<endl;}
	void Print()
	{
		cout<<"m_i = "<<m_i<<"  m_j = "<<m_j<<endl;
	}
    A (A *s)：m_i(s->m_i),m_j(s->m_j)//假设调这个函数，
    {
        cout<<"A(A*)"<<endl;
    }

 private:
    int m_i;
    iny m_j;
};
void main()
{
    A a(3,6);
    a.Print;//正常打印出m_i是3，m_j是6
    A b=&a;//可能会理解为用a的地址给b赋值
    b.Print();
}

截图展示：  

由上图可知：用指针功能可以实现，但是会出现歧义， A b=&a;//可能会理解为用a的地址给b赋值

3）引用类型（本类对象的const引用)

class A
{
public:
	A(int i = 0,int j = 0):m_i(i),m_j(j){cout<<"A"<<endl;}
	void Print()
	{
		cout<<"m_i = "<<m_i<<"  m_j = "<<m_j<<endl;
	}
    A（const A &s):m_i(s.m_i),m_j(s.m_j)//s是a的别名
    {
      cout<<"A (A&)"<<endl;
    }
 private:
    int m_i;
    iny m_j;
};
void main()
{
    A a(3,6);
    a.Print;//正常打印出m_i是3，m_j是6
    A b=a;//声明一个对象，想用对象a的值给b赋值
          //本质其实就是用a的数据成员去初始化b 的数据成员
    b.Print();
}

截图展示： 

A（const A &s)就是拷贝（复制）构造函数。

2.拷贝构造函数功能--用已有对象去构造本类的新对象（倒数两行）

class A
{
public:
	A(int i = 0,int j = 0):m_i(i),m_j(j){cout<<"A"<<endl;}
	void Print()
	{
		cout<<"m_i = "<<m_i<<"  m_j = "<<m_j<<endl;
	}
    A（const A &s):m_i(s.m_i),m_j(s.m_j)
    {
      cout<<"A (A&)"<<endl;
    }
 private:
    int m_i;
    iny m_j;
};
void main()
{
    A a(3,6);
    a.Print;//正常打印出m_i是3，m_j是6
    A b=a;//声明一个对象，想用对象a的值给b赋值
          //本质其实就是用a的数据成员去初始化b 的数据成员
    b.Print();
    A c;//已经构造了一个c
    c=a;//在这里c是旧对象了，这句话是用a给c重新赋值
         //不会调用拷贝构造函数，c在上面A c已经构造出来了，调用的是后面要学的赋值运算符重载
}

 

3.如果程序员没有写，类会生成默认的拷贝构造函数，功能是用已有对象的值依次给新对象的值初始化

4.--拷贝构造函数调用的3种情况

1--用已有对象去初始化本类的对象

如上述所示：A b=a;

2--函数传参，类类型的值传递

class A
{
public:
	A(int i = 0,int j = 0):m_i(i),m_j(j){cout<<"A"<<endl;}
	void Print()
	{
		cout<<"m_i = "<<m_i<<"  m_j = "<<m_j<<endl;
	}


 private:
    int m_i;
    iny m_j;
};
void Test(A t)//A t=c从实参c到形参t的过程，调用拷贝构造

{

   cout<<"Test:"<<endl;

   t.Print();

}

void main()
{
    A a(2,6);//调用构造函数A（int,int)
    A b(a);//调拷贝构造函数A（A&）
    A c(9,3);//调用构造函数A（int,int)
    Test(c);//c是旧对象 t是新对象
}

截图展示：  

 

  执行过程：

问：输出多少句话 （10句话）

 

解释：

1：调用A构造函数构造对象a，输出A 2：拷贝构造函数用a构造出b ，输出A（A&)

3：调用构造函数构造c ，输出A

4：c是旧对象，t是新对象，所以先拷贝构造出t，输出A（A&)

5：调用Test函数，输出Test；

6：t.Print()调用Print函数，输出m_i和m_j的值

7：程序即将结束，根据先构造后析构的原则，先析构t，输出~A

8：析构c，输出~A

9：析构b ,输出~A

10：析构a ，输出~A

3--函数是类类型的值返回 局部对象->临时对象

代码展示;

class A
{
public:
	A(int i = 0,int j = 0):m_i(i),m_j(j){cout<<"A"<<endl;}
	void Print()
	{
		cout<<"m_i = "<<m_i<<"  m_j = "<<m_j<<endl;
	}
	A(const A &s):m_i(s.m_i),m_j(s.m_j)
	{
	cout<<"A(A&)"<<endl;
	}
    ~A()
    {
        cout<<"~A"<<endl;
    }
 private:
    int m_i;
    iny m_j;
};
void Test(A t)//A t=c从实参c到形参t的过程，调用拷贝构造

{

   cout<<"Test:"<<endl;

   t.Print();

}

void main()
{
    A a(2,6);//调用构造函数A（int,int)
    A b(a);//调拷贝构造函数A（A&）
    A c(9,3);//调用构造函数A（int,int)
    Test(c);//c是旧对象 t是新对象
}

 截图展示：

3)函数是类类型的值返回，由局部对象到临时对象调用拷贝构造函数

class A
{
public:
	A(int i = 0,int j = 0):m_i(i),m_j(j){cout<<"A"<<endl;}
	void Print()
	{
		cout<<"m_i = "<<m_i<<"  m_j = "<<m_j<<endl;
	}
	A(const A &s):m_i(s.m_i),m_j(s.m_j)
	{
	cout<<"A(A&)"<<endl;
	}
    ~A()
    {
        cout<<"~A"<<m_i<<m_j<<endl;
    }
 private:
    int m_i;
    iny m_j;
};
void Test(A t)//A t=c从实参c到形参t的过程，调用拷贝构造

{

   cout<<"Test:"<<endl;

   t.Print();

}
A fn()
{
    A d(10,12);
    return d;
}

void main()
{
    A a(2,6);//调用构造函数A（int,int)
    A b(a);//调拷贝构造函数A（A&）
    A c(9,3);//调用构造函数A（int,int)
    Test(c);//c是旧对象 t是新对象
    c=fn();
    cout<<"main end"<<endl;
}

 分析过程：

main和fn是两个栈区，他们之间不能直接的传递数据，所以在生成局部对象d的时候，其中也有一个临时对象temp去接受d的值，随后把值传给main函数中的c。

结果输出：  

A：构造A对象，调用普通构造函数

A(A &)：调用拷贝构造构造对象b

A：调用普通构造构造c

A(A &)：进入Test函数，c是旧对象，t是新对象，所以先拷贝构造出t

Test:Test函数自身打印Test

m_i=9 m_j=3:t.Print函数调Print,打印m_i和m_j的值

A~93：Test函数即将结束，析构t对象

A：进入fn函数，调用普通构造构造对象d

A(A &)：因为栈区原因，d无法带回值回到main函数，所有有一个临时对象，调用拷贝构造函数构造临时对象

A~1012：析构局部对象d

A~1012：临时对象把值带给c之后，析构临时对象

main end：主函数打印

A~1012：析构c

A~26：析构b

A~26：析构a

5.默认拷贝构造--浅拷贝--值之间的拷贝

class Student
{
public:
	Student(int num=0,char *name = "oo",char sex='m'):m_num(num),m_sex(sex)
	{
		m_name = new char[strlen(name)+1];
		strcpy(m_name,name);
    }
	~Student()
	{
		delete[]m_name;
	}
	void Print()
	{
		cout<<m_num<<" "<<m_name<<" "<<m_sex<<endl;
	}
private:
	int m_num;
	char *m_name;
	char m_sex;
};
void main()
{
	Student s(1001,"lisi",'f');
	s.Print();
	Student s1(s); //调用默认拷贝构造 ,导致s1对象中的m_name和s对象中的m_name指向的内存相同
	s1.Print();
	cout<<sizeof(s)<<endl;
}

截图结果：  

 

结论：功能实现了，但是出现了崩溃，原因是浅拷贝在遇到指针的时候，原有的对象s拷贝构造了一个s1,s和s1里的函数指针共同指向同一段字符串的首地址，在析构这两对象时，s1被析构后，指针所有的内存单元被释放，等到析构s1的时候，这一段已经空的内存单元又被析构，就会崩溃。

由上图可知：b是一个对象，用a去初始化是成功的，但b的产生会调用构造函数，所以b调用了一个特别的构造函数

6.深拷贝

深拷贝-- 如果有指针作为数据成员，而且用本类的旧对象去构造了新对象，则要写拷贝构造 给新对象的指针要去开辟和旧对象指针同样大小的内存单元，然后拷贝相同的值 1.不但拷贝值，而且要拷贝资源

class Student
{
public:
	Student(int num=0,char *name = "oo",char sex='m'):m_num(num),m_sex(sex)
	{
		m_name = new char[strlen(name)+1];
		strcpy(m_name,name);
	}
	Student(const Student&s):m_num(s.m_num),m_sex(s.m_sex) //深拷贝
	{
		m_name = new char[strlen(s.m_name)+1];//开辟和旧对象的字符串一样大小的内存
		strcpy(m_name,s.m_name);
	}
	~Student()
	{
		delete[]m_name;
	}
	void Print()
	{
		cout<<m_num<<" "<<m_name<<" "<<m_sex<<endl;
	}
private:
	int m_num;
	char *m_name;
	char m_sex;
};
void main()
{
	Student s(1001,"lisi",'f');
	s.Print();
	Student s1(s); //调用默认拷贝构造 ,导致s1对象中的m_name和s对象中的m_name指向的内存相同
	s1.Print();
	cout<<sizeof(s)<<endl;
}
类会提供默认的函数--6个
1.构造函数
2.析构函数
3.拷贝构造(复制构造)
  --只要有指针作为数据成员
4.运算符重载赋值=
*/
class Student
{
public:
	Student(int num=0,char *name = "oo",char sex='m'):m_num(num),m_sex(sex)
	{
		m_name = new char[strlen(name)+1];
		strcpy(m_name,name);
	}
	Student(const Student&s):m_num(s.m_num),m_sex(s.m_sex) //深拷贝
	{
		m_name = new char[strlen(s.m_name)+1];//开辟和旧对象的字符串一样大小的内存
		strcpy(m_name,s.m_name);
	}
	~Student()
	{
		delete[]m_name;
	}
	void Print()
	{
		cout<<m_num<<" "<<m_name<<" "<<m_sex<<endl;
	}
private:
	int m_num;
	char *m_name;
	char m_sex;
};
void main()
{
	Student s(1001,"lisi",'f');
	s.Print();
	Student s1(s); //调用默认拷贝构造 ,导致s1对象中的m_name和s对象中的m_name指向的内存相同
	s1.Print();
	cout<<sizeof(s)<<endl;
}

 结果展示：

7.类会默认提供的函数--6个

1.构造函数

2.析构函数

3.拷贝构造（复制拷贝）--只要有指针作为数据成员

4.运算符重载=

 

我在凌晨等太阳¤
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
详解C++ 拷贝构造函数
01-19
拷贝构造函数是一种特殊的构造函数，它在创建对象时，是使用同一类中之前创建的对象来初始化新创建的对象。拷贝构造函数通常用于： 通过使用另一个同类型的对象来初始化新创建的对象。 复制对象把它作为参数传递给...
C++基础——拷贝构造函数
最新发布
weixin_69283129的博客
11-10 1万+
C++类成员函数之拷贝构造函数
C++学习之路-拷贝构造函数
weixin_45452278的博客
07-07 6365
拷贝构造函数也是构造函数的一种。普通的构造函数可以是无参的，也可以是有参的。但是拷贝构造函数必须是有参的，如下所示，参数就是const类型的对象引用（格式固定，别问为什么） 我们知道，当创建对象的时候会自动调用构造函数。那什么时候会调用拷贝构造函数呢？ 答案是：当利用已存在的对象创建一个新对象时（拷贝对象），就会调用新对象的拷贝构造函数进行初始化新对象的成员变量。 拷贝对象，拷贝了什么？ 利用已经存在的对象去创建新的对象，叫作拷贝操作。拷贝对象，也就是拷贝了对象内存里的东西，也就是拷贝了原有对象的成员。用一
【C++】类和对象——拷贝构造函数
Ye_Ming_OUC的博客
08-21 3709
文章详细讨论了什么是拷贝构造函数、为什么拷贝构造函数只能传引用、编译器自动生成的默认拷贝构造函数做了什么、浅拷贝和深拷贝、以及编译器对拷贝构造的优化。
拷贝构造函数详解
weixin_43831728的博客
08-09 6988
拷贝构造函数详解 拷贝构造函数 int main() { int a; int b = 10; int c(b); return 0 } //结果就是b和c的结果都是10 int main() { int a; int b = 10; int c(b); string s1("hello"); string s2(s1); //用s1去构造s2，然后s1和s2的内容就一模一样了 return 0 } //但是通过监视可以看出，s1和s2的地址是一样的，也就是说s1和
拷贝构造函数.rar
04-03
本资源通过代码实例详细介绍在C++程序中调用拷贝构造函数的三种情境，每行代码配有详细的注释，帮助学习者直观理解
详解C++ 拷贝构造函数和赋值运算符
09-01
本文主要介绍了拷贝构造函数和赋值运算符的区别，以及在什么时候调用拷贝构造函数、什么情况下调用赋值运算符。最后，简单的分析了下深拷贝和浅拷贝的问题。有需要的朋友可以看下
C++中拷贝构造函数的总结详解
01-20
1.什么是拷贝构造函数： 拷贝构造函数嘛，当然就是拷贝和构造了。（其实很多名字，只要静下心来想一想，就真的是顾名思义呀）拷贝又称复制，因此拷贝构造函数又称复制构造函数。百度百科上是这样说的：拷贝构造函数...
C++中拷贝构造函数的应用
01-20
C++中拷贝构造函数的定义 　有一个参数的类型是其类类型的构造函数是为拷贝构造函数。如下： 　X::X( const X& x); 　Y::Y( const Y& y， int =0 ); 　//可以是多参数形式，但其第二个即后继参数都有一个默认值 ...
什么时候调用拷贝构造函数
01-20
以下几种情况会调用拷贝构造函数 1. 以一个对象初始化另一个对象 2. 函数以某个对象为参数 3. 函数返回某个对象 4. 初始化序列式容器的元素 2. void test2() { Test t1(1,2); Test t2; t2=t1;//调用的不是拷贝构造...
深入C++拷贝构造函数的总结详解
12-31
拷贝构造函数是C++最基础的概念之一，大家自认为对拷贝构造函数了解么？请大家先回答一下三个问题:1. 以下函数哪个是拷贝构造函数,为什么?X::X(const X&); X::X(X); X::X(X&, int a=1); X::X(X&, int a=1, b=2);...
详解C++ 编写String 的构造函数、拷贝构造函数、析构函数和赋值函数
08-29
主要介绍了详解C++ 编写String 的构造函数、拷贝构造函数、析构函数和赋值函数的相关资料,这里提供实例帮助大家理解掌握这部分内容，需要的朋友可以参考下
php中拷贝构造函数、赋值运算符重载
10-28
php中拷贝构造函数、赋值运算符重载方法， 需要的朋友可以参考下
拷贝构造（深拷贝、浅拷贝）
qq_42981122的博客
10-04 2895
简单理解一下深拷贝和浅拷贝
C++——拷贝构造函数
热门推荐
weixin_59179454的博客
05-21 2万+
（用旧对象去构造新对象）拷贝构造函数，又称复制构造函数，是一种特殊的构造函数，它由编译器调用来完成一些基于同一类的其他对象的构造及初始化。值类型（不行，会产生递归）；指针类型（能实现要求，但会出现歧义（感觉a的地址给b构造））；引用类型（本类对象的const引用）。其唯一的形参必须是引用，但并不限制为const，一般普遍的会加上const限制。此函数经常用在函数调用时用户定义类型的值传递及返回。拷贝构造函数要调用基类的拷贝构造函数和成员函数。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

我在凌晨等太阳¤

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值