深入理解 C++ 左值右值、std::move 与函数重载中的参数传递

最新推荐文章于 2025-06-09 20:45:18 发布

achene_ql

最新推荐文章于 2025-06-09 20:45:18 发布

阅读量1k

点赞数 25

分类专栏： c++ 文章标签： c++ 开发语言服务器

本文链接：https://blog.csdn.net/2301_76564925/article/details/148520776

版权

c++ 专栏收录该内容

22 篇文章

订阅专栏

在 C++ 编程中，左值和右值的概念以及std::move的使用，常常让开发者感到困惑。特别是在函数重载场景下，如何合理利用这些特性来优化代码性能、确保语义正确，更是一个值得深入探讨的话题。

在开始之前，先提出几个问题：

当我定义一个函数func(int c) 时，我在调用这个函数 func（3）和int a = 3; func(a)有什么区别，形参在被实参赋值时调用拷贝构造吗，如果形参不是内置变量类型而是类类型又是什么情况？
那当函数不是值传递而是左值或右值的引用传递时会调用拷贝构造吗？
当我的类有一个私有成员变量cb_接受一个可执行类型数据作为回调函数，类提供一个公有成员方法setcallback来设置这个回调函数，setcallback有两种重载分别接受const T& t和右值引用 T&& t，但是两个的实现都是直接cb_ = t ，那么这里时调用拷贝赋值还是移动构造？
既然const T&可以接受右值，那我在现实时无论实参是左值还是右值，实现都用cb_ = std::move(t)不行吗，为什么好多开源代码中还要分别实现两个方法接收左值和右值？

如果回答不上来，请看下文讲解，并且在文章最后我们来回答这些问题。

一、左值与右值：

在 C++ 中，表达式可以分为左值（lvalue）和右值（rvalue）。简单来说，左值表示有标识符（如变量名）、能获取地址且可被多次使用的对象；而右值通常是临时的、无名称的，无法获取地址，生命周期短暂。

1.1 左值的特点

有标识符：例如int a = 10;中的a，通过变量名可以访问。

可寻址：可以使用&运算符获取其地址，如&a。

可多次使用：在程序的不同位置多次引用该变量。

1.2 右值的特点

无标识符：像字面量10，没有名称标识。

不可寻址：无法对其使用&运算符获取地址。

临时性：通常出现在表达式求值过程中，用完即销毁，例如a + 5中的a + 5计算结果就是一个右值。

1.3 左值与右值的判定示例

int main() {
    int x = 10;  // x是左值
    int y = x + 5;  // x + 5是右值，y是左值
    int&& rref = 20;  // 20是右值，rref是右值引用
    return 0;
}

二、std::move：

std::move它的作用是将左值强制转换为右值引用。但需要明确的是，std::move本身并不会移动任何数据，它只是提供了一种让编译器按照右值来处理对象的方式。

2.1 std::move 的实现原理

template<class T>
typename remove_reference<T>::type&& move(T&& t) {
    return static_cast<typename remove_reference<T>::type&&>(t);
}

通过模板推导和类型转换，std::move将传入的参数T&&（万能引用，可绑定左值或右值）转换为右值引用。

2.2 std::move 的使用场景

移动语义：在类中实现移动构造函数和移动赋值运算符时，使用std::move转移资源所有权，避免不必要的深拷贝，提升性能。例如std::vector在扩容时，就会利用移动语义高效地转移元素。

class MyString {
private:
    char* data;
public:
    MyString(const char* str) {
        // 深拷贝构造
    }
    MyString(MyString&& other) noexcept {
        data = other.data;
        other.data = nullptr;
    }
};

函数参数传递：当函数参数为右值引用时，将左值通过std::move转换后传入，触发移动操作。

三、函数重载中的参数传递：左值引用、右值引用与 const T&

在函数重载时，常常会定义不同参数类型的版本，如左值引用T&、右值引用T&&以及常量左值引用const T& ，以适配不同类型的实参，实现最佳的性能和语义。

3.1 左值引用T&

左值引用T&只能绑定左值（如果传一个右值会报错），常用于需要修改实参的场景。例如：

