luodaoyi

Cpp8 运算符重载和深浅拷贝
深浅拷贝相同类型间可以直接拷贝// _20180212.cpp : Defines the entry point...
右键或长按保存图片
23
2018/02

Cpp8 运算符重载和深浅拷贝

深浅拷贝

相同类型间可以直接拷贝

// _20180212.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"

#include <stdio.h>
#include <windows.h>

class A
{
private:
    int* a;
public:
    A()
    {
        a = new int[10];
    }
    virtual ~A()
    {
        delete a;
        printf("析构 A \n");
    }
};

int main(int argc,char* argv[])
{
    A a1;
    A a2;
    a1 = a2;
    return 0;
}

//反汇编


27:       A a1;
0040108D   lea         ecx,[ebp-14h]
00401090   call        @ILT+15(B::B) (00401014)
00401095   mov         dword ptr [ebp-4],0
28:       A a2;
0040109C   lea         ecx,[ebp-1Ch]
0040109F   call        @ILT+15(B::B) (00401014)
004010A4   mov         byte ptr [ebp-4],1
29:       a1 = a2;
004010A8   lea         eax,[ebp-1Ch]
004010AB   push        eax              //a2 作为参数传递
004010AC   lea         ecx,[ebp-14h]    //a1 作为this指针传递
004010AF   call        @ILT+45(A::operator=) (00401032)
30:       return 0;


A::operator=:
004012E0   push        ebp
004012E1   mov         ebp,esp
004012E3   sub         esp,44h
004012E6   push        ebx
004012E7   push        esi
004012E8   push        edi
004012E9   push        ecx
004012EA   lea         edi,[ebp-44h]
004012ED   mov         ecx,11h
004012F2   mov         eax,0CCCCCCCCh
004012F7   rep stos    dword ptr [edi]
004012F9   pop         ecx 

//eax = a1首地址
004012FA   mov         dword ptr [ebp-4],ecx 
004012FD   mov         eax,dword ptr [ebp-4]   
//ecx = a2首地址
00401300   mov         ecx,dword ptr [ebp+8]
//ecx + 4 这里是 class A中变量a的地址(ecx 对应虚表地址) 
//因为ecx是变量a2 所以这里的edx = a2.a   
00401303   mov         edx,dword ptr [ecx+4]   
//a2.a 赋值给a1.a
00401306   mov         dword ptr [eax+4],edx
//返回a1首地址 
00401309   mov         eax,dword ptr [ebp-4]

0040130C   pop         edi
0040130D   pop         esi
0040130E   pop         ebx
0040130F   mov         esp,ebp
00401311   pop         ebp
00401312   ret         4

我们发现使用=直接赋值对象,编译器自动生成了operator= 函数用于处理类型赋值
我们观察编译器自动生成的函数operator=,这里赋值直接略过了虚表(ecx+4)

// _20180212.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"

#include <stdio.h>
#include <windows.h>

class A
{
private:
    int* a;
public:
    A()
    {
        a = new int[10];
    }
    virtual ~A()
    {
        delete a;
        printf("析构 A \n");
    }

    int* get_a()
    {
        return a;
    }
};

int main(int argc,char* argv[])
{
    A a1;
    A* a2 = new A;
    a1 = *a2;
    delete a2;
    int* i = a1.get_a();

    for (int j =0;j<10;j++)
    {
        i[j] = j;
    }
    return 0;
}

上述代码看似正常,运行也不报错,原因是虽然delete a2;释放掉了a2的内存,内存管理器虽然认为此内存无用,但是却仍然可以访问,所以这里是在非法使用内存

步骤分析

A a1;
A* A2 = new A;

此时a1和a2对应的内存占用如图

a1 = *a2;

这一步是无脑拷贝 把a2.a 赋值给 a1.a

此时的内存结构

这里 a指向的 int* a 就造成了内存泄漏

delete a2;

这里释放掉a2
内存结构如图

这里a2中的int* a成员指向的内存已经释放,
但是此时a1的int* a成员仍然指向a2的成员指向的内存

int* i = a1.get_a();

    for (int j =0;j<10;j++)
    {
        i[j] = j;
    }

这里调用get_a 方法 获取 a1.a的地址,把指向的内存赋值。
这里获取到的 int* i指向的已经是个不存在的 非法的内存块
所以这里就造成了内存的非法访问,如果操作系统吧这里的位置分配给其他位置使用
那么就造成了数据混乱,造成比内存泄漏更危险的错误

以上的拷贝方式,就被称为浅拷贝
浅拷贝:只拷贝成员的值
深拷贝:拷贝的不只是成员。还有成员指向的内存的数据

所以在对象拥有指针成员的时候,就需要慎重考虑使用深拷贝还是浅拷贝

运算符重载

一个类,需要比较类的大小

class Number
{
public:
    Number(int x,int y):x(x),y(y)
    {
    }
    bool Max(Number& n)
    {
        return    this->x>n.x && this->y>n.y;
    }
private:
    int x;
    int y;
};

int main(int argc, char* argv[])
{
    Number n1(1,1),n2(2,2);
    
    bool r = n1.Max(n2);
    return 0;
}

bool类型,其实就是一个char true是1 false是0

为了比较 n1和n2的大小。我们定义了一个max函数。此时我们写的时候有没有感觉很繁琐,那么我们能不能像基础类型那样使用 >这样的符号来做运算呢 比如

boolr = n1 > n2;

答案是可以的!

// _20180223.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"

class Number
{
public:
    Number(int x,int y):x(x),y(y)
    {
    }
    bool operator>(Number& n)
    {
        return    this->x>n.x && this->y>n.y;
    }
private:
    int x;
    int y;
};

int main(int argc, char* argv[])
{
    Number n1(1,1),n2(2,2);
    
    bool r = n1 > (n2);
    return 0;
}

重载 ++ -- + - * / > < 等等运算符

class Number
{
public:
    Number(int x,int y):x(x),y(y)
    {
    }
    Number operator++();
    Number operator--();
    Number operator+(const Number& p);
    Number operator-(const Number& p);
    Number operator*(const Number& p);
    Number operator/(const Number& p);

    bool operator<(const Number& p);
    bool operator==(const Number& p);
    bool operator>(const Number& n)
    {
        return    this->x>n.x && this->y>n.y;
    }
private:
    int x;
    int y;
};

int main(int argc, char* argv[])
{
    Number n1(1,1),n2(2,2);
    
    bool r = n1 > (n2);
    return 0;
}
最后修改:2018 年 02 月 23 日 10 : 26 PM
如果觉得我的文章对你有用,请随意赞赏

发表评论