深入运算符重载(2)

最新推荐文章于 2024-07-25 23:22:43 发布
最新推荐文章于 2024-07-25 23:22:43 发布
阅读量424 收藏 1
点赞数 1
分类专栏： C++学习经历 文章标签： c++ 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46401837/article/details/122914146
版权

深入运算符重载(2)

目录

1、运算符重载时，什么时候以引用返回，什么时候以值返回？

以值返回：

 Int operator+(const Int& it)
 {
     this->value += it.value;
     
     return Int(this->value + it.value);
 }

以引用返回：

Int &operator+=(const Int &it)
{
    this->value += it.value;
    
    return *this;
}

a += b;

总结：凡是运算符返回自身时候，以引用返回。但是以将亡值返回的时候，需要使用值返回。

2、构造函数的三个作用

class Int
{
private:
	int value;
public:
    //1 2 3
    Int(int x = 0):value(x)
    {
        cout << "Int()" << this << endl;
    }
    
    Int(const Int &it):value(it.value) 
    {
        cout << "Copy Int:" << this << endl;
    }
    
    Int &operator=(const Int &it)
    {
        if(this != &it)
        {
            value = it.value;
        }
       	cout << this << " = " << &it << endl;
        
        return *this;
    }

}

int main()
{
    Int a = 10;			//自定义类型
   	//Int a(10);
    
    int b = 100;		//内置类型
    
    a = b;
}

构造函数的三个作用：

  1. 构建对象
  2. 初始化对象
  3. 类型转换（仅限单参数的构造函数）

3、什么是类型转换

我们看下面这个例子

问题：如上main函数所示，能否将b赋值给a？

回答：构造函数的第三个功能，类型转化

首先我们观察，一个是int 类型，一个是自定义的Int类型。如果将b给a赋值，显然是不能通过的，但是编译器并没有报错，这是怎么一回事？在这里插入图片描述

我们将b进行转化，转化为自定义类型。然后将转化后的类型给a赋值。

通过调用我们可以发现：
在这里插入图片描述

我们创建出一个临时对象地址为012FF690，然后将临时对象赋值给a对象。

再来看一下析构过程：

~Int()
{
    cout << "Destroy Int: " << this << endl;
}

在这里插入图片描述
可以发现临时对象在赋值完毕后就会被销毁。

3.1 此处可以类型转换的构造函数必须是单参数的。

//构造函数
Int(int x,int y):value()
{
    cout << "Int()" << this << endl;
}

int main()
{
    Int a(10,20);
    int b = 100;
    
    a = b;		//error：必须只含有一个参数
}

在这里插入图片描述

如果给参数初始值的化也可以以当作是一个参数：

Int(int x,int y = 0):value()
{
    cout << "Int()" << this << endl;
}

int main()
{
    Int a(10);
    int b = 100;
    
    a = b;				//right :赋了默认值
}

问题：a的值是多少呢？

Int(int x,int y = 0):value(x + y)
{
    cout << "Int()" << this << endl;
}

int main()
{
    Int a(1,2);
    int b = 100;
    //a = b;
    //a = b,20;		//逗号运算符，按最右的为准。
    
    //a = (Int)(b,20);	//也是逗号表达式，取20，也就是(Int) 20;
    //a = Int(b,20);	//调用两个参数的构造函数，创建一个无名对象，将20给y，b给x，结果是120； 
}

最后两者都会产生临时对象，第一种按照类型转换方式来调用构造函数，第二种产生一个无名对象，接收两个参数。

接上面的问题，那如果给两个参数，还不给默认初始化呢？

Int(int x,int y):value(x + y)
{
    cout << "Int()" << this << endl;
}

int main()
{
    Int a(10,20);
    int b = 100;
    
    a = (Int)(b,100);	//error：强转形式创建无名对象
    a = Int(b,100);		//right：调动构造函数创建无名对象

}

对于类型强转类型的对象，我们只能给一个有效参数，给多了error

3.2 如果不允许隐式进行构造函数：构造函数前添加explicit关键字。

