构造函数的三个作用，（）运算符的重载，*和-＞运算符的重载

已于 2022-08-19 16:42:11 修改
阅读量354 收藏
点赞数 1
分类专栏： c++笔记 文章标签： c++ 开发语言 后端
于 2022-03-01 11:38:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45510561/article/details/123195377
版权

文章目录

后置++有两个参数

在这里插入图片描述

运算符的重载什么时候以引用返回什么时候以值的形式返回

返回的是*this就以引用返回这样可以少创建对象提高效率；
返回的是重载里面新创建的对象就以值的形式返回；

一，构造函数的三个作用：

创建对象，对象初始化，类型转换（要实现类型转换（银是你构造）构造函数只能是单参的构造函数）

class Int
{
private:
	int Value;
public:
	Int(int x = 0) :Value(x)
	{
		cout << "Create Int: " << this << endl;
	}
	//构造函数的三个作用：创建对象，对象初始化，类型转换
	Int(const Int& it) :Value(it.Value)
	{
		cout << "Copy Create Int: " << this << endl;
	}
	Int& operator=(const Int& it)
	{
		if (this != &it)
		{
			Value = it.Value;
		}
		cout << this << " ==== " << &it << endl;
		return *this;
	}
	~Int() { cout << "Destroy Int: " << this << endl; }
	void Printf()const
	{
		cout << Value << endl;
	}
};
int main()
{
	Int a(10);
	int b = 100;

	a = b;


	return 0;
}

在这里插入图片描述

如果想不允许这种隐士的类型转换explicit Int(const Int& it) :Value(it.Value)

字只能用于修饰只有一个参数的类构造函数, 它的作用是表明该构造函数是显示的, 而非隐式的, 跟它相对应的另一个关键字是implicit, 意思是隐藏的,类构造函数默认情况下即声明为implicit(隐式).
类型转换

int a;
doublie d=12.34;
a=d;发生了隐式转换，即编译器先把d强制类型转化为一个int类型的临时变量，值为12，然后由这个临时的int类型的变量去赋值给整型a。

class Object
{
	int val;
public:
	Object(int v=10) :val(v) { cout << "构造函数" << endl; };
	~Object() {};
	void operator=(const Object& obj)
	{
		if (&obj != this)
		{
			val = obj.val;
		}
		cout << "赋值语句" << endl;
	}
};
int main()
{
	Object obj;
	obj = 100;
	return 0;
}

在这里插入图片描述

class Int
{
private:
	int Value;
public:
	Int(int x = 0) :Value(x)
	{
		cout << "Create Int: " << this << endl;
	}
	//构造函数的三个作用：创建对象，对象初始化，类型转换
	//如果想不允许这种隐士的类型转换explicit Int(const Int& it) :Value(it.Value)
	explicit Int(const Int& it) :Value(it.Value)
	{
		cout << "Copy Create Int: " << this << endl;
	}
	Int& operator=(const Int& it)
	{
		if (this != &it)
		{
			Value = it.Value;
		}
		cout << this << " ==== " << &it << endl;
		return *this;
	}
	~Int() { cout << "Destroy Int: " << this << endl; }
	void Printf()const
	{
		cout << Value << endl;
	}
};
int main()
{
	Int a(10);
	int b = 100;
	a = (Int)b;
	return 0;
}

变向的将双参认为是单参

class Int
{
private:
	int Value;
public:
	Int(int x ,int y) :Value(x+y)
	{
		cout << "Create Int: " << this << endl;
	}
	//构造函数的三个作用：创建对象，对象初始化，类型转换
	//如果想不允许这种隐士的类型转换explicit Int(const Int& it) :Value(it.Value)
	 Int(const Int& it) :Value(it.Value)
	{
		cout << "Copy Create Int: " << this << endl;
	}
	Int& operator=(const Int& it)
	{
		if (this != &it)
		{
			Value = it.Value;
		}
		cout << this << " ==== " << &it << endl;
		return *this;
	}
	~Int() { cout << "Destroy Int: " << this << endl; }
	void Printf()const
	{
		cout << Value << endl;
	}
};
int main()
{
	Int a(10,20);
	int b = 100;
	a = b;
	return 0;
}

在这里插入图片描述

更改之后

