C++深拷贝与浅拷贝,初始化列表,对象成员,静态成员相关分析

简介: 深拷贝与浅拷贝深浅拷贝是面试经典问题,也是常见的一个坑浅拷贝:简单的赋值拷贝操作深拷贝:在堆区重新申请空间,进行拷贝操作



深拷贝与浅拷贝

深浅拷贝是面试经典问题,也是常见的一个坑

浅拷贝:简单的赋值拷贝操作

深拷贝:在堆区重新申请空间,进行拷贝操作

示例:

classPerson {

public:

   //无参(默认)构造函数

   Person() {

       cout<<"无参构造函数!"<<endl;

   }

   //有参构造函数

   Person(intage ,intheight) {

       

       cout<<"有参构造函数!"<<endl;

       m_age=age;

       m_height=newint(height);//使用new创建堆区数据,需要人为释放,new出来的东西是等到整个进程结束了才会自动释放。如果这个对象已经销毁,而这个类里没有析构函数却恰恰有个指针,自动释放的是栈区的变量,而不是堆区的,那么这个地址就没有指针指向它,就造成了内存泄漏。

       

   }

   

       //如果不利用深拷贝在堆区创建新内存,会导致浅拷贝带来的重复释放堆区问题: p1在进行有参初始化时,在堆区申请了一个空间,p1的height指针就指向这个空间,p2在进行拷贝初始化时使用的是编译器提供的浅拷贝,浅拷贝是对成员变量的简单赋值,指针传递的是地址,所以p2的height指针=p1的height指针,即两个height指针指向堆区的同一个地址,函数test01结束后,p1和p2把同一个空间释放了两次,所以程序崩了。

   //既然编译器的浅拷贝不好用就自己写拷贝构造函数:

   //拷贝构造函数  

   Person(constPerson&p) {

       cout<<"拷贝构造函数!"<<endl;

       m_age=p.m_age;

       //m_height = p.m_height;编译器的默认代码:浅拷贝。

       m_height=newint(*p.m_height);

       

   }

   //析构函数

   ~Person() {

       cout<<"析构函数!"<<endl;

       if (m_height!=NULL)

       {

           deletem_height;

       }

   }

public:

   intm_age;

   int*m_height;

};

voidtest01()

{

   Personp1(18, 180);

   Personp2(p1);

   cout<<"p1的年龄: "<<p1.m_age<<" 身高: "<<*p1.m_height<<endl;

   cout<<"p2的年龄: "<<p2.m_age<<" 身高: "<<*p2.m_height<<endl;

}

intmain() {

   test01();

   system("pause");

   return0;

}

总结:如果属性有在堆区开辟的(例如本案例:m_height = new int(height);),一定要自己提供拷贝构造函数,防止浅拷贝带来的问题。

PS:

网络异常,图片无法展示
|

使用new创建堆区数据,需要人为释放,new出来的东西是等到整个进程结束了才会自动释放。如果这个对象已经销毁,而这个类里没有析构函数却恰恰有个指针,自动释放的是栈区的变量,而不是堆区的,那么这个地址就没有指针指向它,就造成了内存泄漏。

如果不利用深拷贝在堆区创建新内存,会导致浅拷贝带来的重复释放堆区问题: p1在进行有参初始化时,在堆区申请了一个空间,p1的height指针就指向这个空间,p2在进行拷贝初始化时使用的是编译器提供的浅拷贝,浅拷贝是对成员变量的简单赋值,指针传递的是地址,所以p2的height指针=p1的height指针,即两个height指针指向堆区的同一个地址,函数test01结束后,p1和p2把同一个空间释放了两次,所以程序崩了。

初始化列表

作用:

C++提供了初始化列表语法,用来初始化属性

语法:构造函数():属性1(值1),属性2(值2)... {}

示例:

classPerson {

public:

   ////传统方式初始化

   //Person(int a, int b, int c) {

   //  m_A = a;

   //  m_B = b;

   //  m_C = c;

   //}

   //初始化列表方式初始化:

   Person(inta, intb, intc) :m_A(a), m_B(b), m_C(c) {}//留出代码空间{}写其他的代码。

   voidPrintPerson() {

       cout<<"mA:"<<m_A<<endl;

       cout<<"mB:"<<m_B<<endl;

       cout<<"mC:"<<m_C<<endl;

   }

private:

   intm_A;

   intm_B;

   intm_C;

};

intmain() {

   Personp(1, 2, 3);

   p.PrintPerson();

   system("pause");

   return0;

}

类对象作为类成员

C++类中的成员可以是另一个类的对象,我们称该成员为 对象成员

例如:

classA {}

classB

{

   Aa;

}

B类中有对象A作为成员,A为对象成员

那么当创建B对象时,A与B的构造和析构的顺序是谁先谁后?构造A构造B,析构B,析构A。

