移动语义和完美转发

移动语义和完美转发

移动语义

移动语义是 C++11 引入的一项特性,通过右值引用(Rvalue Reference)实现。它的目标是提高对于临时对象或即将销毁的对象的效率,避免不必要的深拷贝,而是在必要的时候将资源所有权从一个对象转移到另一个对象。

移动语义的关键在于对于右值引用的使用,它使用 && 表示。在移动语义中,有两个主要的概念:移动构造函数和移动赋值运算符。

移动构造函数

移动构造函数是一种特殊的构造函数,它允许将一个对象的资源(例如动态分配的内存、文件句柄等)从一个对象移动到另一个对象,而不是进行深拷贝。

代码示例:

class MyClass {
public:
    // 移动构造函数
    MyClass(MyClass&& other) noexcept {
        // 移动资源的所有权
        resource = other.resource;
        other.resource = nullptr;
    }

    // 其他成员函数和构造函数省略

private:
    int* resource;  // 假设 resource 是需要移动的资源
};
移动赋值运算符

移动赋值运算符用于将一个对象的资源移动到另一个对象,类似于移动构造函数,但是它在对象已经存在的情况下使用

class MyClass {
public:
    // 移动赋值运算符
    MyClass& operator=(MyClass&& other) noexcept {
        if (this != &other) {
            // 释放当前对象的资源
            delete resource;
            
            // 移动资源的所有权
            resource = other.resource;
            other.resource = nullptr;
        }
        return *this;
    }

    // 其他成员函数和构造函数省略

private:
    int* resource;  // 假设 resource 是需要移动的资源
};
move函数

move 是 C++ 标准库中定义的一个函数模板,位于头文件 中。它用于将一个左值转换为右值引用,主要用于支持移动语义。move 并不实际进行移动操作,它只是通过类型转换告诉编译器,我们允许对这个左值进行移动操作。

move函数的实现代码:

namespace std {
    template 
    constexpr remove_reference_t&& move(T&& arg) noexcept {
        return static_cast&&>(arg);
    }
}

std::move 接受一个模板参数 T,并返回一个 T&& 类型的右值引用。它实际上是通过 static_cast 进行类型转换的。在右值引用&&的特性中介绍到, T&&作为函数参数, 可以推到为左值引用

这里使用了 static_castT&& 转换为 remove_reference_t&&remove_reference_t 是一个模板元编程工具,用于移除引用。这个转换告诉编译器,我们希望将传入的左值引用 arg 转换为右值引用。

综合例子
#include 
#include 

class MyString {
public:
    // 普通构造函数
    MyString(const char* data) : size(std::strlen(data)), str(new char[size + 1]) {
        std::cout << "普通构造函数" << std::endl;
        strcpy_s(str, size + 1, data);
    }

    // 移动构造函数
    MyString(MyString&& other) noexcept : size(other.size), str(other.str) {
        std::cout << "移动构造函数" << std::endl;
        other.size = 0;
        other.str = nullptr;
    }

    // 移动赋值运算符
    MyString& operator=(MyString&& other) noexcept {
        std::cout << "移动赋值运算" << std::endl;
        if (this != &other) {
            delete[] str;
            size = other.size;
            str = other.str;
            other.size = 0;
            other.str = nullptr;
        }
        return *this;
    }

    // 打印字符串
    void print() const {
        std::cout << "String: " << (str ? str : "null") << std::endl;
    }

    ~MyString() {
        delete[] str;
    }

private:
    size_t size;
    char* str;
};

int main() {
    MyString a("Hello");  // 普通构造函数
    a.print();
    MyString b(std::move(a));  // 移动构造函数
    a.print(); // null
    b.print();
    // MyString c = b; // error 移动构造函数, = 右边应该是一个右值
    MyString c = std::move(b); // 移动构造

    a = MyString("World");  // 普通构造函数 + 移动赋值运算符
    // MyString("World") 属于是一个用普通构造创建的一个右值, 通过=赋值给a
    a.print();

    return 0;
}

输出结果为:

普通构造函数
String: Hello
移动构造函数
String: null
String: Hello
移动构造函数
普通构造函数
移动赋值运算
String: World
MyString b(std::move(a));  // 移动构造函数
a.print(); // null

a已经将资源转移给b了, 打印a输出null

完美转发

概述

完美转发是 C++11 引入的一个重要特性,它允许在模板中精确地保持函数参数的值类别(左值还是右值),并将它们传递到其他函数。完美转发通常用于实现泛型代码,特别是在编写通用函数模板时非常有用。

完美转发的核心在于使用通用引用(Universal Reference)和引用折叠。通用引用的语法是 T&&,其中 T 是模板参数。引用折叠是指在模板类型推导或类型声明的过程中,两个引用(无论是左值引用还是右值引用)可能折叠成一个引用。

代码示例:

#include 
#include 

