// C++11 之前
vector<string> create_large_vector() {
    vector<string> result(1000000, "hello");
    return result;  // ?? 拷貝 100萬(wàn)個(gè) string！
}
vector<string> v = create_large_vector();
// 內(nèi)部發(fā)生：
// 1. 分配新內(nèi)存
// 2. 拷貝 100萬(wàn)個(gè) string（每個(gè)又要拷貝字符串內(nèi)容）
// 3. 銷(xiāo)毀臨時(shí)對(duì)象
// 性能災(zāi)難！

?C++11 的解決方案：移動(dòng)語(yǔ)義

// C++11
vector<string> create_large_vector() {
    vector<string> result(1000000, "hello");
    return result;  // ? 移動(dòng)，幾乎零開(kāi)銷(xiāo)！
}
vector<string> v = create_large_vector();
// 內(nèi)部發(fā)生：
// 1. 交換指針（僅復(fù)制幾個(gè)字節(jié)）
// 2. 臨時(shí)對(duì)象被置空
// 快如閃電！

三、move 的本質(zhì)

??move 不移動(dòng)任何東西！

// std::move 的實(shí)際實(shí)現(xiàn)（簡(jiǎn)化版）
template<typename T>
typename remove_reference<T>::type&& move(T&& t) noexcept {
    return static_cast<typename remove_reference<T>::type&&>(t);
}
// 它只是一個(gè)類(lèi)型轉(zhuǎn)換！
// 左值 → 右值引用

核心理解：

? std::move 是無(wú)條件的類(lèi)型轉(zhuǎn)換
? 它把左值轉(zhuǎn)換成右值引用
? 真正的"移動(dòng)"發(fā)生在移動(dòng)構(gòu)造函數(shù)或移動(dòng)賦值運(yùn)算符

四、拷貝 vs 移動(dòng)對(duì)比

??深拷貝（C++98）

class String {
    char* data;
    size_t size;
public:
    // 拷貝構(gòu)造函數(shù)
    String(const String& other) {
        size = other.size;
        data = new char[size];           // 1. 分配新內(nèi)存
        memcpy(data, other.data, size);  // 2. 拷貝數(shù)據(jù)
        // ?? 慢！
    }
    // 拷貝賦值運(yùn)算符
    String& operator=(const String& other) {
        if (this != &other) {
            delete[] data;               // 1. 釋放舊內(nèi)存
            size = other.size;
            data = new char[size];       // 2. 分配新內(nèi)存
            memcpy(data, other.data, size);  // 3. 拷貝數(shù)據(jù)
        }
        return *this;
    }
};
String s1("hello");
String s2 = s1;  // 深拷貝：分配內(nèi)存 + 拷貝 5 字節(jié)

?移動(dòng)（C++11）

class String {
    char* data;
    size_t size;
public:
    // 移動(dòng)構(gòu)造函數(shù)
    String(String&& other) noexcept {
        data = other.data;        // 1. 偷走指針
        size = other.size;
        other.data = nullptr;     // 2. 置空源對(duì)象
        other.size = 0;
        // ? 快！只復(fù)制指針
    }
    // 移動(dòng)賦值運(yùn)算符
    String& operator=(String&& other) noexcept {
        if (this != &other) {
            delete[] data;        // 1. 釋放舊內(nèi)存
            data = other.data;    // 2. 偷走指針
            size = other.size;
            other.data = nullptr; // 3. 置空源對(duì)象
            other.size = 0;
        }
        return *this;
    }
};
String s1("hello");
String s2 = std::move(s1);  // 移動(dòng)：只復(fù)制指針，8 字節(jié)
// s1 現(xiàn)在是空的（被掏空）

??性能對(duì)比

// 移動(dòng) 100萬(wàn)個(gè) string
vector<string> v1, v2;
for (int i = 0; i < 1000000; ++i) {
    v1.push_back(string(1000, 'a'));  // 每個(gè) 1KB
}
// 拷貝
auto start = now();
v2 = v1;  // 深拷貝：1GB 數(shù)據(jù)
auto end = now();
// 耗時(shí)：~500ms
// 移動(dòng)
auto start = now();
v2 = std::move(v1);  // 移動(dòng)：只復(fù)制幾個(gè)指針
auto end = now();
// 耗時(shí)：~1ms ? 快 500 倍！

五、move 的典型使用場(chǎng)景

?場(chǎng)景 1：函數(shù)返回大對(duì)象

// 返回局部變量
vector<int> createVector() {
    vector<int> result(1000000);
    // ...
    return result;  // C++11 自動(dòng)移動(dòng)（NRVO優(yōu)化）
}
// 顯式 move（通常不需要）
vector<int> createVector() {
    vector<int> result(1000000);
    return std::move(result);  // ?? 不推薦，會(huì)阻止 RVO
}

?場(chǎng)景 2：容器插入臨時(shí)對(duì)象

