c/c++ 左值右值

🕗 发布于 2025-01-21 07:33 c语言 c++ java

左值 (Lvalue):

定义：

表达式结束后依然存在的持久对象。
有名字、有持久性的表达式，它是既能够出现在等号左边，也能出现在等号右边的变量。

右值 (Rvalue):

定义：

表达式结束后就不再存在的临时对象。
临时的、将亡的值。一般是不可寻址的常量，或在表达式求值过程中创建的无名临时对象，短暂性的。

左值和右值主要的区别之一是左值可以被修改，而右值不能。

int number;
number = 1

在这段代码中 number 为左值，1 为右值。

 // getValue()返回的临时值是右值
int value = getValue();

引用的本质是别名，可以通过引用改变变量的值，传参时传引用可以避免拷贝。

左值引用 (Lvalue Reference):

定义：引用一个对象；
基本用法：

    int number = 10;
    int& count = number;
    count++; // number = count = 11;

number 是左值，10 是右值
count 是左值引用，count 引用 number

void addCount(int& count)
{
    count++;
}

int number = 10;
addCount(number);

如果给“左值”引用直接赋“右值”，则会报错，例：

int& number = 10;
报错：
错误 C2440“初始化”: 无法从“int”转换为“int &”

const 左值引用不会修改指向值，因此可以指向右值

例如:

std::vector 中的方法 push_back

// 如果没有 const 那么使用 v.push_back(10) 这样 10 的类型是右值，就无法通过编译了
void push_back(const value_type& _Val)

// 可以直接传递字面值
v.push_back(10) 
// 可以传递表达式结果
v.push_back(x+y)

右值引用 (Rvalue Reference):

定义：就是必须绑定到右值的引用，它可以指向右值，不能指向左值。C++11中右值引用可以实现“移动语义”，通过 && 获得右值引用。

右值引用绑定右值

 int&& number = 1;

错误：右值引用不能直接绑定左值

    int count = 2;
    int&& number = count;
    报错：
    error C2440: “初始化”: 无法从“int”转换为“int &&”
    message : 无法将左值绑定到右值引用

尝试让右值引用指向左值

    int count = 2;
    // 使用 std::move 把左值强制转换为右值 ,number = 2
    int&& number1 = std::move(count);
    // 等同与 std::move 类型转换 ,number = 2
    int&& number2 = static_cast<int&&>(count);
// count = number1 = number2 = 10
number1 = 10;

简单练习：

void test(int & o) {std::cout << "左值。" << std::endl;}
void test(int && temp) {std::cout << "右值。" << std::endl;}

int main(){
    int a;
int && b = 10; 

test(a);
test(std::move(a));
test(b);
}
结果：
a 是一个具名变量，有固定的内存地址是典型的左值。输出："左值。"
std::move(a) 将左值 a 转换为右值引用 返回类型是 int&&。输出："右值"
虽然 b 的类型是右值引用（int&&）但 b 本身是一个具名变量，可以取地址。 输出:"左值"

结论：右值引用类型只是用于匹配右值，而并非表示一个右值。因此，尽量不要声明右值引用类型的变量，而只在函数形参使用它以匹配右值。

浅拷贝（Shallow Copy）：

浅拷贝只复制指向某个对象的指针，而不复制对象本身，新旧对象还是共享同一块内存（分支）。

浅拷贝是按位拷贝对象，它会创建一个新对象，这个对象有着原始对象属性值的一份精确拷贝。
如果属性是基本类型，拷贝的就是基本类型的值；如果属性是内存地址（引用类型），拷贝的就是内存地址，因此如果其中一个对象改变了这个地址，就会影响到另一个对象。

深拷贝（deep copy）：

深拷贝会另外创造一个一模一样的对象，新对象跟原对象不共享内存，修改新对象不会改到原对象，是“值”而不是“引用”（不是分支）

拷贝第一层级的对象属性或数组元素
递归拷贝所有层级的对象属性和数组元素
深拷贝会拷贝所有的属性,并拷贝属性指向的动态分配的内存。当对象和它所引用的对象一起拷贝时即发生深拷贝。深拷贝相比于浅拷贝速度较慢并且花销较大。

