C++赋值运算符重载

赋值运算符重载=赋值本身时存在问题
如p1= p1；

#include<iostream>
using namespace std;
 class Person
 {
public:
    Person(int a )
   {
    m_Age = new int (a);   // new int 返回 int *指针

   } 
   ~Person()
   {
    if (m_Age != NULL)
    {
        delete m_Age;
        m_Age = NULL;
    }
   }
   Person& operator=(Person &p)
   {
    if (m_Age != NULL)
    {
        delete m_Age;
        m_Age = NULL;
    }
    m_Age = new int (*p.m_Age);  //  这一行重要p.m_Age是一个指针，指向传入的值，
                                         //再解引用，新开一个空间使m_Age指向这个值而不是指向指针
    return *this;
   }                                                             
   int *m_Age;
 };
 void test01()
{
    Person p1(55);

    Person p2(20);

    Person p3(30);
    // p3 = p2 = p1; //赋值操作
    p1 = p1;

    cout << "p1的年龄为:" << *p1.m_Age << endl;

    cout << "p2的年龄为:" << *p2.m_Age << endl;

    cout << "p3的年龄为:" << *p3.m_Age << endl;
}
main()
{
    test01();
    system("pause");
    return 0;
}

if (m_Age != NULL)
    {
        delete m_Age;
        m_Age = NULL;
    }

把这段代码注释了就不报错，看起来像是拷贝之前把自身删除了
那么这段代码的必要性在哪能体现出来，或者怎么解决?

出现问题的原因是在赋值运算符重载函数中，在删除m_Age指针之前检查了它是否为NULL。这样做的目的是为了避免重复删除指针导致的问题。然而，在执行p1 = p1; 这样的自我赋值操作时，由于指针没有发生改变，m_Age指向的内存块实际上没有被删除，因此删除操作是多余的。这可能导致了问题的出现。

解决这个问题的一种方法是在赋值运算符重载函数中添加自我赋值检查。可以在赋值运算符重载函数中添加以下代码：

if (&p == this) {
return *this; // 如果是自我赋值，直接返回当前对象
}

这样，当进行自我赋值操作时，函数将直接返回当前对象，而不会进行后续的删除和内存分配操作。

另外，为了确保在删除指针之后将其设置为NULL，可以在删除m_Age指针之后立即将其设置为NULL，而不是在条件判断中。例如：

delete m_Age;
m_Age = NULL;

这样可以确保在删除指针之后，m_Age指针始终是NULL。

把要删除的对象想用指针q记录下来，执行拷贝之后再delete q

不知道你这个问题是否已经解决, 如果还没有解决的话:
  • 帮你找了个相似的问题, 你可以看下: https://ask.csdn.net/questions/7768942
  • 这篇博客你也可以参考下：打印素数和两个小游戏 C语言从入门到入土（入门篇）（算法篇p1）
  • 除此之外, 这篇博客: 常量指针、指针常量，指针数组、数组指针，函数指针、指针函数中的 2.1 指针数组 *p1[5] 部分也许能够解决你的问题, 你可以仔细阅读以下内容或者直接跳转源博客中阅读:
     数据类型    *数组名[常量表达式][常量表达式]...... ;

    它是一个数组，数组的元素都是指针，数组占多少个字节由数组本身的大小决定，每个元素都是一个指针。

    例如：char *arr[]={“Sunday”,“Monday”}，存储了两个指针，第一个指针指向了字符串"Sunday"，第二个指针指向了字符串"Monday"，而sizeof(arr)=8，因为在32位平台，指针类型大小占4个字节。指针数组最重要的用途是对多个字符串进行处理操作，因为字符指针比二维数组更快更有效。

    在这里插入图片描述
    下面是个简单的例子

    #include <stdio.h>
int main()
{
    //定义三个整型数组
	int a[5] = { 1,2,3,4,5 };
	int b[5] = { 6,4,8,3,1 };
	int c[5] = { 2,5,8,6,1 };
    //定义一个存放指向整型变量的指针的数组arr
    int* arr[] = { a,b,c };
    //通过接引用打印出三个一维数组的元素
	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 5; j++)
        {
		    printf("%d ", *(arr[i]+j));
	    }
        printf("\n");
    }
	return 0;
}

    结果如下：

      1 2 3 4 5

  6 4 8 3 1

  2 5 8 6 1

    以上对arr解引用的方式有很多，它们都是等价的，我们来举个例子：

    #include<stdio.h>
