【继承关系中赋值运算符的重载、单例模式】

已于 2022-09-12 21:38:45 修改
阅读量521 收藏 1
点赞数
分类专栏： C++ 文章标签： 单例模式 c++ 开发语言
于 2022-07-11 17:22:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lmy347771232/article/details/125723756
版权

继承关系中赋值运算符的重载

1.程序设计者在基类和派生类中都没有重载operator=函数; C++编译器将在基类和派生类中自动产生按位赋值的,重载operator=函数；C++编译器会在派生类的重载赋值函数中，加入基类重载赋值函数的调用，是C++编译器合成的代码；（完成行为的统一）；// 0 .

2.程序设计者在基类中定义重载赋值函数；而在派生类中没有定义重载赋值函数；C++编译器将会在派生类中自动产生按位赋值的重载赋值函数。并合成代码，调用(关联）基类的重载赋值函数。

class person {
private:

	string _name;
	int _age;
public:
	string _idperson;

	person& operator=(const person& s1)
	{
		_name = s1._name;
		_age = s1._age;
		_idperson = s1._idperson;
		return *this;
	}
	person(const string& idperson, const string& name, int x) : _idperson(idperson), _name(name), _age(x)
	{
		cout << " Create peron" << endl;
	}
};
class Student :public person
{
private:
	string _snum;
	float _score;
public:
	Student(const string& idperson, const string& name, int age, const char* ip) :person(idperson, name, age), _score(100)
	{
		_snum = name;

	}
};
int main()
{
	string name = "wang";
	string idperson{ "22000002" };
	Student stux(idperson, name, 12, "202201");
	Student stux1("931211","lmy",28,"00000");
	stux1 = stux;
	//stux.print();
	stux1.print();
}

在这里插入图片描述

3，程序设计者在基类和派生类中都定义了重载赋值函数；程序设计者在派生类中,没有指定调用基类的重载赋值函数时。C++编译器不会合成调用基类的重载赋值函数的代码。要在派生类的重载赋值函数调用基类的重载赋值函数，程序设计者必须自己加入调用代码。 1 1

class person {
private:

	string _name;
	int _age;
public:
	string _idperson;

	person& operator=(const person& s1)
	{
		_name = s1._name;
		_age = s1._age;
		_idperson = s1._idperson;
		return *this;
	}
	person(const string& idperson, const string& name, int x) : _idperson(idperson), _name(name), _age(x)
	{
		cout << " Create peron" << endl;
	}
};
class Student :public person
{
private:
	string _snum;
	float _score;
public:
	Student(const string& idperson, const string& name, int age, const char* ip) :person(idperson, name, age), _score(100)
	{
		_snum = name;

	}
	Student& operator=(const Student &s1)
	{
		_snum = s1._snum;
		_score = s1._score;
		return *this;
	}
};
int main()
{
	string name = "wang";
	string idperson{ "22000002" };
	Student stux(idperson, name, 12, "202201");
	Student stux1("931211","lmy",28,"00000");
	stux1 = stux;
	//stux.print();
	stux1.print();
}

在这里插入图片描述没有调用基类的赋值重载，那么我们怎么能实现调用基类的赋值重载呢？
请看如下代码：

Student& operator=(const Student &s1)
	{
		_snum = s1._snum;
		_score = s1._score;
		person::operator=( s1);//调动基类的赋值语句
		return *this;
	}

在这里插入图片描述

4.程序设计者在基类中没有定义重载赋值函数（C++编译器将自动产生按位赋值的重载赋值函数）。而在派生类中定义了重载赋值函数。程序设计者在派生类中,没有指定调用基类的重载赋值函数。C++编译器不会合成调用基类的重载赋值函数的代码。

class person {
private:

	string _name;
	int _age;
public:
	string _idperson;
	person(const string& idperson, const string& name, int x) : _idperson(idperson), _name(name), _age(x)
	{
		cout << " Create peron" << endl;
	}
};
class Student :public person
{
private:
	string _snum;
	float _score;
public:
	Student(const string& idperson, const string& name, int age, const char* ip) :person(idperson, name, age), _score(100)
	{
		_snum = name;
	}
	Student& operator=(const Student &s1)
	{
		_snum = s1._snum;
		_score = s1._score;
		//person::operator=( s1);//调动基类的赋值语句
		return *this;
	}
};
int main()
{
	string name = "wang";
	string idperson{ "22000002" };
	Student stux(idperson, name, 12, "202201");
	Student stux1("931211","lmy",28,"00000");
	stux1 = stux;
	//stux.print();
	stux1.print();
}

在这里插入图片描述

//student赋值函数加上这行代码：
		person::operator=( s1);//调动基类的赋值语句
	}

