effective C++ 读书笔记 条款12

最新推荐文章于 2023-11-15 21:44:15 发布
最新推荐文章于 2023-11-15 21:44:15 发布
阅读量888 收藏 1
点赞数 1
分类专栏： c/c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/djb100316878/article/details/41146197
版权

条款12 ： 复制对象时不要忘记其每一个成分

 

编写一个类用来表现顾客，其中手动写出copying函数使得外界对它们的调用记录会被logged下来：

#include <iostream>
#include <string>
using namespace std;
void logCall(const string funcName)
{
	cout<<funcName<<endl;
}

class Customer
{
public:
	Customer()
	{

	}
	Customer(const Customer& rhs);
	Customer& operator= (const Customer& rhs);

private:
	string name;
};

Customer::Customer(const Customer& rhs)
{
	this->name = rhs.name;
	logCall("拷贝构造函数");
}
Customer& Customer::operator=(const Customer& rhs)
{
	logCall("赋值操作符重载");
	name = rhs.name;
	return *this;
}
int main()
{
	Customer c1;
	Customer c2(c1);
	Customer c3;
	c3 = c2;
	return 0;
}


上面的函数看起来没有问题，知道一个新的成员变量加入：

#include <iostream>
#include <string>
using namespace std;
void logCall(const string funcName)
{
	cout<<funcName<<endl;
}
class Date
{
};
class Customer
{
public:
	Customer()
	{		
	}
	Customer(const Customer& rhs);
	Customer& operator= (const Customer& rhs);
	
private:
	string name;
	Date data; //这里增加一个成员变量

};
Customer::Customer(const Customer& rhs)
{
	//函数体并没有增加对data成员变量的处理，但是编译器不会给出任何警告
	this->name = rhs.name;
	logCall("拷贝构造函数");
}
Customer& Customer::operator=(const Customer& rhs)
{
	//函数体并没有增加对data成员变量的处理，但是编译器不会给出任何警告
	logCall("赋值操作符重载");
	name = rhs.name;
	return *this;
}
int main()
{
	Customer c1;
	Customer c2(c1);
	Customer c3;
	c3 = c2;
	return 0;
}
/*
如果你为一个class添加一个成员变量，你必须同时修改copying函数，如果你忘记，
编译器是不会给出任何提示的。

*/


上面说明：如果你为一个class添加一个成员变量，你必须同时修改copying函数

现在让他拥有子类：

 

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

void logCall(const string funcName)
{
	cout<<funcName<<endl;
}

class Date
{
	
};
class Customer
{
public:
	Customer()
	{
		
	}
	Customer(const Customer& rhs);
	Customer& operator= (const Customer& rhs);
	
private:
	string name;
	Date data; //这里增加一个成员变量
	
};

Customer::Customer(const Customer& rhs)
{
	//函数体并没有增加对data成员变量的处理，但是编译器不会给出任何警告
	this->name = rhs.name;
	logCall("拷贝构造函数");
}

Customer& Customer::operator=(const Customer& rhs)
{
	//函数体并没有增加对data成员变量的处理，但是编译器不会给出任何警告
	logCall("赋值操作符重载");
	name = rhs.name;
	return *this;
}

//现在发生了继承
class PriorityCustomer:public Customer
{
public:
	PriorityCustomer(const PriorityCustomer& rhs);
	PriorityCustomer& operator= (const  PriorityCustomer& rhs);


private:
	int priority;
};

PriorityCustomer::PriorityCustomer(const PriorityCustomer& rhs):priority(rhs.priority)
{
	logCall("PriorityCustomer copy constructor");
}
PriorityCustomer& PriorityCustomer::operator =(const PriorityCustomer& rhs)
{
	logCall("PriorityCustomer copy assignment operator");
	priority = rhs.priority;

	return *this;
}
/*

  PriorityCustomer的copying函数看起来好像复制了PriorityCustomer内的每一样东西，但是仔细看就会发现，
  它们复制了PriorityCustomer声明的成员变量，但是每个PriorityCustomer还内含它所继承的Customer成员变
  量复件（副本），而这些成员变量却没有被复制。priorityCustome的copy构造函数并没有制定实参传给其base
  class构造函数（也就是说它在它的成员初值列表中没有提到Customer），因此PriorityCustomer对象的Customer
  成分会被不带实参的Customer构造函数初始化，那么也就是说Customer内的成员变量name和data将执行缺省的初始化。

*/