class Int
{
private:
	int Value;
public:
	Int(int x ,int y=0) :Value(x*y)
	{
		cout << "Create Int: " << this << endl;
	}
	//a(10,20);
	// int b=100;
	// a=b,2;//a=(Int)(b,20)这是强转类型,逗号表达式取,的右边的值
	// a=(Int)(b,20)和a=Int(b,20)不一样后者是构造函数产生临时变量
	//构造函数的三个作用：创建对象，对象初始化，类型转换
	//如果想不允许这种隐士的类型转换explicit Int(const Int& it) :Value(it.Value)
	 Int(const Int& it) :Value(it.Value)
	{
		cout << "Copy Create Int: " << this << endl;
	}
	Int& operator=(const Int& it)
	{
		if (this != &it)
		{
			Value = it.Value;
		}
		cout << this << " ==== " << &it << endl;
		return *this;
	}
	~Int() { cout << "Destroy Int: " << this << endl; }
	void Printf()const
	{
		cout << Value << endl;
	}
};
int main()
{
	Int a(10,20);
	int b = 100;
	a = b;
	return 0;
}

class Int
{
private:
	int Value;
public:
	Int(int x ,int y=0) :Value(x+y)
	{
		cout << "Create Int: " << this << endl;
	}
	//a(10,20);
	// int b=100;
	// a=b,2;//a=(Int)(b,20)这是强转类型,逗号表达式取,的右边的值
	// a=(Int)(b,20)和a=Int(b,20)不一样后者是构造函数产生临时变量
	//构造函数的三个作用：创建对象，对象初始化，类型转换
	//如果想不允许这种隐士的类型转换explicit Int(const Int& it) :Value(it.Value)
	 Int(const Int& it) :Value(it.Value)
	{
		cout << "Copy Create Int: " << this << endl;
	}
	Int& operator=(const Int& it)
	{
		if (this != &it)
		{
			Value = it.Value;
		}
		cout << this << " ==== " << &it << endl;
		return *this;
	}
	~Int() { cout << "Destroy Int: " << this << endl; }
	void Printf()const
	{
		cout << Value << endl;
	}
};
int main()
{
	Int a(10,20);
	int b = 100;
	a = (Int)(b, 100);//必须是单参数的形式
	return 0;
}

整形强转符的重载（避免写很多的< >的运算符重载）

class Int
{
private:
	int Value;
public:
	Int(int x ,int y=0) :Value(x+y)
	{
		cout << "Create Int: " << this << endl;
	}
	//a(10,20);
	// int b=100;
	// a=b,2;//a=(Int)(b,20)这是强转类型,逗号表达式取,的右边的值
	// a=(Int)(b,20)和a=Int(b,20)不一样后者是构造函数产生临时变量
	//构造函数的三个作用：创建对象，对象初始化，类型转换
	//如果想不允许这种隐士的类型转换explicit Int(const Int& it) :Value(it.Value)
	 Int(const Int& it) :Value(it.Value)
	{
		cout << "Copy Create Int: " << this << endl;
	}
	Int& operator=(const Int& it)
	{
		if (this != &it)
		{
			Value = it.Value;
		}
		cout << this << " ==== " << &it << endl;
		return *this;
	}
	~Int() { cout << "Destroy Int: " << this << endl; }
	void Printf()const
	{
		cout << Value << endl;
	}
	operator int()const//重载一个整形强转符
	{
		return Value;
	}
};

int main()
{
	Int a(10);
	int b = 100;
	a = (Int)b;
	b = a;//b=a.operator int();
	b = (int)a;
}
int main()
{
	Int a = 10, b = 10;
	a < b;
	int x = 100;
	a < x;
	return 0;
}

易变关键字和()运算符的重载

mutable关键字作用：当类或者结构体中的某个变量被mutable关键字修饰时，即便这个结构体或者类被实例化为const类型，其中被mutable修饰的变量仍可以被修改。

class Add
{
private:
	mutable int value;//常方法中仍然可以改变属性的值
public:
	Add(int x = 0) : value(x) {}

	int operator()(int a, int b) const//()重载运算符
	{
		value = a + b;
		return value;
	}
};

int main()
{
	int a = 10, b = 20, c = 0;
	Add add;
	c = add(a, b);//凡是重载了()运动算符就称之为仿函数
	//c=add.operator()(a,b)
}
int main（）
{
int a=10,b=20,c=30;
c=Add()(a,b);//类型名加（）
//含义是调动构造函数产生将亡值对象在调用()运算符的重载赋值给c
}

二，当一个类的成员变量是对象时

不用初始化列表进行初始化

class Int
{
private:
	int Value;
public:
	Int(int x= 0) :Value(x)
	{
		cout << "Create Int: " << this << endl;
	}
	
