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;
}