在这里插入图片描述

delete删除关键字用在构造函数上的情况

protected:
	
	lmy(const string& name, const string& sex, int age)  : _name(name), _sex(sex), _age(age) {}
	~lmy() {}
	lmy(const lmy& s1) = delete;//将拷贝构造删除
	lmy& operator=(const lmy& s1) = delete;

如果基类的拷贝构造和赋值函数都删除，确在派生类中定义了拷贝和赋值函数，则基类的删除不起作用。

几种域，在类的访问时的一些情况：

在这里插入图片描述
块域：比如if（）{}里的内容属于块域。

单例模式

单例模式，属于创建类型的一种常用的软件设计模式。通过单例模式的方法创建的类在当前进程中只有一个实例（根据需要，也有可能一个线程中属于单例，如：仅线程上下文内使用同一个实例）

再说Static 在里面起到的作用：
在这里插入图片描述

第一种单例模式（也是饥汉模式）：

using namespace std;
#if 1
class lmy 
{
private:
	string _name;
	string _sex;
	int _age;
public:
	void fun()
	{
		cout << " lmy unique plays  " << endl;
		//_name = "gouzi09";
		cout << "  name =  "<<_name << endl;
	}
protected:
	
	lmy(const string& name, const string& sex, int age)  : _name(name), _sex(sex), _age(age) {}
	~lmy() {}
	lmy(const lmy& s1) = delete;
	//lmy(const lmy& s1) :_name(s1._name), _sex(s1._sex), _age(s1._age) {} 
	lmy& operator=(const lmy& s1) = delete;
	
private:
	static lmy lmy1;
public:
	static lmy& get_single()
	{
		return  lmy1;
	}
};
lmy lmy::lmy1("gouzi2", "man_or_woman", 1);
class llmy :private lmy
{
private:
	string _name;
	string _sex;
	int _age;
public:
	void fun()
	{
		cout << " llmy unique plays  " << endl;
		//lmy::fun();
	}
private:
	
	
	llmy(const string& name, const string& sex, int age) :lmy(name,sex,age),_name(name), _sex(sex), _age(age) {}
	~llmy() {}
	llmy(const llmy& s1)  = delete;
	
	llmy& operator=(const llmy& s1) = delete;
	
private:
	static llmy l1;
public:
	static llmy& get_single()
	{
		return  l1;
	}
};
llmy llmy::l1("gouzi2", "man_or_woman", 1);
int main()
{
	llmy& l1 = llmy::get_single();
	//llmy s1;
	l1.fun();
	lmy& lmy1 = lmy::get_single();
	lmy1.fun();
	//lmy lmy2("gouzi2", "man_or_woman", 1);
	return 0;
}

我们用static 关键字加上私有的构造函数做出了只能构造一个的对像，则称为单例模式。

如果基类的构造函数属性是私有的 ，那么 派生来的单例模式此时无法生成，所以我们可以利用继承特性将其设置成保护：
在这里插入图片描述
在这里插入图片描述
第二种：饿汉模式：实例在使用之前就已经创建。