	Int(const Int& it) :Value(it.Value)
	{
		cout << "Copy Create Int: " << this << endl;
	}
	Int& operator=(const Int& it)
	{
		if (this != &it)
		{
			Value = it.Value;
		}
		cout << this << " ==== " << &it << endl;
		return *this;
	}
	~Int() { cout << "Destroy Int: " << this << endl; }
	void Printf()const
	{
		cout << Value << endl;
	}
};

class Object
{
	int num;
	Int val;
public:
	Object(int x, int y)
	//进入该构造函数之前先要调动Int的构造函数产生对象Create Int:XXXXXXX
	//进入之后要用y给val赋值再次调用Int的拷贝构造函数产生临时对象Create Int:yyyyyyy
	//赋值时调用Int的赋值运算符重载
	//析构临时对象Destroy Int:yyyyyyy
	//主函数结束先析构obj对象在析构里面的成员对象对象Destroy Int:xxxxxxx
	{
	cout << "Create Object: " << this << endl;
		num = x;
		val = y;
	}
	~Object()
	{cout<<"Destroy Object: "<<this<<endl;}
};

int main()
{
	Object obj(1, 2);
	return 0;
}

在这里插入图片描述

使用初始化列表进行初始化

class Int
{
private:
	int Value;
public:
	Int(int x= 0) :Value(x)
	{
		cout << "Create Int: " << this << endl;
	}
	
	Int(const Int& it) :Value(it.Value)
	{
		cout << "Copy Create Int: " << this << endl;
	}
	Int& operator=(const Int& it)
	{
		if (this != &it)
		{
			Value = it.Value;
		}
		cout << this << " ==== " << &it << endl;
		return *this;
	}
	~Int() { cout << "Destroy Int: " << this << endl; }
	void Printf()const
	{
		cout << Value << endl;
	}
};

class Object
{
	int num;
	Int val;
public:
	Object(int x, int y):num(x),val(y)
	{
		cout << "Create Object: " << this << endl;
	}
	~Object()
	{
		cout << "Destroy Object: " << this << endl;
	}
};

int main()
{
	Object obj(1, 2);
	return 0;
}

在这里插入图片描述
成员属性在构造函数里面的构造顺序和初始化列表属性左右位置无关，和你在写类声明顺序有关

一，当一个类的成员变量是指针时，

*运算符的重载和->运算符的重载

class Int
{
private:
	int value;
public:
	Int(int x = 0) :value(x)
	{
		cout << "Create Int: " << this << endl;
	}

	Int(const Int& it) :value(it.value)
	{
		cout << "Copy Create Int: " << this << endl;
	}
	Int& operator=(const Int& it)
	{
		if (this != &it)
		{
			value = it.value;
		}
		cout << this << " ==== " << &it << endl;
		return *this;
	}
	~Int() { cout << "Destroy Int: " << this << endl; }
	void Printf()const
	{
		cout << value << endl;
	}
	int& Value()
	{

		return value;
	}
	const int& Value()const { return value; }
};
class Object
{
	Int* ip;
public:
	Object(Int* s = NULL) :ip(s) {}
	Object()
	{
		if (ip != NULL)
		{
			delete ip;
		}
		ip = NULL;
	}
	//int GetIp() { return ip->Value(); }//可以这样写但是没必要
	Int * operator*()
	{
		return ip;
	}
	const Int* operator*()const
	{
		return ip;
	}
	Int* operator->()
	{
		return ip;
	}
	const Int* operator->()const
	{
		return ip;
	}
};
int main()
{
	Object obj(new Int(10));
	//这样写的好处是可以对Int这个对象的生存期实现自动化
	(*obj)->Value();//使用了*运算符的重载
	obj->Value();//->运算符重载
}

组合

1,强关联
在这里插入图片描述
2，弱关联
在这里插入图片描述
3，强引用
在这里插入图片描述

何为自动化管理

class Int
{
private:
	int value;
public:
	Int(int x = 0) :value(x)
	{
		cout << "Create Int: " << this << endl;
	}