void modifyValue(int& num) {
    num++;
}

modifyValue函数通过左值引用接收参数，能够直接修改传入的变量。

3.2 右值引用T&&

右值引用T&&专门用于绑定右值，在函数内部可以安全地移动右值的资源。在移动语义中应用广泛：

void processRValue(int&& num) {
    // 可以安全地移动num
}

当传入右值（如字面量或临时对象）时，processRValue函数会高效地处理而不产生额外拷贝。

3.3 常量左值引用const T&

const T&既可以绑定左值，也可以绑定右值。它的优势在于能够以只读方式访问对象，避免不必要的拷贝，并且可以处理临时对象。但如果在使用const T&接收右值后，使用std::move进行移动操作，可能会出现问题。因为const修饰的对象不能被移动（移动构造函数通常不接受const参数）。

3.4 实际案例分析

假设我们有一个类MyClass，其中有一个私有成员变量cb_用于存储回调函数，并提供setCallback方法来设置回调。

class MyClass {
private:
    std::function<void()> cb_;
public:
    // 左值引用重载：拷贝赋值
    template<typename T>
    void setCallback(const T& t) {
        std::cout << "拷贝赋值" << std::endl;
        cb_ = t;
    }

    // 右值引用重载：移动赋值
    template<typename T>
    void setCallback(T&& t) {
        std::cout << "移动赋值" << std::endl;
        cb_ = std::move(t);
    }
};

当传入左值时，const T&版本的setCallback函数会执行拷贝操作；当传入右值时，T&&版本的函数会执行移动操作，实现了性能优化和语义正确。

如果只使用const T&版本并统一使用std::move，会对右值实参强制执行拷贝，违背移动语义；而如果只使用T&&版本并对所有参数使用std::move，可能会意外移动左值，导致数据丢失。

四、完美转发：更优雅的解决方案

在泛型编程中，我们可以使用完美转发来解决上述问题。通过std::forward函数，能够在函数模板中保留实参的左值 / 右值属性，从而实现更灵活高效的参数传递（这里的&&不再代表右值引用）。

template<typename T>
void setCallback(T&& t) {
    cb_ = std::forward<T>(t);
}

当传入左值时，std::forward返回左值引用，触发拷贝；当传入右值时，返回右值引用，触发移动，仅需一个函数即可处理所有情况，同时保留了实参的原始属性。

五、问题的回答

1.当我定义一个函数func(int c) 时，我在调用这个函数 func（3）和int a = 3; func(a)有什么区别，形参在被实参赋值时调用拷贝构造吗，如果形参不是内置变量类型而是类类型又是什么情况？

分析与回答：

右值实参（像临时对象）和左值实参（如变量）在传递给按值传递的形参时，处理机制是相同的。

这意味着无论实参是左值还是右值，都会进行一次拷贝操作。不过，对于像 int 这样的内置类型，这种拷贝操作仅仅是进行位复制，并不会调用拷贝构造函数，如果是类类型才会调用拷贝构造函数。

#include <iostream>
using namespace std;

// 内置类型参数（不会调用拷贝构造函数）
void func(int c) {
    cout << "func(int): " << c << endl;
}

// 类类型参数（会调用拷贝构造函数）
class MyClass {
public:
    int value;
    MyClass(int v) : value(v) { cout << "构造函数" << endl; }
    MyClass(const MyClass& other) : value(other.value) {
        cout << "拷贝构造函数" << endl;
    }
};

void func(MyClass c) {
    cout << "func(MyClass): " << c.value << endl;
}

int main() {
    // 情况1：内置类型参数
    func(3);        // 实参是右值
    int a = 3;
    func(a);        // 实参是左值

    // 情况2：类类型参数
    func(MyClass(4)); // 实参是右值（临时对象）
    MyClass obj(5);
    func(obj);      // 实参是左值
}


//结果
func(int): 3
func(int): 3
构造函数
拷贝构造函数
func(MyClass): 4
构造函数
拷贝构造函数
func(MyClass): 5