vector<string> names;
// C++98：拷貝
string temp = "Alice";
names.push_back(temp);  // 拷貝 temp
// C++11：移動(dòng)
string temp = "Alice";
names.push_back(std::move(temp));  // 移動(dòng) temp
// temp 現(xiàn)在是空的
// 更好：直接構(gòu)造
names.emplace_back("Alice");  // 最優(yōu)

?場(chǎng)景 3：交換對(duì)象

// C++98：三次拷貝
void swap(string& a, string& b) {
    string temp = a;  // 拷貝
    a = b;            // 拷貝
    b = temp;         // 拷貝
}
// C++11：三次移動(dòng)
void swap(string& a, string& b) {
    string temp = std::move(a);  // 移動(dòng)
    a = std::move(b);             // 移動(dòng)
    b = std::move(temp);          // 移動(dòng)
}
// 標(biāo)準(zhǔn)庫(kù) std::swap 就是這樣實(shí)現(xiàn)的

?場(chǎng)景 4：unique_ptr 轉(zhuǎn)移所有權(quán)

unique_ptr<int> p1 = make_unique<int>(42);
unique_ptr<int> p2 = p1;              // ? 編譯錯(cuò)誤：禁止拷貝
unique_ptr<int> p2 = std::move(p1);   // ? 移動(dòng)：轉(zhuǎn)移所有權(quán)
// 現(xiàn)在 p1 是空的，p2 擁有對(duì)象
cout << (p1 == nullptr);  // true
cout << *p2;              // 42

?場(chǎng)景 5：容器元素轉(zhuǎn)移

vector<string> v1 = {"apple", "banana", "cherry"};
vector<string> v2;
// 移動(dòng)單個(gè)元素
v2.push_back(std::move(v1[0]));  // v1[0] 變成空字符串
// 移動(dòng)整個(gè)容器
v2 = std::move(v1);  // v1 變成空容器

?場(chǎng)景 6：多線程傳遞數(shù)據(jù)

void process(vector<int> data) {
    // 處理數(shù)據(jù)
}
vector<int> large_data(1000000);
// 傳遞給線程（移動(dòng)，避免拷貝）
thread t(process, std::move(large_data));
// large_data 現(xiàn)在是空的，數(shù)據(jù)已轉(zhuǎn)移到線程

?場(chǎng)景 7：成員變量初始化

class Widget {
    string name;
    vector<int> data;
public:
    // 移動(dòng)參數(shù)到成員變量
    Widget(string n, vector<int> d) 
        : name(std::move(n))      // 移動(dòng)
        , data(std::move(d)) {    // 移動(dòng)
    }
};
string s = "widget";
vector<int> v = {1, 2, 3};
Widget w(std::move(s), std::move(v));  // s 和 v 被掏空

六、move 后的對(duì)象狀態(tài)

??關(guān)鍵規(guī)則：移后源對(duì)象處于"有效但未指定"狀態(tài)

string s1 = "hello";
string s2 = std::move(s1);
// s1 的狀態(tài)：
// ? 有效：可以安全地調(diào)用成員函數(shù)
// ?? 未指定：不知道具體內(nèi)容
// 安全操作
s1.clear();           // ? 可以
s1 = "new value";     // ? 可以
if (s1.empty()) {}    // ? 可以
s1.~string();         // ? 析構(gòu)函數(shù)總是被調(diào)用
// 不安全操作
cout << s1;           // ?? 可能輸出空字符串或其他
cout << s1[0];        // ? 未定義行為（如果 s1 為空）

??STL 容器移動(dòng)后的保證

vector<int> v1 = {1, 2, 3};
vector<int> v2 = std::move(v1);
// v1 的狀態(tài)：
// ? 保證為空容器
cout << v1.size();     // 0
cout << v1.empty();    // true
v1.push_back(42);      // ? 可以繼續(xù)使用

七、常見(jiàn)陷阱

?陷阱 1：對(duì)右值使用 move

vector<int> v = std::move(createVector());
//              ^^^^^^^^^ 多余！createVector() 已經(jīng)是右值
// 正確寫(xiě)法
vector<int> v = createVector();  // 自動(dòng)移動(dòng)

?陷阱 2：move 后繼續(xù)使用

string s1 = "hello";
string s2 = std::move(s1);
cout << s1.size();  // ?? 結(jié)果未定義（可能是 0，也可能不是）
// 正確寫(xiě)法
string s1 = "hello";
string s2 = std::move(s1);
s1.clear();         // 先重置
s1 = "new value";   // 再使用

?陷阱 3：const 對(duì)象無(wú)法移動(dòng)

const string s1 = "hello";
string s2 = std::move(s1);  // ?? 仍然是拷貝！
// 原因：
// 移動(dòng)構(gòu)造函數(shù)簽名：String(String&& other)
// const 左值轉(zhuǎn)換后：const String&&
// 無(wú)法匹配，退化為拷貝構(gòu)造函數(shù)