编写代码：


#include <iostream>

class Vector {
    int num;
    int* a;
public:
    // 构造函数
    Vector(int n = 0) : num(n) {
        a = new int[num];
        for (int i = 0; i < num; ++i) {
            a[i] = i + 1;  // 初始化为1,2,3...
        }
    }

    // 析构函数
    ~Vector() {
        delete[] a;
    }

    void ShallowCopy(Vector& v);
    void DeepCopy(Vector& v);

    // 打印数组内容的辅助函数
    void print() const {
        std::cout << "num = " << num << ", array content: ";
        for (int i = 0; i < num; ++i) {
            std::cout << a[i] << " ";
        }
        std::cout << std::endl;
    }

    // 修改数组内容的辅助函数
    void modify(int index, int value) {
        if (index >= 0 && index < num) {
            a[index] = value;
        }
    }
};

// 浅拷贝实现
void Vector::ShallowCopy(Vector& v) {
    this->num = v.num;
    this->a = v.a;
}

// 深拷贝实现
void Vector::DeepCopy(Vector& v) {
    delete[] this->a;  // 先释放原有内存
    this->num = v.num;
    this->a = new int[num];
    for (int i = 0; i < num; ++i) {
        a[i] = v.a[i];
    }
}

浅拷贝测试：


int main() {
    // 测试浅拷贝
    std::cout << "=== 测试浅拷贝 ===" << std::endl;
    {
        Vector v1(5);  // 创建一个包含5个元素的向量
        std::cout << "Original v1: ";
        v1.print();

        Vector v2(3);  // 创建另一个向量
        std::cout << "Original v2: ";
        v2.print();

        v2.ShallowCopy(v1);  // 浅拷贝
        std::cout << "After shallow copy, v2: ";
        v2.print();

        // 修改v1，观察v2是否变化
        v1.modify(0, 100);
        std::cout << "After modifying v1, v1: ";
        v1.print();
        std::cout << "After modifying v1, v2: ";
        v2.print();

        // 这里会崩溃，因为v1和v2都试图删除同一块内存
        std::cout << "Program will crash here due to double delete\n";
    }
    }
  程序输出:
  === 测试浅拷贝 ===
Original v1: num = 5, array content: 1 2 3 4 5
Original v2: num = 3, array content: 1 2 3
After shallow copy, v2: num = 5, array content: 1 2 3 4 5
After modifying v1, v1: num = 5, array content: 100 2 3 4 5
After modifying v1, v2: num = 5, array content: 100 2 3 4 5
Program will crash here due to double delete

崩溃位置:
    // 析构函数
    ~Vector() {
        delete[] a;
    }

深拷贝测试：


int main() {


    // 测试深拷贝
    std::cout << "\n=== 测试深拷贝 ===" << std::endl;
    {
        Vector v1(5);
        std::cout << "Original v1: ";
        v1.print();

        Vector v2(3);
        std::cout << "Original v2: ";
        v2.print();

        v2.DeepCopy(v1);  // 深拷贝
        std::cout << "After deep copy, v2: ";
        v2.print();

        // 修改v1，观察v2是否变化
        v1.modify(0, 100);
        std::cout << "After modifying v1, v1: ";
        v1.print();
        std::cout << "After modifying v1, v2: ";
        v2.print();

        // 这里不会崩溃，因为每个对象管理自己的内存
        std::cout << "Program will exit normally\n";
    }

    return 0;
} 

=== 测试深拷贝 ===
Original v1: num = 5, array content: 1 2 3 4 5
Original v2: num = 3, array content: 1 2 3
After deep copy, v2: num = 5, array content: 1 2 3 4 5
After modifying v1, v1: num = 5, array content: 100 2 3 4 5
After modifying v1, v2: num = 5, array content: 1 2 3 4 5
Program will exit normally

再探右值引用：

使用 C++ 11 的右值引用，重载拷贝函数，代码修改为：


class Vector {
    int num;
    int* a;
public:
    // 构造函数
    Vector(int n = 0) : num(n) {
        a = new int[num];
        for (int i = 0; i < num; ++i) {
            a[i] = i + 1;  // 初始化为1,2,3...
        }
    }