class lmy 
{
private:
	string _name;
	string _sex;
	int _age;
public:
protected:
	lmy(const string& name, const string& sex, int age)  : _name(name), _sex(sex), _age(age) {}
	~lmy() {}
	lmy(const lmy& s1) = delete;
	//lmy(const lmy& s1) :_name(s1._name), _sex(s1._sex), _age(s1._age) {} 
	lmy& operator=(const lmy& s1) = delete;
	
private:
	static lmy lmy1;
public:
	static lmy& get_single()
	{
		return  lmy1;
	}
};
lmy lmy::lmy1("gouzi2", "man_or_woman", 1);
如果没有继承的情况：在类外定义一个对象，但是成员属性是私有的，构造函数是保护的，所以无法构建对象。
//int main()
//{
//	//lmy& l1 = lmy::get_single();
//	lmy l1("gouzi2", "man_or_woman", 1);
//	//l1.fun();
//
//
//	///llmy& l2 = llmy::get_single();
//	//l2.fun();
//
//	//return 0;
//}
class llmy :private  lmy
{
private:
	string _name;
	string _sex;
	int _age;
public:
public:
	llmy(const string& name, const string& sex, int age) :lmy(name,sex,age),_name(name), _sex(sex), _age(age) {}
	~llmy() {}
	llmy(const llmy& s1)  = delete;
	
	llmy& operator=(const llmy& s1) = delete;
public:
	static llmy& get_single()对于派生类对象，只写了一个get_single函数就只能创建一个对象
	{
		static llmy l1("gouzi2", "man_or_woman", 1);
		return l1;
	}
};
int main()
{
	llmy& l1 = llmy::get_single();
	l1.fun();
	lmy &lmy1 = lmy::get_single();
	return 0;
}

第三种：懒汉模式：实例在使用时才创建。

class lmy 
{
private:
	string _name;
	string _sex;
	int _age;
public:

protected:
	
	lmy(const string& name, const string& sex, int age)  : _name(name), _sex(sex), _age(age) {}
	~lmy() {}
	lmy(const lmy& s1) = delete;
	//lmy(const lmy& s1) :_name(s1._name), _sex(s1._sex), _age(s1._age) {} 
	lmy& operator=(const lmy& s1) = delete;
	
private:
	static lmy lmy1;
public:
	static lmy& get_single()
	{
		return  lmy1;
	}
};
lmy lmy::lmy1("gouzi2", "man_or_woman", 1);
class llmy :private  lmy
{
private:
	string _name;
	string _sex;
	int _age;
public:
public:
	llmy(const string& name, const string& sex, int age) :lmy(name,sex,age),_name(name), _sex(sex), _age(age) {}
	~llmy() {}
	llmy(const llmy& s1)  = delete;
	llmy& operator=(const llmy& s1) = delete;
private :
	static llmy* p;
public:
	static llmy& get_single()
	{
		if (p == nullptr)
		{
			p = new llmy("gouzi2", "man_or_woman", 1);//new 了一个新对象
		}
		return *p;
	}
};
llmy* llmy:: p = nullptr;//注意：llmy* （类型指针）llmy:: （加标识）p（指针变量）
int main()
{
	llmy& l1 = llmy::get_single();
	l1.fun();
	lmy &lmy1 = lmy::get_single();
	lmy1.fun();
	return 0;
}

在这里插入图片描述
单例模式在多进程和多线程时可能会发生线程安全的问题。

