0%

自定义类型的封装String：移动构造函数 + 移动赋值运算符

发表于 更新于 分类于 阅读次数：
本文字数： 2.1k 阅读时长 ≈ 2 分钟

2020年5月16日 下午11:34

总结：

  1. 移动：可以分为两类：
    1. 移动构造函数
    2. 移动赋值运算
  2. 实现移动的原理：
    1. 使用&&右值引用来实现移动，其实就是一种重载。
    2. 具体的可以查看吴永伟《C++实战》-右值引用到底有什么用

String.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#pragma once
using namespace std;
class String
{
public:
    String(const char *str = NULL);                              // 普通构造函数
    String(const String &other);                                  // 拷贝构造函数
    String(String&& other);                                         // 移动构造函数
    ~String(void);                                                         // 析构函数
    String& operator= (const String& other);             // 赋值函数
    String& operator=(String&& rhs)noexcept;		   // 移动赋值运算符

    friend ostream& operator<<(ostream& os, const String &c); // cout输出

private:
    char *m_data; // 用于保存字符串
};

String.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
#include "stdafx.h"


// _CRT_SECURE_NO_WARNINGS

// String 的普通构造函数
String::String(const char *str)
{
    if (str == NULL)
    {
        m_data = new char[1];
        if (m_data != NULL)
        {
            *m_data = '\0';
        }
        else
        {
            exit(-1);
        }
    }
    else
    {
        int len = strlen(str);
        m_data = new char[len + 1];
        if (m_data != NULL)
        {
            strcpy(m_data, str);
        }
        else
        {
            exit(-1);
        }
    }
}

// 拷贝构造函数
String::String(const String &other)
{
    int len = strlen(other.m_data);
    m_data = new char[len + 1];
    if (m_data != NULL)
    {
        strcpy(m_data, other.m_data);
    }
    else
    {
        exit(-1);
    }
}

// 移动构造函数
String::String(String&& other)
{
    if (other.m_data != NULL)
    {
        // 资源让渡
        m_data = other.m_data;
        other.m_data = NULL;
    }
}


// 赋值函数
String& String::operator= (const String &other)
{
    if (this == &other)
    {
        return *this;
    }
    // 释放原有的内容
    delete[ ] m_data;
    // 重新分配资源并赋值
    int len = strlen(other.m_data);
    m_data = new char[len + 1];
    if (m_data != NULL)
    {
        strcpy(m_data, other.m_data);
    }
    else
    {
        exit(-1);
    }

    return *this;
}

// 移动赋值运算符
String& String::operator=(String&& rhs)noexcept
{
    if(this != &rhs)
    {
        delete[] m_data;
        m_data = rhs.m_data;
        rhs.m_data = NULL;
    }
    return *this;
}

// String 的析构函数
String::~String(void)
{
    if (m_data != NULL)
    {
        delete[] m_data;
    }
}

ostream& operator<<(ostream& os, const String &c)
{
    os << c.m_data;
    return os;
}