C++ Cherno 左值，右值，移动语义，std::move

Day 30 (2024.4.7)

现在很多人称左值是有地址的值（located value），但Cherno认为你只需要知道左值和右值是什么，不要试图定义它。

左值右值最简单的定义：左值大多数时候在等号左边，右值在右边。

int GetValue()
{
    return 10;
}

int& GetLValue()
{
    static int value = 10;
    return value;
}

void SetValue(int value)
{

}

int main()
{
    int i = 10;           //左值大多数时候在等号左边，右值在右边
    int a = i;            //这个例子就不适用了，左右两边都是左值
    int j = GetValue()    //右值不只是像这样的字面量，它也可以是函数的结果
                          //这个函数返回一个int，它没有位置，没有存储空间，只是返回10
                          //我们现在只是取这个右值（临时值），然后把它存储到左值中

    GetLValue() = 5;      //返回的是一个左值引用，可以对它赋值

    SetValue(i);
    SetValue(10);         //在这种情况下，当函数被调用时，这个右值会被用来创建一个左值
}

另一个规则是：你不能将右值赋给左值引用。

void SetValue(int& value)
{

}

int main()
{
    int i = 10;
    SetValue(i);
    SetValue(10);      //报错，非const引用的初始值必须是左值
                       //实际上这有一个特殊规则，const int& value是可以接受右值
                       //这种情况编译器可能会先创建一个临时变量，然后赋给引用
                       //const int& value = 10
                       //和以下等价
                       //int temp = 10;
                       //const int& a = temp;
}

再看另一个例子：

void PrintName(std::string& name) {
    std::cout << name << std::endl;
}

int main()
{
    std::string firstName = "Yan";
    std::string lastName = "Chernikov";
    std::string fullName = firstName + lastName;
 
    PrintName(fullName);
    PrintName(firstName + lastName);   //报错，firstName + lastName为右值
                                       //所以你会看到为什么很多c++写的是常量引用
                                       //因为它们兼容临时右值和实际存在的左值变量
                                       //void PrintName(const std::string& name)
}
 

通过以上例子，我们很明显的知道可以写一个非常量的左值引用来判断是否为左值。我们有没有办法写一个东西接收右值呢？

void PrintName(std::string&& name) {
    std::cout << name << std::endl;
}

int main()
{
    std::string firstName = "Yan";
    std::string lastName = "Chernikov";
    std::string fullName = firstName + lastName;
     
    PrintName(fullName);               //报错，一个右值引用不能绑定到左值
    PrintName(firstName + lastName);   //正确
                                       
}
 

因为有了右值引用，我们现在有了一种方法来检测临时值，并对它们做一些特殊的事情。主要的事情是什么呢，是优化！如果我们知道传入的是临时对象，那我们就不需要担心它们是否活着，是否完整，是否拷贝。我们可以简单地偷它的资源，给到特定的对象或者其他地方使用它们。

而如果使用的是void PrintName(std::string& name) ，你要慎重考虑从name中窃取任何东西，因为它可能会在很多函数中使用。

Day 31 (2024.4.8)

下面情况会调用构造函数和拷贝构造函数各一次，而实际上我们并不需要拷贝构造函数被调用，它影响了性能（分配了两次内存）。

#include <iostream>

class String
{
public:
	String() = default;
	String(const char* string)
	{
		printf("Created!\n");
		m_Size = strlen(string);
		m_Data = new char[m_Size];
		memcpy(m_Data, string, m_Size);
	}

	String(const String& other)
	{
		printf("Copied!!\n");
		m_Size = other.m_Size;
		m_Data = new char[m_Size];
		memcpy(m_Data, other.m_Data, m_Size);
	}

	void Print()
	{
		for (uint32_t i = 0; i < m_Size; i++)
			printf("%c", m_Data[i]);
		printf("\n");
	}

	~String()
	{
		printf("Destroyed!\n");
		delete m_Data;
	}

private:
	char* m_Data;
	uint32_t m_Size;
};

class Entity
{
public:
	Entity(const String& name) : m_Name(name)
	{

	}

	void PrintName()
	{
		m_Name.Print();
	}

private:
	String m_Name;
};

int main()
{
	Entity entity("Cherno");
	entity.PrintName();
	std::cin.get();

	return 0;
}

这种情况，我们可以创建移动构造函数（移动构造函数不会重新分配内存）。

// 写一个移动构造函数，它和复制构造函数很相似，除了接收的是一个右值

#include <iostream>

class String
{
public:
	String() = default;
	String(const char* string)
	{
		printf("Created!\n");
		m_Size = strlen(string);
		m_Data = new char[m_Size];
		memcpy(m_Data, string, m_Size);
	}

	String(const String& other)
	{
		printf("Copied!!\n");
		m_Size = other.m_Size;
		m_Data = new char[m_Size];
		memcpy(m_Data, other.m_Data, m_Size);
	}

	String(String&& other) noexcept
	{
		printf("Moved!!\n");
		m_Size = other.m_Size;
		m_Data = other.m_Data;
		
		other.m_Size = 0;
		other.m_Data = nullptr;
	}

	void Print()
	{
		for (uint32_t i = 0; i < m_Size; i++)
			printf("%c", m_Data[i]);
		printf("\n");
	}

	~String()
	{
		printf("Destroyed!\n");
		delete m_Data;
	}

private:
	char* m_Data;
	uint32_t m_Size;
};

class Entity
{
public:
	Entity(const String& name) : m_Name(name)
	{

	}

	Entity(String&& name) : m_Name(std::move(name))
	{

	}

	void PrintName()
	{
		m_Name.Print();
	}

private:
	String m_Name;
};

int main()
{
	Entity entity("Cherno");
	entity.PrintName();
	std::cin.get();

	return 0;
}

Day 32 (2024.4.9)

// 移动构造函数接受临时变量作为参数

String string = "Hello";
String dest((String&&)string);

String dest(std::move(string));

#include <iostream>

class String
{
public:
	String() = default;
	String(const char* string)
	{
		printf("Created!\n");
		m_Size = strlen(string);
		m_Data = new char[m_Size];
		memcpy(m_Data, string, m_Size);
	}

	String(const String& other)
	{
		printf("Copied!!\n");
		m_Size = other.m_Size;
		m_Data = new char[m_Size];
		memcpy(m_Data, other.m_Data, m_Size);
	}

	// 移动构造函数
	String(String&& other) noexcept
	{
		printf("Moved Constructed!!\n");
		m_Size = other.m_Size;
		m_Data = other.m_Data;
		
		other.m_Size = 0;
		other.m_Data = nullptr;
	}

	// 移动赋值运算符
	String& operator=(String&& other) noexcept
	{
		printf("Moved Operations!\n");

		if (this != &other)
		{
			delete[] m_Data;

			m_Size = other.m_Size;
			m_Data = other.m_Data;

			other.m_Size = 0;
			other.m_Data = nullptr;
		}

		return *this;
	}

	void Print()
	{
		for (uint32_t i = 0; i < m_Size; i++)
			printf("%c", m_Data[i]);
		printf("\n");
	}

	~String()
	{
		printf("Destroyed!\n");
		delete m_Data;
	}

private:
	char* m_Data;
	uint32_t m_Size;
};


int main()
{
	String apple = "Apple";
	// 使用移动构造函数
	String dest = std::move(apple);

	String banana = "Banana";
	String home;
	// 使用移动赋值运算符
	home = std::move(banana);

	std::cin.get();

	return 0;
}