?陷阱 4：返回局部變量時(shí)使用 move（阻止 RVO）

// ? 錯(cuò)誤
string create() {
    string s = "hello";
    return std::move(s);  // 阻止 NRVO 優(yōu)化
}
// ? 正確
string create() {
    string s = "hello";
    return s;  // 編譯器自動(dòng)優(yōu)化（RVO/NRVO）
}

八、何時(shí)必須用 move？

// 1. 轉(zhuǎn)移 unique_ptr 所有權(quán)
unique_ptr<int> p1 = make_unique<int>(42);
unique_ptr<int> p2 = std::move(p1);  // 必須
// 2. 將左值傳給只接受右值的函數(shù)
void process(vector<int>&& v);  // 只接受右值
vector<int> data = {1, 2, 3};
process(std::move(data));  // 必須
// 3. 容器中移動(dòng)元素
vector<string> v1 = {"a", "b"};
vector<string> v2;
v2.push_back(std::move(v1[0]));  // 需要
// 4. 實(shí)現(xiàn)移動(dòng)語(yǔ)義
class MyClass {
    MyClass(MyClass&& other) noexcept {
        data = std::move(other.data);  // 遞歸移動(dòng)成員
    }
};

九、性能數(shù)據(jù)

struct LargeObject {
    vector<int> data;
    LargeObject() : data(1000000) {}
};
// 測(cè)試拷貝 vs 移動(dòng)（1000 次）
auto test_copy = [&]() {
    vector<LargeObject> v;
    for (int i = 0; i < 1000; ++i) {
        LargeObject obj;
        v.push_back(obj);  // 拷貝
    }
};
auto test_move = [&]() {
    vector<LargeObject> v;
    for (int i = 0; i < 1000; ++i) {
        LargeObject obj;
        v.push_back(std::move(obj));  // 移動(dòng)
    }
};
// 結(jié)果（典型值）
拷貝：5000ms  （分配+拷貝 4GB 數(shù)據(jù)）
移動(dòng)：50ms    （只拷貝指針）
? 快 100 倍！

十、最佳實(shí)踐

?規(guī)則總結(jié)

// 1. 返回局部變量：不要 move
return result;  // 讓編譯器優(yōu)化
// 2. 轉(zhuǎn)移容器/智能指針：必須 move
v2 = std::move(v1);
p2 = std::move(p1);
// 3. 傳參給右值引用函數(shù)：使用 move
void func(string&& s);
func(std::move(my_string));
// 4. 移動(dòng)成員變量：使用 move
Widget(string s) : name(std::move(s)) {}
// 5. 優(yōu)先 emplace_back 而非 push_back + move
v.emplace_back(args...);  // 最優(yōu)

??記憶口訣

move 不移動(dòng)，只轉(zhuǎn)換
左值變右值，資源可轉(zhuǎn)移
拷貝變移動(dòng)，性能翻百倍
移后可析構(gòu)，內(nèi)容不保證

十一、與其他特性的關(guān)系

// move + perfect forwarding
template<typename T>
void wrapper(T&& arg) {
    func(std::forward<T>(arg));  // 完美轉(zhuǎn)發(fā)
}
// move + RVO
string create() {
    return string("hello");  // RVO，無(wú)需 move
}
// move + emplace
v.emplace_back(std::move(s));  // 組合使用

總結(jié)

方面	核心要點(diǎn)
本質(zhì)	類(lèi)型轉(zhuǎn)換：左值 → 右值引用
目的	避免深拷貝，實(shí)現(xiàn)資源轉(zhuǎn)移
代價(jià)	幾乎零開(kāi)銷(xiāo)（只復(fù)制指針）
副作用	源對(duì)象被"掏空"
適用	大對(duì)象、容器、智能指針
性能提升	10-1000 倍（取決于對(duì)象大?。?/td>

一句話：std::move 讓 C++ 從"拷貝語(yǔ)義"進(jìn)化到"移動(dòng)語(yǔ)義"，是現(xiàn)代 C++ 性能優(yōu)化的基石。

有具體的使用場(chǎng)景嗎？我可以幫你分析要不要用 move！

到此這篇關(guān)于C++ move 的作用詳解及陷阱最佳實(shí)踐的文章就介紹到這了,更多相關(guān)C++ move 使用內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章:

C++
move

最新国产好看的视频,伊人天堂AV在线,国产Aaaaaa视频,蜜臀视频在线观看一区,人妻av色图,密臀久久久精品影片,青青视频免费观看毛片,久草在线观看视,国产三级精品色情在线

C++ move 的作用詳解及陷阱最佳實(shí)踐

目錄

C++ move 的作用詳解

一、一句話總結(jié)

二、為什么需要 move？

??C++98/03 的痛點(diǎn)

?C++11 的解決方案：移動(dòng)語(yǔ)義

三、move 的本質(zhì)

??move 不移動(dòng)任何東西！

四、拷貝 vs 移動(dòng)對(duì)比