2.那当函数不是值传递而是左值或右值的引用传递时会调用拷贝构造吗？

分析与回答：

在 C++ 中，当函数采用引用传递时，形参直接绑定到实参，不会发生拷贝操作。但左值引用和右值引用在绑定规则上存在差异，左值引用只能绑定到左值，无法绑定到右值（除非是 const T&）；右值引用专门用于绑定右值（临时对象），不能直接绑定左值（将左值传递给右值引用参数，需要使用 std::move 将左值强制转换为右值引用）。

class MyClass {
public:
    MyClass(int v) { cout << "构造函数" << endl; }
    MyClass(const MyClass& other) { cout << "拷贝构造函数" << endl; }
};

void funcByValue(MyClass c) {  // 值传递
    // 会调用拷贝构造函数
}

void funcByRef(MyClass& c) {  // 左值引用传递
    // 不会调用拷贝构造函数
}

void funcByRRef(MyClass&& c) {  // 右值引用传递
    // 不会调用拷贝构造函数
}

int main() {
    MyClass obj(1);  // 调用构造函数
    
    funcByValue(obj);  // 调用拷贝构造函数
    funcByRef(obj);    // 不调用拷贝构造函数
    
    funcByValue(MyClass(2));  // 调用构造函数和拷贝构造函数
    funcByRRef(MyClass(3));   // 只调用构造函数（右值引用直接绑定临时对象）
}

构造函数        // MyClass obj(1)
拷贝构造函数    // funcByValue(obj)
构造函数        // MyClass(2)
拷贝构造函数    // funcByValue(MyClass(2))
构造函数        // MyClass(3)

3.当我的类有一个私有成员变量cb_接受一个可执行类型数据作为回调函数，类提供一个公有成员方法setcallback来设置这个回调函数，setcallback有两种重载分别接受const T& t和右值引用 T&& t，但是两个的实现都是直接cb_ = t ，那么这里时调用拷贝赋值还是移动赋值？

分析与回答：

先看一个实例代码：

class MyClass {
private:
    std::function<void()> cb_;  // 回调函数类型

public:
    // 左值引用重载：接受可拷贝的回调
    template<typename T>
    void setCallback(const T& t) {
        cb_ = t;  // 拷贝赋值
    }

    // 右值引用重载：接受可移动的回调
    template<typename T>
    void setCallback(T&& t) {
        cb_ = t;  // 仍为拷贝赋值！
    }
};

右值引用重载中的 t 是左值
尽管参数 T&& t 可以绑定右值，但在函数体内，t 是一个命名变量（左值）。因此 cb_ = t 会调用 std::function 的拷贝赋值运算符（operator=(const T&)），而非移动赋值运算符。
移动语义需要显式调用 std::move
若要触发移动赋值，必须将 t 转换为右值引用：cb_ = std::move(t)。

无论使用左值引用还是右值引用重载，cb_ = t 这行代码确实会导致拷贝赋值操作，而非移动赋值。

4.既然const T&可以接受右值，那我在现实时无论实参是左值还是右值，实现都用cb_ = std::move(t)不行吗，为什么好多开源代码中还要分别实现两个方法接收左值和右值？

在实现中只提供一个 const T& 参数的重载并统一使用 std::move 确实能处理所有情况，但是右值被 const 引用绑定后会失去可移动性。此时使用 std::move 会强制调用拷贝操作（因为移动构造函数通常不接受 const 参数）。

class ExpensiveResource {
public:
    ExpensiveResource() = default;
    ExpensiveResource(const ExpensiveResource&) { std::cout << "深拷贝（耗时）" << std::endl; }
    ExpensiveResource(ExpensiveResource&&) noexcept { std::cout << "移动（高效）" << std::endl; }
};

template<typename T>
void setCallback(const T& t) {
    cb_ = std::move(t);  // 对 const 对象使用 move，触发拷贝！
}

// 调用示例
setCallback(ExpensiveResource{});  // 本应移动，但实际触发深拷贝

移动语义的核心是高效转移资源所有权，而 const T& 的设计目的是安全地读取对象。混用两者会导致：