// 用于演示的一个简单处理函数
void process(int& x) {
    std::cout << "Lvalue reference: " << x << std::endl;
}

void process(int&& x) {
    std::cout << "Rvalue reference: " << x << std::endl;
}

// 完美转发函数模板
template 
void forwarder(T&& arg) {
    // 在这里可以根据 arg 的值类别进行处理
    process(std::forward(arg));
}

int main() {
    int x = 42;

    forwarder(x);        // 传递左值
    forwarder(123);      // 传递右值

    return 0;
}

输出为:

Lvalue reference: 42
Rvalue reference: 123

在这个例子中,forwarder 是一个接受通用引用的函数模板,它调用 process 函数并使用 std::forward 来完美转发参数。process 函数有两个重载版本,分别接受左值引用和右值引用。

通过 forwarder(x) 调用时,T 被推导为 int&,从而调用了接受左值引用的 process 版本。通过 forwarder(123) 调用时,T 被推导为 int,从而调用了接受右值引用的 process 版本。(详细说明可以看下面的forward函数)

在实际使用中,完美转发通常结合模板参数包(Template Parameter Pack)和 std::forward 使用,以处理任意数量和类型的参数。这使得编写通用的函数模板成为可能,可以适应各种情况。

forward函数

这里从另一个角度说一下完美转发和forward函数

右值引用类型是独立于值的,一个右值引用作为函数参数的形参时,在函数内部转发该参数给内部其他函数时,它就变成一个左值,并不是原来的类型了。如果需要按照参数原来的类型转发到另一个函数,可以使用C++11提供的std::forward()函数,该函数实现的功能称之为完美转发。

函数原型如下:

// 函数原型
template  T&& forward (typename remove_reference::type& t) noexcept;
template  T&& forward (typename remove_reference::type&& t) noexcept;

// 精简之后的样子
std::forward(t);

重点:

  • 当T为左值引用类型时,t将被转换为T类型的左值
  • 当T不是左值引用类型时,t将被转换为T类型的右值

代码示例:

#include 
using namespace std;

template
void printValue(T& t)
{
    cout << "l-value: " << t << endl;
}

template
void printValue(T&& t)
{
    cout << "r-value: " << t << endl;
}

template
void testForward(T && v)
{
    printValue(v);
    printValue(move(v));
    printValue(forward(v));
    cout << endl;
}

int main()
{
    testForward(520);
    int num = 1314;
    testForward(num);
    testForward(forward(num));
    testForward(forward(num));
    testForward(forward(num));

    return 0;
}

输出结果:

l-value: 520
r-value: 520
r-value: 520

l-value: 1314
r-value: 1314
l-value: 1314

l-value: 1314
r-value: 1314
r-value: 1314

l-value: 1314
r-value: 1314
l-value: 1314

l-value: 1314
r-value: 1314
r-value: 1314
  1. testForward(520);函数的形参为未定引用类型T&&,实参为右值,初始化后被推导为一个右值引用
    printValue(v);已命名的右值v,编译器会视为左值处理,实参为左值
    printValue(move(v));已命名的右值编译器会视为左值处理,通过move又将其转换为右值,实参为右值
    printValue(forward(v));forward的模板参数为右值引用,最终得到一个右值,实参为右值

  2. testForward(num);函数的形参为未定引用类型T&&,实参为左值,初始化后被推导为一个左值引用
    printValue(v);实参为左值
    printValue(move(v));通过move将左值转换为右值,实参为右值
    printValue(forward(v));forward的模板参数为左值引用,最终得到一个左值引用,实参为左值

  3. testForward(forward(num));forward的模板类型为int,最终会得到一个右值,函数的形参为未定引用类型T&&被右值初始化后得到一个右值引用类型
    printValue(v);已命名的右值v,编译器会视为左值处理,实参为左值
    printValue(move(v));已命名的右值编译器会视为左值处理,通过move又将其转换为右值,实参为右值
    printValue(forward(v));forward的模板参数为右值引用,最终得到一个右值,实参为右值

  4. testForward(forward(num));forward的模板类型为int&,最终会得到一个左值,函数的形参为未定引用类型T&&被左值初始化后得到一个左值引用类型
    printValue(v);实参为左值
    printValue(move(v));通过move将左值转换为右值,实参为右值
    printValue(forward(v));forward的模板参数为左值引用,最终得到一个左值,实参为左值

  5. testForward(forward(num));forward的模板类型为int&&,最终会得到一个右值,函数的形参为未定引用类型T&&被右值初始化后得到一个右值引用类型
    printValue(v);已命名的右值v,编译器会视为左值处理,实参为左值
    printValue(move(v));已命名的右值编译器会视为左值处理,通过move又将其转换为右值,实参为右值
    printValue(forward(v));forward的模板参数为右值引用,最终得到一个右值,实参为右值

你可能感兴趣的:(开发语言,c++)