lmy347771232
关注
专栏目录
单例模式（C++）
mmz123_的博客
03-14 229
文章目录不能被拷贝的类只能在堆上创建对象的类只能在栈上创建对象的类不能被继承的类只能创建一个对象的类（单例模式）单例模式饿汉模式懒汉模式 不能被拷贝的类 拷贝只会放生在两个场景中：拷贝构造函数以及赋值运算符重载，因此想要让一个类禁止拷贝，只需让该类不能调用拷贝构造函数以及赋值运算符重载即可。 C++98 将拷贝构造函数与赋值运算符重载只声明不定义，并且将其访问权限设置为私有即可。 class CopyBan { //... private: CopyBan(const CopyBan&);
第 十六 章 运算符重载
m0_57581736的博客
11-18 732
有一些事情让我感到有些不安，比如运算符重载。我决定不支持运算符重载，这完全是个人的选择，因为我看到太多 C++ 程序员在中滥用它 James Gosling,Creator of Java 在 Python 中，您可以使用如下公式计算复利： interest = principal * ((1 + rate) ** peri...
c++继承,运算符重载
比雅尼·斯特劳斯特鲁普（Bjarne Stroustrup）曾说过：如果你没看过这些博客，那么你的编程不会拥有智慧，你的代码不可能附有灵魂。
11-08 569
继承和运算符重载
C++ 派生类中的拷贝构造函数以及赋值运算符重载问题
u011836078的专栏
04-24 809
由thinking in C++ 的一道题目引发的思考
C++之派生类的拷贝构造与赋值运算符重载
maoliran的博客
06-09 4888
这里只说一下为什么派生类在拷贝构造器和赋值运算符重载中一些注意语法： 一、派生类的拷贝构造器1.派生类的拷贝构造器跟普通构造器一样，若没有自定义生成，编译器会自动生成拷贝构造器，自动调用父类的拷贝构造器（不管父类的拷贝构造是否自定义或编译器自动生成）。2.若派生类的拷贝构造器自定义生成，则一定要显示调用父类的拷贝构造器（不管父类的拷贝构造器是否自定义或编译器自动生成），否则编译可以通过，But拷贝
继承和重载
qq_40808896的博客
04-24 968
1、继承概述：根据多个类中的共性内容，向上抽取而来； 让类与类之间产生关系(子父类关系)，子类可以直接使用父类中非私有的成员； （1）继承的格式： 格式：public class子类名extends父类名{} 例子：public class Zi extends Fu{};Fu是父类，也称基类，超类； Zi子类，也称派生类； （2）继承的好处和短板 好处：提高代码的复用性、维护性；类与类之间产生关系，是多态的前提； 短板：继承是侵入性， 降低代码的灵活性；继承关系，导致子类必须拥有父类非私有
C++（十二）类的继承与派生、运算符重载
红叶谷 wsp_1138886114的博客
02-27 1128
1、为什么要进行类的继承与派生？ 关于这个话题其实在之前的课程中有给大家介绍过，就在《实用C++》第29课 面向对象的程序设计的第⑤个知识点：https://www.cctry.com/thread-289448-1-1.html 继承与派生是C++编程过程中经常用到的一个非常重要的功能。可以复用以前开发好的功能，站在巨人的肩膀上，节省时间，提高开发效率。不用重复造轮子了。这就是C++面向对象编程...
C++：单例模式以及一些常见的特殊类
qq_43825377的博客
04-23 466
C++：单例模式什么是单例模式单例模式饿汉模式二级目录三级目录 什么是单例模式 首先我们需要知道什么是设计模式，设计模式是软件开发人员在长期的软件开发过程中总结出来的在面临一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。这就有点类似于我们古代的《孙子兵法》一样，都是通过长期的经验总结出来的。那么使用设计模式的目的是什么呢？ 使用设计模式的目的： 1.为了提高代码的可重用性 2.让代码更容易被他人理解 3.保证代码可靠性 4. 设计模式使代码编写真正工程化 5.
Java面向对象之封装、继承、多态，单例模式
qq_38326107的博客
10-21 429
面向对象的三大特征继承、封装、多态，最编写具有面向对象思想的Java程序。 1.2.1 Java面向对象 认识Java中的面向对象的思想，掌握面向对象的基本原则以及基本实现原理。 面向对象思想开发的程序的优势:稳定性、可扩展性、可重用性 java语言实现面向对象的三大特征：继承、封装、多态； 1.什么是对象？万物皆对象；对象是类的实例表现；对象是特定类型的数据(计算机世界只有数据) 2.什么是面向对象？人关注对象即人关注事物信息(对计算机而言) 3.什么是类？类是模子，确定对象将会拥有的特性(属性)和行为(
C++运算符重载的边界与替代：选择最合适的编程策略
## 1.1 C++中的运算符重载概念 在C++编程语言中，运算符重载是面向对象编程的核心特性之一。它允许开发者为自定义的类定义新的运算符行为，使得运算符可以对类的实例进行操作。这是通过重载运算符函数来实现的，该...
继承之下的赋值运算符重载
qq_54419195的博客
11-14 117
继承之下的赋值运算符重载
公有继承，私有继承，保护继承的区别
dwj6336736的博客
08-29 673
一个子类继承父类时，可按照public、private和protected方式继承父类，每种继承方式的区别如下：1) public继承方式基类中所有public成员在派生类中为public属性； 基类中所有protected成员在派生类中为protected属性； 基类中所有private成员在派生类中不可访问。2) protected继承方式基类中的所有public成员在派生类中为protec
C++派生类和重载赋值运算符以及和复制构造函数的调用运行逻辑实例
xuchaoxin1375的博客
10-03 540
//program 14.10.1.cpp 派生类和赋值运算符 #include <iostream> using namespace std; class CBase { int a; public: CBase(int a_=0) :a(a_) { cout << "constructor_of_CBase is called!" << endl; cout << "a=" << a << endl;
运算符重载及组合与继承
最新发布
qq_52479948的博客
01-17 813
运算符重载及组合与继承
对象的初始化，运算符重载，类的继承和多态知识总结
qq_43628959的博客
06-22 356
对象的初始化，运算符重载，类的继承和多态知识总结 第7章 对象的初始化、复制和销毁 1、默认初始化：如果定义对象时没有指定初值，对象被默认初始化，调用类中的默认构造函数。 2、直接初始化：初始值在圆括号“()”中，可以提供多个初始值，根据初始值类型和个数直接调用最匹配的构造函数。 3、拷贝初始化：用等号“=”初始化一个对象时，执行拷贝初始化，编译器用等号右边的初始值创建一个对象，复制给新创建的对象...
派生类和基类运算符重载
crispto的博客
12-04 3564
C++派生类和基类函数重载 有时候派生类和基类重载同一个函数，这个函数的调用过程需要传入基类，那么在子类中的重载函数应该怎么写呢 class Parent{ private: int a, b; public: Parent(int x, int y){ a = x; b = y; } friend ostream&amp;amp; ...
C++运算符重载和继承
qq_43718691的博客
03-11 1857
一、运算符重载 概念：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型 1.1加号运算符重载 作用：实现两个自定义数据类型相加的运算 编译器给起一个通用的名称——可以通过成员函数重载、或者通过全局函数重载 使用的的指令是：operator+ 总结：1、对于内置的数据类型的表达的运算符是不可能改变的 2、不要滥用运算符重载 1.2左移运算符重载（<<） 作用：可以输出自定义数据类型（一般是使用全局运算符重载） 1.3递增运算符重载 作用：通过重载递增运算符实
C++复习（继承，运算符）
touchinsert
12-25 179
----------------------继承: ,,,,(俺要主攻uc,还要回珠海工作) 1.子类继承父类方式：1.public 2.protected 3.private 通过public继承下来的，都不变 通过protected继承下来的，原有父类的public函数，将转化为protected来继承。 通过private继承下来的，原有父类的public ,protected 函...
计算机面试必备：操作系统、C++与设计模式解析
以及面向对象编程的关键概念，如构造函数、虚函数、静态成员函数、拷贝构造与赋值运算符、列表初始化、多态、静态绑定与动态绑定、`explicit`、`mutable`、`volatile`、`internal`关键字、继承、堆栈溢出、重载操作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值