从运算符重载到指针悬挂

在Mayuyu讲解指针悬挂之前，先来简单讲一下运算符重载，因为一般情况下我们是通过重载赋值运算符来解决指针

悬挂问题的。

我们知道，在C++中，编译时多态性是通过函数重载和运算符重载来实现的，也称为静态多态性。而运行时多态性是

通过继承和虚函数来实现的，也称为动态多态性。那么我们先来看看什么是运算符重载。

我们都知道对于像"+","-","*","/"，这样的运算符来说，进行运算的对象必须是基本数据类型，比如int，long

等等。那么两个对象将无法进行这些操作，实际上通过运算符重载，同样可以进行这些操作，比如两个复数相加。

我们可以写出如下代码：

#include <iostream>
#include <string.h>
#include <stdio.h>

using namespace std;

class complex
{
public:
double real;
double imag;
complex(double real=0.0,double imag=0.0)
{
this->real = real;
this->imag = imag;
}
};

complex operator+(complex c1,complex c2)
{
complex t;
t.real = c1.real + c2.real;
t.imag = c1.imag + c2.imag;
return t;
}

//重载输出运算符"<<"
ostream &operator<<(ostream &out,complex &c)
{
out<<c.real<<"+"<<c.imag<<"i"<<endl;
return out;
}

int main()
{
complex c1(1.0,2.0);
complex c2(3.0,4.0);
complex ans1,ans2;
ans1 = c1 + c2;
ans2 = operator+(c1,c2);
cout<<ans1<<ans2<<endl;
return 0;
}

在我们定义好重载运算符后，可以通过ans1 = c1 + c2或者ans2 = operator+(c1,c2)来使用它。似乎上面

的代码没有什么问题，但是前提是我们把数据成员都定义成共有的，所以在外界我们能直接用，如果你把它们设置

private类型的，你会发现编译不过，原因很简单：私有数据在类外部不能访问。我们学过友元函数，他本身不是

类的成员函数，但是我们却可以通过它来访问类内部的私有数据，相当于在类这个无法进入的黑匣子开了一个小孔，

这样就使得外界可以访问类内部的私有数据了。

我们把上面的代码修改一下：

#include <iostream>
#include <string.h>
#include <stdio.h>

using namespace std;

class complex
{
private:
double real;
double imag;
public:
complex(double real=0.0,double imag=0.0)
{
this->real = real;
this->imag = imag;
}
friend complex operator+(complex c1,complex c2);
friend ostream &operator<<(ostream &out,complex &c);
};

complex operator+(complex c1,complex c2)
{
complex t;
t.real = c1.real + c2.real;
t.imag = c1.imag + c2.imag;
return t;
}

//重载输出运算符"<<"
ostream &operator<<(ostream &out,complex &c)
{
out<<c.real<<"+"<<c.imag<<"i"<<endl;
return out;
}

int main()
{
complex c1(1.0,2.0);
complex c2(3.0,4.0);
complex ans1,ans2;
ans1 = c1 + c2;
ans2 = operator+(c1,c2);
cout<<ans1<<ans2<<endl;
return 0;
}

嗯，这样达到了目的。。。注意不能用友元函数重载的运算符有：=，()，[]，->，所以要重载这四个运算符，必

须把它们当作成员函数。

现在我们来看两个重要的运算符++p和p++，它们是怎么重载的呢 ？ 这个很重要。。。在C++中，编译器可以通过

在运算符函数参数表中是否插入关键字int来区分这两种方式。即：

classname operator++(); 相当于++p

classname operator++(int); 相当于p++

比如：

#include <iostream>
#include <string.h>
#include <stdio.h>

using namespace std;

class X
{
private:
int x,y;
public:
X(int x,int y)
{
this->x = x;
this->y = y;
}
X operator++();
X operator++(int);
friend ostream &operator<<(ostream &out,X &c);
};

X X::operator++()
{
++x;
++y;
return *this;
}

X X::operator++(int)
{
x++;
y++;
return *this;
}

//重载输出运算符"<<"
ostream &operator<<(ostream &out,X &c)
{
out<<c.x<<" "<<c.y<<endl;
return out;
}

int main()
{
X c1(1,2);
X c2(3,4);
++c1;
c2++;
cout<<c1<<c2<<endl;
return 0;
}

到了这里，Mayuyu把运算符重载基本讲完了。。。

讲完运算符重载，我们来进一步看看指针悬挂问题。

#include <iostream>
#include <string.h>
#include <stdio.h>

using namespace std;

class String
{
private:
char *str;
public:
String(char *s)
{
str = new char[strlen(s) + 1];
strcpy(str,s);
}
~String()
{
delete str;
}
void Print()
{
cout<<str<<endl;
}
};

int main()
{
String p1("Mayuyu");
{
String p2("Hello!");
p2 = p1;
p2.Print();
}
p1.Print();
return 0;
}

如上代码，我们知道对象之间的赋值其实就是引用，而不是重新开辟一块新的空间。也就是说在main()中执行语句

p2 = p1后，指针指向情况如下图：



也就是说，p1和p2指向同一块内存空间，而在主函数的{}中的代码在执行完毕后会调用p2的析构函数，也就是说

p1和p2共同指向的那块内存被释放了，那么将会出现指针p1指向不明确，p1变成了野指针。这样是极其危险的。

所以我们要解决这个问题，一个很明显的解决办法就是，在执行"="运算符时，让p1和p2各指向一个内存块，而这

两个内存块一个是另一个的复制品，这样就避免了上面的出错情况。当然实际上还有一个做法也是比较好的，方法

大致如下：

对于同一个内存块，我们用一个count统计，有多少个指针指向它，加一个指针count++，释放一个count--，

如果最后count = 1时，我们才真正释放这块内存，这样貌似比较麻烦，不在我们讨论范围内。

下面，我们只需要重载"="，在函数体内实现拷贝就行了。代码如下：

#include <iostream>
#include <string.h>
#include <stdio.h>

using namespace std;

class String
{
private:
char *str;
public:
String(char *s)
{
str = new char[strlen(s) + 1];
strcpy(str,s);
}
~String()
{
delete str;
}
void Print()
{
cout<<str<<endl;
}
String &operator=(const String &);
};

String &String::operator=(const String &p)
{
if(this == &p) return *this;
delete str;
str = new char[strlen(p.str) + 1];
strcpy(str,p.str);
return *this;
}

int main()
{
String p1("Mayuyu");
{
String p2("Hello!");
p2 = p1;
p2.Print();
}
p1.Print();
return 0;
}

这样，就解决了指针悬挂问题。。。

Mayuyu在这里感谢广大网友的阅读，不要忘了评论哦！！！