示例:

classPhone

{

public:

   Phone(stringname)

   {

       m_PhoneName=name;

       cout<<"Phone构造"<<endl;

   }

   ~Phone()

   {

       cout<<"Phone析构"<<endl;

   }

   stringm_PhoneName;

};

classPerson

{

public:

   //初始化列表可以告诉编译器调用哪一个构造函数

   Person(stringname, stringpName) :m_Name(name), m_Phone(pName)

   {

       cout<<"Person构造"<<endl;

   }

   ~Person()

   {

       cout<<"Person析构"<<endl;

   }

   voidplayGame()

   {

       cout<<m_Name<<" 使用"<<m_Phone.m_PhoneName<<" 牌手机! "<<endl;

   }

   stringm_Name;

   Phonem_Phone;

};

voidtest01()

{

   //当类中成员是其他类对象时,我们称该成员为 对象成员

   //构造的顺序是 :先调用对象成员的构造,再调用本类构造

   //析构顺序与构造相反

   Personp("张三" , "苹果X");

   p.playGame();

}

intmain() {

   test01();

   system("pause");

   return0;

}

静态成员

静态成员就是在成员变量和成员函数前加上关键字static,称为静态成员

静态成员分为:

  • 静态成员变量
  • 所有对象共享同一份数据
  • 在编译阶段分配内存
  • 类内声明,类外初始化
  • 静态成员函数
  • 所有对象共享同一个函数
  • 静态成员函数只能访问静态成员变量

示例1 :静态成员变量

classPerson

{

   

public:

   staticintm_A; //静态成员变量

   //静态成员变量特点:

   //1 在编译阶段分配内存,就是在exe运行前(代码区,全局区)就分配内存了,分配到全局区。

   //2 类内声明,类外初始化(即必须有初始值,否则无法访问这块内存)

   //3 所有对象共享同一份数据

private:

   staticintm_B; //静态成员变量也是有访问权限的

};

intPerson::m_A=10;

intPerson::m_B=10;

//静态成员变量不属于某个对象上,所有对象共享一份数据,因此静态成员变量有两种访问方式。

voidtest01()

{

   //静态成员变量两种访问方式

   //1、通过对象(非静态成员变量只能通过类名的方法访问)

   Personp1;

   p1.m_A=100;

   cout<<"p1.m_A = "<<p1.m_A<<endl;

   Personp2;

   p2.m_A=200;

   cout<<"p1.m_A = "<<p1.m_A<<endl; //共享同一份数据

   cout<<"p2.m_A = "<<p2.m_A<<endl;

   //2、通过类名(静态成员变量独有)

   cout<<"m_A = "<<Person::m_A<<endl;

   //cout << "m_B = " << Person::m_B << endl; //私有权限访问不到

}

intmain() {

   test01();

   system("pause");

   return0;

}

示例2:静态成员函数

classPerson

{

public:

   //静态成员函数特点:

   //1 程序共享一个函数

   //2 静态成员函数只能访问静态成员变量

   

   staticvoidfunc()

   {

       cout<<"func调用"<<endl;

       m_A=100;

       //m_B = 100; //错误,不可以访问非静态成员变量。

       //解释一:静态static成员函数它只属于类本身不属于每一个对象实例,独立存在。非静态成员,仅当实例化对象之后才存在。静态成员函数产生在前,非静态成员函数产生在后,静态函数无法访问一个不存在的东西。

       //解释二:静态成员函数 不可以访问非静态成员变量,因为访问的时候不知道修改的是哪个对象的。由于m_A不属于某一个对象上的,所以可以访问。

   }

   staticintm_A; //静态成员变量

   intm_B; //

private:

   //静态成员函数也是有访问权限的

   staticvoidfunc2()

   {

       cout<<"func2调用"<<endl;

   }

};

intPerson::m_A=10;

voidtest01()

{

   //静态成员变量两种访问方式

   //1、通过对象

   Personp1;

   p1.func();

   //2、通过类名

   Person::func();

   //Person::func2(); //私有权限访问不到

}

intmain() {

   test01();

   system("pause");

   return0;

}