int main()
{
	int i = 0;
	int a[3][4] = { {1,2,3,4} ,{5,6,7,8} ,{9,10,11,12} };//定义一个二维数组
	int* pa[3];//定义一个指针数组
	for (i = 0; i < 3; i++)//给指针数组赋值
		pa[i] = a[i];
    printf("指针数组的内容为:\n");
	for (i = 0; i < 3; i++)//打印出指针数组的内容
	{
		int j;
		for (j = 0; j < 4; j++)
			printf("%d ", *(*(pa + i) + j));
		printf("\n");
	}
    //以下均为不同方式的解引用操作
    printf("不同解引用操作的结果为:\n");
	printf("%d,%d\n", a[1][1], *(pa[1] + 1));
	printf("%d,%d\n", a[1][1], *(*(pa+1) + 1));
	printf("%d,%d\n", a[1][1], (*(pa + 1))[1]);
	printf("%d,%d\n", a[1][1], pa[1][1]);
    return 0;
}

    结果如下所示：

    指针数组的内容为:

1 2 3 4
5 6 7 8
9 10 11 12

不同解引用操作的结果为:

6,6
6,6
6,6
6,6

    从以上例子可看出解引用有多种方式，它们的等价形式如下：

    *( pa[i] + j )         //等价于 *( a[i] + j )

*( *(p+i) + j )        //等价于 *( *(a+j) + j )

( *(p+i) )[ j ]        //等价于( *(a+i) )[ j ]

p[ i ][ j ]                //等价于 a[i][j]

    补充（1）：指针数组还可以和字符串数组相结合使用，请看下面的例子：

    #include <stdio.h>
int main(){
    char *str[3] = {"lirendada","C语言","C Language"};
 
    printf("%s\n%s\n%s\n", str[0], str[1], str[2]);
    return 0;
}

    结果如下：

    lirendada

c语言

C Language

    需要注意的是，字符数组 str 中存放的是字符串的首地址，不是字符串本身，字符串本身位于其他的内存区域，和字符数组是分开的。

    也只有当指针数组中每个元素的类型都是char *时，才能像上面那样给指针数组赋值，其他类型不行。

    为了便于理解，可以将上面的字符串数组改成下面的形式，它们都是等价的。

    #include <stdio.h>
int main(){
    char *str0 = "lirendada";
    char *str1 = "C语言";
    char *str2 = "C Language";
    char *str[3] = {str0, str1, str2};
    printf("%s\n%s\n%s\n", str[0], str[1], str[2]);
    return 0;
}

    补充（2）：二维数组与指针数组的区别

    char *p1[]={"lirendada","C","C++"};
char p2[][8]={"liren","C","C++"};

    *p1，*(p1+1)，*(p1+2)：所指向的字符串常量是不规则长度的，且sizeof(p1)=12。


p2[0]，p2[1]，p2[2]所指向的字符串都是一定长度的，且sizeof(p2)=24。
  • 以下回答来自chatgpt:

    在进行赋值运算符重载时，需要特别处理自我赋值的情况。因为这种情况下，如果在赋值前没有检查并处理这种情况，会导致拷贝内容不正确，出现意想不到的错误。

    具体处理方法可以在赋值运算符重载函数中加入自我赋值检查，当赋值操作的目标对象和当前对象是同一个对象时，可以直接返回*this，避免产生拷贝错误。示例代码如下：

    class MyClass {
public:
    // 赋值运算符重载
    MyClass& operator=(const MyClass& other) {
        // 自我赋值检查
        if (this == &other) {
            return *this;
        }
        // 其他的赋值操作
        // ...
        return *this;
    }
};

    另外，在赋值操作中，如果动态申请了内存，则需要注意资源管理问题，避免出现内存泄漏等问题。可以使用智能指针等方法进行资源管理，或在析构函数中释放资源。代码示例如下：

    class MyClass {
public:
    MyClass() {
        m_data = new int(0);
    }
    ~MyClass() {
        delete m_data;
    }
    // 赋值运算符重载
    MyClass& operator=(const MyClass& other) {
        // 自我赋值检查
        if (this == &other) {
            return *this;
        }
        // 释放旧资源
        delete m_data;
        // 分配新资源
        m_data = new int(*other.m_data);
        return *this;
    }
private:
    int* m_data;
};

    以上是对问题的解决方案，通过自我赋值检查和资源管理，可以在赋值运算符重载时避免赋值本身存在问题的情况。


如果你已经解决了该问题, 非常希望你能够分享一下解决方案, 写成博客, 将相关链接放在评论区, 以帮助更多的人 ^-^