...
explicit Int(int x = 0):value(x)
{
    cout << "Int()" << this << endl;
}
...
    
int main()
{
    Int a(10);
    int b = 100;
    
    a = b;				//error，不能隐式的类型转换
    
    a = (Int) (200);	//right，强制转换后可以
}

3.3 我们能否将变量给对象赋值呢？

explicit Int(int x):value(x)
{
    cout << "Create Int:" << this << endl;
}

int main()
{
    Int a(10);
    int b = 100;
    
    a = (Int)b;
    
    b = a;			//error
    
    b = (int)a;		//尝试类型转换：error
    
}

不可以这样操作，我们没有强制转换类型的缺省函数。我们需要自己写。返回类型是强转的类型（系统给出）

operator int()const 
{
    return value;	
    //返回类型是强转的类型
}

int operator int()const 
{
    return value;
}
//如果是这种情况则刚好：
// b = (int)a;

//如果是这种情况：b = (float)a;
//不可能再写一个float类型的重载函数

//上述代码的main函数
int main()
{
    Int a(10);
    int b = 100;
    
    a = (Int)b;
    
    b = a;
    //调用强转函数
    //相当于：b = a.operator int();
    //相当于：b = operator int(&a);
    b = (int)a;		
    
}

总结：

  1. 当需要将内置类型赋值给对象的时候，我们可以通过强制转换，通过单参构造函数来构建无名对象；
  2. 当需要将对象赋值给内置类型的时候，可以通过运算符重载函数来实现。

3.4 mutable关键字和仿函数

有如下类：

class Add
{
   mutable int value;
   //即使
public:
    Add(int x = 0) : value(x) {}
  	
    int operator()(int a,int b) const 
    //添加const value将无法被修改,可以给value添加 mutable 关键字
    {
        value = a + b;
        return value;
    }
};

如下main函数：

int main()
{
    int a = 10,int b = 20, c = 0;
    Add add;
    
    c = add(a,b);	//仿函数
}

仿函数概念：仿函数即仿照的函数，表示它功能与函数类似但并不是真正的函数，仿函数又叫函数对象。在C++中它通过重载函数调用运算符即 （）运算符。

问题：赋值那句add对象是如何调用构造函数的？

add不会调用构造函数，会调用仿函数

c = add(a,b);		//我们重载了括号运算符

//相当于：
c = add.operator()(a,b);

更复杂的情况:

int main()
{
    int a = 10, b = 20, c = 0;
    c = Add()(a,b);
}

类型名加 () 调用构造函数，产生一个将亡值对象，然后调用自己的

() 运算符重载，将a和b相加，最后赋值给c。

总结：

  1. 被mutable修饰的成员变量，即使在成员方法中为this指针添加const 修饰也可以被修改。
  2. 凡是重载了括号的运算符，我们就叫做仿函数。当碰见对象( )的时候要注意，可能是对象构造，可能是调用仿函数。

4、构造函数使用初始化列表和赋值的区别

思考下面代码的输出方式：

#include<iostream>
using namespace std;

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


class Object
{
    int num;
    Int val;			//Int类型对象
public:
    Object(int x,int y)
    {
        num = x;
        val = y;

        cout << "create Objcet:" << this << endl;
    }

    ~Object()
    {
        cout << "destroy Object:"<< this << endl;
    }
};

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

过程分析：
在这里插入图片描述在这里插入图片描述在这里插入图片描述

输出结果：在这里插入图片描述

初始化列表和在构造函数里面赋值等同的效果（仅限内置类型）

Object(int x,int y):num(x)	//等价赋值语句
{
    cout << "Create Object:"<< this << endl;
    //num = x;		//等价于初始化列表
    val = y;
}

但是自定义类型就不一样，不需要构造临时对象

Object(int x,int y):num(x),val(y)
{
    cout << "Create Object:"<< this << endl;
    //num = x;		//等价于初始化列表
    //val = y;
}

在这里插入图片描述

总结：对于内置类型，效率相同；对于自定义类型的初始化，尽量使用初始化列表的方式进行，节省空间。

5、类数据成员的构造顺序