CtrlX
+关注
目录
打赏
0
0
0
0
4
分享
相关文章
类和对象(下)C++
本内容主要讲解C++中的初始化列表、类型转换、静态成员、友元、内部类、匿名对象及对象拷贝时的编译器优化。初始化列表用于成员变量定义初始化,尤其对引用、const及无默认构造函数的类类型变量至关重要。类型转换中,`explicit`可禁用隐式转换。静态成员属类而非对象,受访问限定符约束。内部类是独立类,可增强封装性。匿名对象生命周期短,常用于临时场景。编译器会优化对象拷贝以提高效率。最后,鼓励大家通过重复练习提升技能!
类和对象(中 )C++
本文详细讲解了C++中的默认成员函数,包括构造函数、析构函数、拷贝构造函数、赋值运算符重载和取地址运算符重载等内容。重点分析了各函数的特点、使用场景及相互关系,如构造函数的主要任务是初始化对象,而非创建空间;析构函数用于清理资源;拷贝构造与赋值运算符的区别在于前者用于创建新对象,后者用于已存在的对象赋值。同时,文章还探讨了运算符重载的规则及其应用场景,并通过实例加深理解。最后强调,若类中存在资源管理,需显式定义拷贝构造和赋值运算符以避免浅拷贝问题。
类和对象(上)(C++)
本篇内容主要讲解了C++中类的相关知识,包括类的定义、实例化及this指针的作用。详细说明了类的定义格式、成员函数默认为inline、访问限定符(public、protected、private)的使用规则,以及class与struct的区别。同时分析了类实例化的概念,对象大小的计算规则和内存对齐原则。最后介绍了this指针的工作机制,解释了成员函数如何通过隐含的this指针区分不同对象的数据。这些知识点帮助我们更好地理解C++中类的封装性和对象的实现原理。
|
4月前
|
【c++】继承(继承的定义格式、赋值兼容转换、多继承、派生类默认成员函数规则、继承与友元、继承与静态成员)
本文深入探讨了C++中的继承机制,作为面向对象编程(OOP)的核心特性之一。继承通过允许派生类扩展基类的属性和方法,极大促进了代码复用,增强了代码的可维护性和可扩展性。文章详细介绍了继承的基本概念、定义格式、继承方式(public、protected、private)、赋值兼容转换、作用域问题、默认成员函数规则、继承与友元、静态成员、多继承及菱形继承问题,并对比了继承与组合的优缺点。最后总结指出,虽然继承提高了代码灵活性和复用率,但也带来了耦合度高的问题,建议在“has-a”和“is-a”关系同时存在时优先使用组合。
237 6
【C++篇】深度解析类与对象(下)
在上一篇博客中,我们学习了C++的基础类与对象概念,包括类的定义、对象的使用和构造函数的作用。在这一篇,我们将深入探讨C++类的一些重要特性,如构造函数的高级用法、类型转换、static成员、友元、内部类、匿名对象,以及对象拷贝优化等。这些内容可以帮助你更好地理解和应用面向对象编程的核心理念,提升代码的健壮性、灵活性和可维护性。
c++模板初阶----函数模板与类模板
class 类模板名private://类内成员声明class Apublic:A(T val):a(val){}private:T a;return 0;运行结果:注意:类模板中的成员函数若是放在类外定义时,需要加模板参数列表。return 0;
45 0
c++的类(附含explicit关键字,友元,内部类)
本文介绍了C++中类的核心概念与用法,涵盖封装、继承、多态三大特性。重点讲解了类的定义(`class`与`struct`)、访问限定符(`private`、`public`、`protected`)、类的作用域及成员函数的声明与定义分离。同时深入探讨了类的大小计算、`this`指针、默认成员函数(构造函数、析构函数、拷贝构造、赋值重载)以及运算符重载等内容。 文章还详细分析了`explicit`关键字的作用、静态成员(变量与函数)、友元(友元函数与友元类)的概念及其使用场景,并简要介绍了内部类的特性。
112 0
【c++11】c++11新特性(上)(列表初始化、右值引用和移动语义、类的新默认成员函数、lambda表达式)
C++11为C++带来了革命性变化,引入了列表初始化、右值引用、移动语义、类的新默认成员函数和lambda表达式等特性。列表初始化统一了对象初始化方式,initializer_list简化了容器多元素初始化;右值引用和移动语义优化了资源管理,减少拷贝开销;类新增移动构造和移动赋值函数提升性能;lambda表达式提供匿名函数对象,增强代码简洁性和灵活性。这些特性共同推动了现代C++编程的发展,提升了开发效率与程序性能。
114 12
【C++进阶】特殊类设计 && 单例模式
通过对特殊类设计和单例模式的深入探讨,我们可以更好地设计和实现复杂的C++程序。特殊类设计提高了代码的安全性和可维护性,而单例模式则确保类的唯一实例性和全局访问性。理解并掌握这些高级设计技巧,对于提升C++编程水平至关重要。
98 16
【C++篇】深度解析类与对象(中)
在上一篇博客中,我们学习了C++类与对象的基础内容。这一次,我们将深入探讨C++类的关键特性,包括构造函数、析构函数、拷贝构造函数、赋值运算符重载、以及取地址运算符的重载。这些内容是理解面向对象编程的关键,也帮助我们更好地掌握C++内存管理的细节和编码的高级技巧。
登录插画

登录以查看您的控制台资源

管理云资源
状态一览
快捷访问