	Int(const Int& it) :value(it.value)
	{
		cout << "Copy Create Int: " << this << endl;
	}
	Int& operator=(const Int& it)
	{
		if (this != &it)
		{
			value = it.value;
		}
		cout << this << " ==== " << &it << endl;
		return *this;
	}
	~Int() { cout << "Destroy Int: " << this << endl; }
	void Printf()const
	{
		cout << value << endl;
	}
	int& Value()
	{

		return value;
	}
	const int& Value()const { return value; }
};
class Object
{
	Int* ip;
public:
	Object(Int* s = NULL) :ip(s) {}
	Object()
	{
		if (ip != NULL)
		{
			delete ip;
		}
		ip = NULL;
	}
	//int GetIp() { return ip->Value(); }//可以这样写但是没必要
	Int & operator*()
	{
		return *ip;
	}
	const Int& operator*()const
	{
		return *ip;
	}
	Int* operator->()
	{
		return &**this;
		//*this是obj对象然后是obj的*重载的调用
		//return ip;
	}
	const Int* operator->()const
	{
		return &**this;
		//return ip;
	}
};
int main()
{
	Object obj(new Int(10));
	//这样写的好处是可以对Int这个对象的生存期实现自动化，当程序结束时会自己调用析构函数
	Int* p = new Int(10);//这个必须手动的delete否则内存泄漏；
	(*p).Value();//*p是对裸指针p的解引用
	(*obj).Value();//*obj是obj对*运算符重载的调用
	ip->Value();//裸指针的直接运用
	obj->Value();//obj对->运算符重载的调用
}
丽丽的代码
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++操作符重载+、-、*、/、[]、（）、＜＜、＞＞、=、new、delete、&&、||、++、--、+=、强制转换重载
weixin_44190648的博客
12-18 2120
注意：为什么ostream& operator
C++学习9：C++重载“*”和“-＞”运算符 和智能指针的假设
12-06 330
C++重载“*”和“->”运算符 和智能指针的假设
C++之*与->的重载
maoliran的博客
06-06 534
C++中指针一直是个不被人待见的东西，不仅是因为指针这个东西让人把关系搞不清楚，而且对指针new一个空间后，往往会忘记delete释放空间，这就让内存的泄漏不可避免的发生了。 如今有个auto_ptr（智能指针）来解决这个问题：class A{ public: A(){ cout << "constuctor" << endl; } ~A(){
初入c++（七）运算符的重载+、-、*、/、[]、自加++的重载
tr_ainiyangyang的博客
07-20 704
1.为什么要用到运算符的重载 所谓重载，就是赋予新的含义。函数重载（Function Overloading）可以让一个函数名有多种功能，在不同情况下进行不同的操作。运算符重载（Operator Overloading）也是一个道理，同一个运算符可以有不同的功能. 看下面这个代码：怎样实现虚数的加减。 #include using namespace std; cla
C++运算符重载（二）简单易懂的智能指针教程，指针类运算符重载。-＞运算符重载，*运算符重载，【】运算符重载。最后附带完整实现代码。
qq_51004011的博客
06-27 1588
在C++中使用new实例化一个该类的对象时，使用完这个对象后我们需要自己去释放这一块向堆区申请的空间。 那么如果我们忘记释放某一个new出来的对象，那么就可能造成内存泄漏的情况。为了避免这样的情况出现，就出现了智能指针这个概念。...
面向对象作业1-构造函数+运算符重载.docx
最新发布
07-06
自定义一个时间类，有两种构造方法：给三个数值或给一个字符串。 要求可以使用cout输出该对象。两个对象可以相差，得到两个时间的间隔秒数（正数）。 假设主程序main及运行结果如下： int main() { MyTime t1(12,30...
php中拷贝构造函数、赋值运算符重载
10-28
php中拷贝构造函数、赋值运算符重载方法， 需要的朋友可以参考下
详解C++ 拷贝构造函数和赋值运算符
09-01
总之，理解C++中的拷贝构造函数和赋值运算符是编写可靠代码的关键，它们在对象复制和值传递中起到核心作用。同时，深拷贝和浅拷贝的区分对于管理动态分配的资源至关重要，避免潜在的编程陷阱。通过自定义拷贝构造...
C++中的四个默认成员函数与运算符重载详解
08-29
四个默认成员函数包括构造函数、析构函数、拷贝构造函数和赋值运算符重载函数，这些函数是类的成员函数，用于定义类对象的创建、销毁、复制和赋值等操作。 1. 构造函数：构造函数是特殊的成员函数，用于初始化类...
c++ demo，运算符重载，成员函数的实现
01-24
本教程通过一个DEMO深入探讨如何在C++中实现运算符重载以及如何利用成员函数来完成这一过程。 首先，理解运算符重载的基本原理。在C++中，当我们对自定义类型（如类或结构体）使用运算符时，编译器会寻找与该运算符...
C++运算符重载之+，-，*，/
qq_58665528的博客
01-10 1526
运算符“+”的重载 class Point { private: int m_xPosition; int m_yPosition; public: Point(int xPosition = 0, int yPosition = 0); //构造函数 声明 const Point operator+(const Point& point) const; //重载运算符+ 声明 }; //构造函数 定义 Point::Point(int xPosition, int y.
操作符*或者->的重载
多看多听多总结
05-29 374
一般操作符*返回的是对象的引用 ，而->返回的是对称的指针 以Test类为例 class Test { public: Test() :a(0), b(0) {} Test& operator*() { cout << "operator*" << endl; return *this; } Test* operator->() { cout " << endl;
c语言中 int和const int的区别
热门推荐
m0_73964151的博客
10-01 1万+
一、const int 和int 的区别 具体的是 int定义的是一个变量，不需要初始化const int定义的是常量，需要初始化 1、返回值 const int & 是返回这个数值的一个常量的引用。 而int 是返回这个数值的一个拷贝。 int 是进行拷贝构造，而const int & 是返回的引用。拷贝构造更消耗时间，与此同时还用析构函数。因为产生了一个拷贝，你就可以轻易地修改拷贝的内容。 2、取指针 const int类型一旦定义以后就不能修改，int类型是随时可以修改的
函数重载的作用
sinat_15164393的博客
04-11 3637
函数重载是指在同一作用域内，可以有一组具有相同函数名，不同参数列表的函数，这组函数被称为重载函数。重载函数通常用来命名一组功能相似的函数，这样做减少了函数名的数量，避免了名字空间的污染，对于程序的可读性有很大的好处。 如果没有函数重载机制，如在C中，你必须要这样去做：为这个print函数取不同的名字，如print_int、print_string。这里还只是两个的情况，如果是很多个的话，就需要为实...
构造函数的重载
qq_45288949的博客
04-29 6122
（一）重载函数条件 (1)函数名相同 (2）函数参数不同（一下两个满足其中一个即可） 1）函数参数个数不同 2）函数参数类型不同 注意：函数返回值不同不能作为函数重载条件 重载：根据函数参数个数和参数数据类型来自动调用哪一个重载函数 （二）构造函数的重载 1）默认/缺省构造函数 （1）如果没有构造函数，系统会提供一个默认的构造函数帮助创建对象 （2）默认构造函数没有参数 2）复制/拷贝构造函数 用对象初始化另一个对象，需要用到复制构造函数 （1）作用：用一个已知的对象初始化另一
构造函数(一) 构造函数及重载
03-31 2245
什么是构造函数 构造函数是初始化类对象的类成员函数。在c++中，当对象被创建时，自动调用构造函数，构造函数是该类的一个特殊成员的函数 构造函数和一般的成员函数有什么不同 构造函数的名称和类的名称完全相同 构造函数没有返回类型(包括void) 创建对象的时候自动调用构造函数 如果我们不写构造函数，编译器会自动创建一个没有参数的构造函数，函数主体内什么也没有（默认构造函数） 函数体中不能有...
构造函数的定义与重载
Keep Learning, Keep Growing, Keep Succeeding!
05-29 2311
构造函数：处理对象的初始化，是一种特殊的成员函数，与其他函数不同，不需要用户来调用它，在建立对象时自动执行。 每建立一个对象，就调用一次构造函数； 构造函数没有返回值，因此也没有类型，作用只是对对象进行初始化； 构造函数不需要被用户调用，也不能被用户调用。 构造函数的重载：构造函数具有相同的名字，而参数列表不同（参数的个数或参数类型不相同）。 注意：重载函数的参数个数，参数类型或参数顺序...
C++：构造函数和析构函数
杜恒其的博客
04-15 1168
 在C++中，有一种特殊的成员函数，它的名字和类名相同，没有返回值，不需要用户显式调用（用户也不能调用），而是在创建对象时自动执行。这种特殊的成员函数就是构造函数（Constructor）。 构造函数必须是 public 属性的，否则创建对象时无法调用。当然，设置为 private、protected 属性也不会报错，但是没有意义。 构造函数没有返回值，因为没有变量来接收返回值，即使有也
指针运算符重载（* 和 -＞）
hsjdjhdijdsj的博客
12-05 289
#include <iostream> #include <stdlib.h> using namespace std; class Arry{ public: Arry(const int len = 10):arr(new int[len]),size(len){ for(int i = 0; i < size; i++){ arr[i] = i; } } Arry(const Arry &obj):arr(new int[obj.size
复制运算符重载和拷贝构造函数的区别
05-16
复制运算符重载和拷贝构造函数都是用于对象的复制，但它们的实现方式和使用场景有所不同。 拷贝构造函数是在创建一个新对象时调用的，它的作用是将已有对象的数据成员复制到新对象中。拷贝构造函数的原型为`...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值