int main()
{
	
	Customer c1;
	Customer c2(c1);
	Customer c3;
	c3 = c2;
	return 0;
}
/*

*/


子类的copy函数只是复制了子类本身加上去的成员变量，但是继承下来的成员变量却没有没复制，怎么解决？

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

void logCall(const string funcName)
{
	cout<<funcName<<endl;
}

class Date
{
	
};
class Customer
{
public:
	Customer()
	{
		
	}
	Customer(const Customer& rhs);
	Customer& operator= (const Customer& rhs);
	
private:
	string name;
	Date data; //这里增加一个成员变量
	
};

Customer::Customer(const Customer& rhs)
{
	//函数体并没有增加对data成员变量的处理，但是编译器不会给出任何警告
	this->name = rhs.name;
	logCall("拷贝构造函数");
}

Customer& Customer::operator=(const Customer& rhs)
{
	//函数体并没有增加对data成员变量的处理，但是编译器不会给出任何警告
	logCall("赋值操作符重载");
	name = rhs.name;
	return *this;
}

/*
任何时候，只要我们为子类编写copy函数，那我们就必须小心复制其base class成分，而这些成分一般都是private；
所以我们无法直接访问他们，我们能做的就是让子类的copying函数调用相应的base class函数：
*/
class PriorityCustomer:public Customer
{
public:
	PriorityCustomer(const PriorityCustomer& rhs);
	PriorityCustomer& operator= (const  PriorityCustomer& rhs);


private:
	int priority;
};

//我们能做的就是让子类的copying函数调用相应的base class函数：
PriorityCustomer::PriorityCustomer(const PriorityCustomer& rhs):Customer(rhs),priority(rhs.priority)//调用base class的copy构造函数
{
	logCall("PriorityCustomer copy constructor");
}
//我们能做的就是让子类的copying函数调用相应的base class函数：
PriorityCustomer& PriorityCustomer::operator =(const PriorityCustomer& rhs)
{
	logCall("PriorityCustomer copy assignment operator");
	Customer::operator =(rhs); //对base class成分进行赋值动作
	priority = rhs.priority;

	return *this;
}





int main()
{
	
	Customer c1;
	Customer c2(c1);
	Customer c3;
	c3 = c2;
	return 0;
}
/*

*/

我们能做的就是让子类的copying函数调用相应的base class函数

 

总结：

1：Copying函数应该确保复制“对象内的所有成员变量”及所有base class成分

2：不要尝试以某个copying函数实现另外一个copying函数。应该讲共同的机能放进第三个函数当中，并由两个copying函数共同调用。

 

 