按照设计顺序进行构建

#include<iostream>
using namespace std;

class Object
{
    int num;
    int sum;		//与定义数据相关
public:
    Object(int x = 0):sum(x),num(sum)
    {
        
    }
    
    void Print()const 
    {
        cout << num << " " << sum << endl;
    }
};

C++中类数据成员的构造与初始化列表中成员的顺序无关，与类数据成员再类中定义的数据有关。

过程分析：

  1. 首先构造的是num，其次是sum。根据编译器会将所有的数据成员先初始化为0，再赋值。
  2. num先被构造，将sum的值赋给num。但是此时sum未被构造，是0或是随机数，将这个值赋给了num。
  3. 后来将x的值赋给sum。

6、对象生存期管理方式

class Object
{
    Int *ip;
public:
    Object(Int *s = NULL):ip(s) {}
    ~Object()
    {
        if(ip != NULL)
        {
            delete ip;
        }
        ip = NULL;
    }
};


int main()
{
    Object obj(new Int(10));
    //new 的三个作用
    //1、从堆区申请空间
    //2、调用构造函数，构造对象
    //3、返回对象的地址
}

过程分析：

  1. new有三个作用，首先会从堆区开辟一块空间，接着调用构造函数来构建对象，最后会返回对象的地址。将10存放到开辟的空间中，指针s来指向这个空间，在构造函数中还会将s来赋值给ip。
  2. 对象结束后，如果ip为空，则删除ip。将ip赋值为空。

这样做有什么好处呢？

可以将 Int 对象的生存期进行自动管理，我们将上下两个代码进行对比。

手动管理：

int fun()
{
    Int *ip = new Int(10);
    
    ...
        
    delete ip;		//如果没有这一步，会发生内存泄漏，由我们手动进行
}

int main()
{
    fun();
}

自动管理:

int fun()
{
    Object obj(new Int(10));
    //在堆区申请的空间，如果fun函数结束，obj局部对象会被销毁，会调用它的析构函数。而它的析构函数中有delete，由系统自动进行
}

int main()
{
    fun();
}

7、*运算符和->运算符重载后返回对象的区别

分析下面代码：

class Int
{
private:
	int value;
public:
    Int(int x = 0):value(x)
    {
        cout << "Int()" << this << endl;
    }
    
    Int(const Int &it):value(it.value) 
    {
        cout << "Copy Int:" << this << endl;
    }
    
    Int &operator=(const Int &it)
    {
        if(this != &it)
        {
            value = it.value;
        }
       	cout << this << " = " << &it << endl;
        
        return *this;
    }
	
    ~Int()
    {
        cout << "Destory Int:" << this << 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 &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 *ip = new Int(10);
    (*ip).Value();
    (*obj).Value();
    obj->Value();
    ip->Value();
}

重载*返回的是对象本身,重载指向符返回的是对象的指向。

为什么呢，我们看一下组合的概念：

组合：

  1. 值类型
  2. 指针类型
  3. 引用类型（最复杂）
    在这里插入图片描述

第一种组合最常见，val 对象是整个Object 类的一部分。

第二种指针类型的组合，ip并不是Object类的一部分，是一种弱关联，指针指向的对象可以被改变。

如果使用对ip进行访问，返回对象本身。如果通过*->进行访问，得到的是堆区的地址**。
在这里插入图片描述

第三中组合通过引用来修饰类内对象，是强关联，修改val对象会影响到。

明白了这个我们就可以将->进行进一步的修改:

Int * opearotr->()	//重载->运算符
{
    return &**this;
    //return ip;			//返回的是对象的地址
}

const Int *opearotr->()const 
{
    return &**this;
    //return ip;
}

问题：&**this是如何理解的呢？

this指针指向当前的对象，*this的意思就是对象本身。

再来一个就是 * * this，他会调用重载函数，返回的是所指向的对象的别名（返回 * ip）。

这时加上&，与解引用相互抵消，就是ip的地址。

那么，返回最初的代码，为什么解引用加.能和->有同样的作用呢？

class Int
{
private:
	int value;
public:
    Int(int x = 0):value(x)
    {
        cout << "Int()" << this << endl;
    }
    