    // 析构函数
    ~Vector() {
        delete[] a;
    }
    
    //左值引用形参=>匹配左值
    void Copy(Vector& tmp) {

        if (nullptr != this->a){
            delete[] this->a;
        }
      
        this->num = tmp.num;
        this->a = tmp.a;
        
        // 防止tmp析构时删除内存
        tmp.a = nullptr;    
    }
 
   //右值引用形参=>匹配右值
    void Copy(Vector&& tmp) {
        this->num = tmp.num;
        this->a = tmp.a;
    }
};

调用测试：

int main() {
    // 测试左值引用版本
    Vector v1(5);        // v1: {1,2,3,4,5}
    Vector v2;
    v2.Copy(v1);        // 深拷贝：v2获得自己的内存副本

    // 测试右值引用版本
    Vector v3;
    v3.Copy(Vector(3)); // 移动：直接窃取临时对象的资源

    return 0;
}

原文地址：https://blog.csdn.net/Tiantangbujimo7/article/details/145222509

免责声明：本站文章内容转载自网络资源，如侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：OpenAI进军实体机器人：GPT赋能的智能未来
下一篇：数据库Block Nested Loop Join的原理及C++和Boost库实现

if_yellow_only_restart_upgrading_nodes_with_unassigned_replicas
要将CR 状态从或yellow状态转为“启动”状态，首先需要解决副本分片未分配的问题，检查并确保集群资源充足，查看并修复升级过程中出现的节点重启问题。如果有必要，可以修改升级策略或暂时调整集群配置，手
阅读更多2025-01-23
Facebook广告零支出无消耗：可能原因与解决方法
Facebook广告预算消耗异常涉及多方面因素，及时排查，辅以可靠的网络工具，往往能有效解决问题。
阅读更多2025-01-23
CSS align-items 属性
属性为弹性容器内的项目指定默认对齐方式。提示：请使用每个项目的align-self属性来覆盖这个 align-items 属性。
阅读更多2025-01-23
【Agent】AI Agents的安全性综述
大语言模型的出现推动了AI Agents的研究和发展。AI Agents可以充当智能助理，通过访问工具并在其环境中执行命令来代表用户完成任务。通过对典型AI Agents工作流程的研究和体验，我们提出
阅读更多2025-01-23
Python保留字与标识符及常变量
保留字；严格区分大小写不可以把保留字作为变量、函数、类、模块和其他对象的名称来使用。
阅读更多2025-01-23
论文阅读--Qwen2&2.5技术报告
后训练数据主要由两部分组成：对齐数据 D = { ( x i , y i ) } 和偏好数据 P = { ( x i , y i + , y i − ) } ，其中 x i 代表指令，y i代表满意的
阅读更多2025-01-23
SpringBoot项目集成MinIO
最近在学习MinIO，所以想让自己的SpringBoot项目集成MinIO,在网上查阅资料，并进行操作的过程中遇到一些问题，所以想把自己遇到的坑和完成步骤记录下来供自己和各位查阅。
阅读更多2025-01-23
使用ListLayoutElements()函数限制返回的布局元素
布局视图中包含大量制图元素,但是对于特定的地理处理脚本而言,很多元素都是多余的.通过ListLayoutElements()函数限制返回的布局元素.5.使用ListLayoutElements()函数
阅读更多2025-01-23
【深度学习】关键技术-模型训练（Model Training）
模型训练是机器学习和深度学习中调整模型参数以优化性能的过程，通常包括以下步骤：数据准备：加载数据、预处理、分割训练集和测试集。模型定义：选择合适的算法或网络架构。损失函数与优化器：定义训练目标（损失函
阅读更多2025-01-23
Nodejs中fs文件系统模块（一）
fs模块作为Node.js的核心组件，提供了一套全面的文件系统操作API，涵盖文件读写、目录管理等关键功能。借助fs模块，开发者无需依赖外部库即可执行文件操作及流处理。该模块API分为同步与异步两种模
阅读更多2025-01-23