cpp玩家攻略
关注
专栏目录
《Effective C++》 读书笔记 条款6-10
youyadefeng1的博客
03-12 132
Effective C++ 6-10 Note 条款06：若不想使用编译器自动生成的函数，就明确拒绝 在老版的C++中，将不想自动生成的函数声明为private并且不定义 在当前版本的C++中，可以使用delete修饰符进行修饰 条款07：为多态基类声明virtual析构函数 带多态性质的基类应该声明一个虚析构函数，如果类带有任何虚函数，它就应该有一个虚析构函数 当出现基类指针或引用指向派生类对象时，如果析构函数不为虚函数，那么调用的就是静态对象的析构函数，也就是基类的析构函数，这会导致派生类的派生部分没
读书笔记_Effective C++_习惯C++
John_cdy的专栏
05-04 2980
这是一本非常经典C++书籍，也是我在工作中发现自己C++上还有很多薄弱点的时候经常拿来充电的。这本书内容很多，讲了很多如何高效地使用C++的方法，有些地方自己也没能啃透，读过一遍后很多知识点容易忘记，这次是一条一条地进行温习，之所以会分享出来是觉得对于程序员来说，好记性不如烂笔头，自己多动手往往在真正写程序的时候能够像条件反射一样写出好的代码。慢工出细活，对待技术要有谨慎和敬畏之心。这本书推荐喜欢C
Effective C++条款12
weixin_50019806的博客
08-18 242
条款12：复制对象时勿忘其每一个成分 #include<iostream> class Date{ public: Date()=default; Date(const int&month,const int&day) :m_month(month),m_day(day) {} void Init_Date() { std::cout<<"Please input month and d
effective C++ 条款十二解读
weixin_38911779的博客
08-19 183
复制对象时不要忘记复制对象中的每一个成分 这里所说的复制对象，显然主要指的拷贝构造函数以及拷贝赋值函数。 复制对象中的每一个成分，表示要复制对象的基类部分以及当前类的成员，以一段代码来展示： class Base { public: Base(const Base&); Base& operator=(const Base&); } class Derived:publi
Effective C++ 条款12_不止于此
嘟嘟的博客
10-13 239
复制对象时勿忘其每一个成分 设计良好之面向对象系统会将对象的内部封装起来，只留两个函数负责对象拷贝（copy 构造函数和 copy assignment 操作符） 在 C++ 中，如果自己声明 copying 函数，会发生这样一种情况：当你的实现代码几乎必然出错时却不告诉你。 看下面的代码说事： void logCall(const std::string& funcName); // 制造一个 log entry class Customer { public: ... Customer(c
effective c++条款12
baidu_25539425的博客
04-13 453
1.Copying函数应该确保复制“对象内的所有成员变量”及所有”base class”成分 2.不要尝试以一个copying函数去实现另一个copying函数，应该将共同机能放进第三个函数中，由两个copying函数调用如果类中没有定义复制构造函数和赋值构造函数,编译器会为我们提供默认的赋值和复制构造函数，但是如果你自己定义了这些函数， 但是数据没有全部copy,编译器是不会提醒你的看下面的
Effective C++ 条款12
weixin_30892763的博客
09-05 95
复制对象时勿忘其每一个成分 Copy all parts of an object 如果我们自己写了拷贝构造函数，那么编译器不会为我们生成默认的拷贝构造函数，即使我们的代码不完全，编译器也不会告诉我们。所以如果有新增加的成员变量，我们必须同时修改拷贝构造函数。 如果遇到继承的情况，那么我们还需要调用父类的拷贝构造函数。 总结：copying函数应该确保复制对象内的所有成员变量以及所有bas...
effective c++笔记1
08-08
Effective C++笔记1 本笔记总结了Effective C++的第1到第11条款，涵盖了C++语言的多个方面，包括构造函数、拷贝构造函数、拷贝赋值函数、const关键字、enum、inline函数、定义域、static变量、初始化、编译器生成的...
《More Effective C++》笔记
weixin_42065178的博客
01-29 1125
《More Effective C++》笔记
《Effective C++》 读书笔记(详细总结55条款)上篇
身在边城 心在编程
07-07 2090
下面从四个方面来说 (1) C++ 以 C 为基础，很多语句语法都没有改变，只是进行了扩展，C++ 解决问题的时候，可以理解为 C 的高效解法 (2) 面向对象，有构造函数，析构函数，继承、封装、多态、虚函数动态绑定，这是不同于C 语言的部分 (3) 泛型编程、可以理解为代码的模型，但是代码本身并不占用内存空间，只有在实例化的时候，才分配内存，所以可以提高代码复用性
《Effective C++》条款12
最新发布
qq_64863535的博客
11-15 119
我们可以调用B的拷贝构造函数进行初始化对象，但是实际上，我们并没有初始化A类的成员，只是因为我们自行写了对应的函数，如果是编译器生成的默认函数，那么会帮我们考虑到继承下来的A类的成员。我们都知道，我们不主动写拷贝构造函数或者赋值重载运算符，那么编译器就会自动生成默认的函数。当我们写时，编译器不会自动生成，它只会找对应我们写的函数，如果此时我们写的函数出现了问题，那编译器可不会处理。而且，我们在这个类里新增了一个成员变量，但是没有及时修改我们写的运算符，那么程序可能会出现错误。复制对象时勿忘其每一个成分。
Effective C++ 条款12：复制对象时勿忘其每一个成分（重要且常用的条款）
weixin_44980842的博客
09-25 274
这一篇博客记录我学习Effective C++ term12的学习笔记！ Effective C++ term12 教会我：复制对象时勿忘其每一个成分（重要且常用的条款）
《Effective C++》条款12:复制对象是勿忘其每一个成分
applemonkey11的博客
01-03 163
对于拷贝构造函数和拷贝赋值函数，如果决定自己定义，那么不要忘记调用父类的相应构造函数。因为如果没有调用，对于拷贝构造函数，编译器会去自动调用父类的default构造函数，那么父类的成员没有被成功从子类实例拷贝；对于拷贝赋值函数，编译器不会做额外的操作，意味着只有子类的部分被赋值，而父类的成员维持原状。 如下代码子类中的拷贝构造函数和拷贝赋值函数，没有主动调用父类的相应函数: class Bas
读书笔记： effective C++ 条款12 尽量以initialization 动作取代assignment
yes_sir_yes的专栏
02-28 433
在初始化中赋值， 和用赋值函数给成员变量在初始化后再赋值有什么不同吗？ 结果可能没有什么不一样的，但是效率却不同。 例如：  Template{  public:     NamedPtr(const string& initName, T* initPtr); private:   const string& name;   T × const ptr; }
Effective C++条款12：复制对象的所有成分
qq_44800780的博客
11-07 167
假设有以下的类 这看起来没问题，但是当Cow类多了一个成员变量 :age class Cow { private: char name[20]; char * hobby; double weight; int age; public: Cow(); Cow(const char * nm, const char * ho, double wt); Cow(const Cow ...
《Effective C++》条款12、继承中的拷贝和赋值
qq_44664843的博客
03-07 154
实现拷贝构造函数和赋值运算符时，我们不能遗忘任何一个成员，当我们自定义以上成员时，如果我们没有将其中的某个成员进行复制，编译器是没法检测出来的。这种情况下我们就会得到不正确的对象。所以当我们为某个类添加任何成员时，我们必须记得修改我们的拷贝构造函和复制运算符重载。 派生类的拷贝和赋值 在派生类中实现拷贝构造函数和复制运算符时我们不能遗忘基类成分，我们必须考虑我们派生类中的隐藏的基类成员的赋值。 考虑以下的案例： class A { public: A() : Num(0), Name("") {}
Effective C++——条款10条,条款11和条款12(第2章)
yiranant的专栏
08-29 1072
条款10:    令operator=返回一个reference to *this Have assignment operators return a reference to *this       关于赋值,可以把它们写成连锁形式: int x, y, z; x = y = z = 15; // 赋值连锁形式     赋值采用右结合律,所以上述连锁赋值被解析为:
Effective C++之条款11、12
Black.Spider的博客
10-10 291
条款11：在operator=中处理“自我赋值”     “自我赋值”发生在对象被赋值给自己时： class Widget {...}; Widget w; ... w = w; //赋值给自己     这样的赋值在编译器看来是合法的。此外赋值动作可能并不明显，例如： a[i] = a[j]; ...
effective C++笔记之条款12： 尽量使用初始化而不要在构造函数里赋值
philips的专栏
03-09 771
l        const和引用数据成员只能用初始化，不能被赋值。 l        对数据成员同时声明const和引用，这样就生成了一个其名字成员在类外可以被修改而在内部是只读的对象。 l        对象的创建分为两步：1.数据成员初始化2.执行被调用构造函数体内的动作。 l        对有基类的对象来说，基类的成员初始化和构造函数体的执行发生在派生类的成员初始化和构造函数体的执
Effective C++ 读书笔记与理解
"Effective C++读书笔记" 在深入探讨《Effective C++》的读书笔记之前，首先需要明白这本书是由Scott Meyers所著，是C++程序员必读的经典之一，旨在帮助开发者掌握C++语言的高级技巧和最佳实践。笔记中提到了几个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值