    Int(const Int &it):value(it.value) 
    {
        cout << "Copy Int:" << this << endl;
    }
    
    Int &operator=(const Int &it)
    {
        if(this != &it)
        {
            value = it.value;
        }
       	cout << this << " = " << &it << endl;
        
        return *this;
    }
	
    ~Int()
    {
        cout << "Destory Int:" << this << 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 &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 *ip = new Int(10);
    (*ip).Value();
    (*obj).Value();
    obj->Value();
    ip->Value();
}

在这里插入图片描述

在创建对象之前，会为obj对象和p对象分配空间。obj对象中有着指针对象，所以占4个字节（32位）；p对象就是传统的指针对象，也占4个字节。

当要构造obj对象的时候，会先将他的临时对象参数先构造出来，在堆区创建一个空间来保存无名对象，值为10。接着p对象也需要创建一个无名对象，由p直接指向它，值为1。

接着p访问的就是p所致空间的内容；而 * obj就需要调用运算符的重载函数，返回的是解引用后的ip,也就是值为10的临时对象临时对象，通过Value来取到它的值。

p->Value()没什么好说的。关键在于obj->Value()，首先会调用->重载运算符。*obj的含义是得到ip，**obj 就是 * ip，得到临时对象的内容。& *ip，& 和 * 相互抵消，就是ip。ip->Value()，与最普通的p->Value()类似。

baobaobashi_
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深入理解运算符重载
yc2zgh1314的博客
04-23 1257
函数 自定义类的 赋值运算符重载函数的作用与内置纷纷投赋值运算符的作用类似，但是要注意的是，它与 拷贝构造函数与析构函数一样，要注意深拷贝浅拷贝的问题，在没有深拷贝浅拷贝的情况下，如果没有指定默认的赋值运算符重载函数，那么系统将会自动提供一个赋值运算符重载函数。 运算符重载的声明方式与方法的声明方式相同，但operator 关键字告诉 编译器，它实际上是一个运算符重载，后面
Python运算符重载用法实例
09-22
首先，让我们深入理解Python运算符重载的基本概念。在Python中，当运算符应用于自定义类的对象时，Python会尝试调用一些特殊方法（也称为魔术方法）。例如，`__add__` 方法对应于加法运算符 `+`。当我们执行 `a + b`...
C++ 运算符重载：C++ 运算符重载的高级技巧和最佳实践
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
04-03 830
【C++运算符重载】C++ 运算符重载：详解与实现
C++ 运算符重载深入学习总结笔记
xUeeeto_的博客
08-21 776
运算符重载引入 1. 从函数重载说起 函数重载是在一定作用域内，多个相同名称但不同参数列表的函数重载 编译时由编译器根据实际调用时给的实参情况来判定本次实际用哪个函数， 这个过程叫重载决策 重载函数本质上就是多个独立函数， 重载机制在编译时发生，运行时不参与 函数重载的意义就是避免我们胡乱起名，方便编写类库覆盖所有可能操作，是一种语法糖 2. 什么是运算符重载 什么是运算符？譬如 + - * / % 等算术运算符和 > < == != 等关系运算符就是典型的可重载运算符（但不是所有的运算符
C++运算符重载函数作为类成员函数和友元函数
Cgengzhihui的博客
01-15 2468
全文转自：http://c.biancheng.net/cpp/biancheng/view/217.html 例10.2中对运算符“+”进行了重载，使之能用于两个复数的相加。在该例中运算符重载函数operator+作为Complex类中的成员函数。 可能有的读者会提出这样的问题：”+“是双目运算符，为什么在例10.2程序中的重载函数中只有一个参数呢？实际上，运算符重载函数有两个参数，由于重载函...
CPP.rar_运算符重载
09-24
本文将深入探讨C++中的运算符重载，特别是关于“+”、“-”、“*”和“=”这四个常见运算符的重载。 一、运算符重载的概念 运算符重载并不创建新的运算符，而是为已有的运算符提供不同的操作方式。它基于函数多态性...
深入解析C++编程中的运算符重载
09-02
2. 运算符重载为友元函数： - 友元函数不隶属于任何类，但可以访问类的私有和保护成员。当运算符重载需要操作两个不同类的对象，或者运算符需要访问非调用对象的数据时，通常使用友元函数。 运算符重载的主要优点...
C++运算符重载和继承
01-17
在C++编程中，运算符重载和继承是两个核心概念，它们极大地扩展了语言的能力，使得代码更加灵活且易于理解。本章我们将深入探讨这两个主题，并通过实际代码示例来阐述它们的工作原理。 首先，让我们关注“运算符...
c++ *运算符重载
09-04
在C++中，运算符重载是一项强大的特性，它允许程序员根据自己的需求为自定义类型定义运算符的行为。这使得代码更加简洁、直观，并且能够更自然地表达复杂的操作。在给定的标题和描述中，重点是关于`*`运算符的重载，...
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1244
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
C++ primer plus 第16章string 类和标准模板库, 关联容器
zhyjhacker的博客
07-25 705
C++ primer plus 第16章string 类和标准模板库, 关联容器。
VS2019编译和使用gtest测试（C++）
m0_65635427的博客
07-24 293
下载下来解压到文件夹，再在文件夹里面新建一个build文件夹，如下：再安装cmake，可以先检查一下是否安装了cmake，打开命令窗口，输入cmake -version：然后双击就对了，我这里已经安装好了，无法提供截图，注意一点就是在让选择是否建立系统环境变量（path）的时候，记得勾上第二个建立系统环境变量！下载好之后，记得检验一下是否安装成功，如果在普通用户下显示没有，建议用管理员身份打开命令窗口，再次尝试。之后命令窗口进入创建的build文件夹路径里面执行cmake ../
【C++修炼之路 第五章】string 类（补充）：string 扩展空间规律 + reserve 的缩容 + resize 的使用
唯有忍受别人不能忍受的，才能享受别人不能享受的
07-23 1154
【详细剖析】string 扩展空间规律 + reserve 的缩容性质与只改变capacity的性质 + resize 的使用 + shink_to_fit 的缩容函数
Windows图形界面(GUI)-MFC-C/C++ - Dialog
最新发布
0xCC说逆向
07-25 1040
流程打开资源视图：在Visual Studio中，右键点击资源文件夹（通常是），选择“添加” -> “资源”。添加对话框资源：在弹出的对话框中选择“Dialog”，然后点击“新建”。设计对话框：在资源编辑器中，你可以拖放控件到对话框上，如按钮、文本框、列表框等。拓展资源ID：每个对话框都有一个唯一的资源ID，用于在代码中引用。对话框编辑器：用于可视化地设计和布局对话框。
【C++初阶】string类
2301_78022459的博客
07-24 895
【C++初阶】string类
学懂C语言（二十一）：深入理解C语言中的函数指针和回调函数
martian665的专栏
07-23 597
学懂C语言：C语言中的函数指针和回调函数详解
C++(week14): C++提高:(一)面向对象设计：设计原则、设计模式
Edward2022的博客
07-25 801
类与类之间的五种关系、面向对象的七种设计原则、23种设计模式
如何在C\#中创建HTML表格
程序员-张师傅
07-24 371
在C#中创建HTML表格通常不是直接由C#语言本身完成的，因为C#是一种面向对象的编程语言，主要用于后端逻辑处理。然而，在Web开发中，你可能会在C#代码（如在ASP.NET MVC、ASP.NET Core MVC或Razor Pages应用程序中）中生成HTML表格的字符串，或者更常见的是，使用Razor视图引擎来动态生成HTML表格。
深入理解：赋值运算符重载与运算符多态
**赋值运算符重载详解** 在C++编程中，运算符重载是一种强大的特性，它允许程序员扩展已有的运算符以适应特定类或数据结构的需求。本文主要聚焦于C++中的赋值运算符“=”的重载，该运算符在原始意义上是用于将右侧...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值