C++11（上）：重塑 C++ 的现代革命

Cx330❀2025-11-20 8:17

🔥个人主页：Cx330🌸

❄️个人专栏：《C语言》《LeetCode刷题集》《数据结构-初阶》《C++知识分享》

《优选算法指南-必刷经典100题》《Linux操作系统》:从入门到入魔

🌟心向往之行必能至

🎥Cx330🌸的简介：

目录

前言：

一、C++11的发展史

[为什么 C++11 如此重要？](#为什么 C++11 如此重要？)

二、列表初始化

[2.1 C++98的传统{}](#2.1 C++98的传统{})

最佳实践：

[2.2 C++11 中的 {}](#2.2 C++11 中的 {})

最佳实践：

[2.3 C++11中的std::initializer_list](#2.3 C++11中的std::initializer_list)

最佳实践：

三、右值引用和移动语义

[3.1 左值和右值](#3.1 左值和右值)

最佳实践：

[3.2 左值引用和右值引用](#3.2 左值引用和右值引用)

最佳实践：

左值引用给左值取别名：

右值引用给右值取别名：

const左值引用引用右值：

右值引用引用move(左值)：

[3.3 引用延长生命周周期](#3.3 引用延长生命周周期)

最佳实践：

​编辑左值引用延长生命周期：

右值引用延长生命周期：

[3.4 左值和右值的参数匹配](#3.4 左值和右值的参数匹配)

[3.5 右值引用和移动语义的使用场景](#3.5 右值引用和移动语义的使用场景)

[3.5.1 左值引用主要使用场景回顾](#3.5.1 左值引用主要使用场景回顾)

[3.5.2 移动构造和移动赋值](#3.5.2 移动构造和移动赋值)

[3.5.3 右值引用和移动语义解决传值返回问题](#3.5.3 右值引用和移动语义解决传值返回问题)

[3.5.4 右值引用和移动语义在传参中的提效](#3.5.4 右值引用和移动语义在传参中的提效)

前言：

如果你是一名 C++ 开发者，无论资历深浅，都绕不开一个里程碑式的版本 ------C++11 。在 C++ 的发展史上，它不是简单的版本迭代，而是一次 "脱胎换骨 " 的升级：从语法到标准库，从性能到安全性，C++11 引入的特性彻底改变了 C++ 的编写方式，让这门古老的语言焕发出现代编程语言的简洁与高效

一、C++11的发展史

C++11 是 C++ 的第二个主要版本，并且是从 C++98 起的最重要更新。它引入了大量更改，标准化了既有实践，并改进了对 C++ 程序员可用的抽象。在它最终由 ISO 在 2011 年 8 月 12 日采纳前，人们曾使用名称 "C++0x"，因为它曾被期待在 2010 年之前发布。C++03 与 C++11 期间花了 8 年时间，故而这是迄今为止最长的版本间隔。从那时起，C++ 有规律地每 3 年更新一次

**注：**其中C++98、C++11、C++17、C++20是较大版本，优化与改动也是挺多的，大家也能发现，这几个版本的字体也是最大的

为什么 C++11 如此重要？

在 C++11 之前，C++ 的语法相对繁琐，标准库功能有限，甚至被调侃为 "带着 C 的枷锁跳舞"。2011 年发布的 C++11（曾用名 C++0x，因延期多次而得名）解决了大量历史遗留问题，同时引入了对现代编程范式（如泛型、并发、函数式编程）的支持。它的目标很明确：让代码更简洁、更安全、更高效

二、列表初始化

2.1 C++98的传统{}

C++98中一般数组和结构体可以用{}进行初始化

最佳实践：
cpp 复制代码 
struct Point
{
    int _x;
    int _y;
};
int main()
{
    int array1[] = { 1, 2, 3, 4, 5 };
    int array2[5] = { 0 };
    Point p = { 1, 2 };
    cout << p._x << " " << p._y << endl;

    return 0;
}

调试结果：

2.2 C++11 中的 {}

  • C++11 以后想统一初始化方式，试图实现一切对象皆可用{}初始化，{}初始化也叫做列表初始化。
  • 内置类型支持，自定义类型也支持，自定义类型本质是类型转换，中间会产生临时对象，最后优化了以后变成直接构造。
  • {}初始化的过程中，可以省略掉=
  • C++11 列表初始化的本意是想实现一个大统一的初始化方式，其次它在有些场景下带来的不少便利，如容器push/insert多参数构造的对象时，{}初始化会很方便
最佳实践：
cpp 复制代码 
class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
	{
		cout << "Date(int year, int month, int day)" << endl;
	}
	Date(const Date& d)
		:_year(d._year)
		, _month(d._month)
		, _day(d._day)
	{
		cout << "Date(const Date& d)" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

void Insert(const Date& d)
{

}

Date func()
{
	/*Date d{ 2025,11,16 };
	return d;*/

	//return { 2025,11,16 };

	//返回默认构造
	Date d;
	return d;

	//return {};
}

int main()
{
	int array1[] = { 1, 2, 3, 4, 5 };
	int array2[5] = { 0 };

	//自定义类型
	Point p = { 1, 2 };
	cout << p._x << " " << p._y << endl;

	Date d2 = 1025;//单参数的隐式类型转换
	Date d2 = { 2025,11,17 };
	Date d3{ 2025,11,17 };
	Date d4{};//调用默认构造，用缺省值
	Date d5;  //也是调用默认构造，用缺省值

	Insert(2025);
	Insert({ 2025,11,17 });
	
	//内置类型
	int i = 0;
	int j = { 1 };
	int k{ 2 };
	int m{};


	// C++11⽀持的
	// 内置类型⽀持
	int x1 = { 2 };
	// ⾃定义类型⽀持
	// 这⾥本质是⽤{ 2025, 1, 1}构造⼀个Date临时对象
	// 临时对象再去拷⻉构造d1，编译器优化后合⼆为⼀变成{ 2025, 1, 1}直接构造初始化d1
	// 运⾏⼀下，我们可以验证上⾯的理论，发现是没调⽤拷⻉构造的
	Date d1 = { 2025, 1, 1 };

	// 这⾥d2引⽤的是{ 2024, 7, 25 }构造的临时对象
	const Date& d2 = { 2024, 7, 25 };

	// 需要注意的是C++98⽀持单参数时类型转换，也可以不⽤{}
	Date d3 = { 2025 };
	Date d4 = 2025;

	// 可以省略掉=
	Point p1{ 1, 2 };
	int x2{ 2 };
	Date d6{ 2024, 7, 25 };
	const Date& d7{ 2024, 7, 25 };

	// 不⽀持，只有{}初始化，才能省略=
	// Date d8 2025;

	vector<Date> v;
	v.push_back(d1);
	v.push_back(Date(2025, 1, 1));

	// ⽐起有名对象和匿名对象传参，这⾥{}更有性价⽐
	v.push_back({ 2025, 1, 1 });

	return 0;
}

我们可以从图中看到，内置类型同样也可以用{ }初始化，但是我们看习惯了直接赋值，那么这里还要用{ }初始化的意义是什么呢？

C++就是要让一切皆可用{}初始化

2.3 C++11中的std::initializer_list

上面的初始化已经很方便，但是对象容器初始化还是不太方便，比如一个 vector 对象，我想用 N 个值去构造初始化，那么我们得实现很多个构造函数才能支持，vector<int> v1 = {1,2,3};vector<int> v2 = {1,2,3,4,5};

**文档：initializer_list****std::initializer_list**支持迭代器遍历

  • C++11 库中提出了一个std::initializer_list的类，auto il = { 10, 20, 30 }; // the type of il is an initializer_list，这个类的本质是底层开一个数组，将数据拷贝过来，std::initializer_list内部有两个指针分别指向数组的开始和结束
  • 容器支持一个std::initializer_list的构造函数，也就支持任意多个值构成的 {x1,x2,x3...} 进行初始化。STL 中的容器支持任意多个值构成的 {x1,x2,x3...} 进行初始化，就是通过std::initializer_list的构造函数支持的
最佳实践：
cpp 复制代码 
int main()
{
	vector<int> v1 = { 1,2,3,4,5,6 };
	vector<int> v2{ 7,8,9 };

	//vector(initializer_list<T> l) vector传给initializer_list<T>
	//{
	//	for (auto e : l)
	//		push_back(e)
	//}

	map<string, string>dict = { {"sort","排序"},{"string","字符串"} };

	v1 = { 10,20,30 };

	auto il = { 10,20,30 };
	cout << typeid(il).name() << endl;

	std::initializer_list<int> mylist;
	mylist = { 10, 20, 30 };
	cout << sizeof(mylist) << endl;

	// 这⾥begin和end返回的值initializer_list对象中存的两个指针
	// 这两个指针的值跟i的地址跟接近，说明数组存在栈上
	int i = 0;
	cout << mylist.begin() << endl;
	cout << mylist.end() << endl;
	cout << &i << endl;

	return 0;
}

这里我们使用vector容器来被std::initializer_list进行接受，其本质就是vector传给initializer_list，这里我们可以使用typeid().name()来打印一下它的本质，这⾥begin和end返回的值initializer_list对象中存的两个指针这两个指针的值跟i的地址跟接近，说明数组存在栈上

三、右值引用和移动语义

C++98 的 C++ 语法中就有引用的语法，而 C++11 中新增了的右值引用语法特性，C++11 之后我们之前学习的引用就叫做左值引用。无论左值引用还是右值引用，都是给对象取别名

3.1 左值和右值

  • 左值是一个表示数据的表达式 (如变量名或解引用的指针)，一般是有持久状态，存储在内存中，我们可以获取它的地址，左值可以出现在赋值符号的左边，也可以出现在赋值符号右边。定义时 const 修饰符后的左值，不能给他赋值，但是可以取它的地址。
  • 右值也是一个表示数据的表达式，要么是字面值常量、要么是表达式求值过程中创建的临时对象等，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能取地址。
  • 值得一提的是，左值的英文简写为 lvalue，右值的英文简写为 rvalue。传统认为它们分别是 left value、right value 的缩写。现代 C++ 中，lvalue 被解释为 loactor value 的缩写，可意为存储在内存中、有明确存储地址可以取地址的对象，而 rvalue 被解释为 read value，指的是那些可以提供数据值，但是不可以寻址，例如：临时变量，字面量常量，存储于寄存器中的变量等，也就是说左值和右值的核心区别就是能否取地址

这里大家可能对左值右值还不太理解，这里给大家举个例子：

cpp 复制代码 
//左值
int a=1;
char b=c;
int *p=&a;

//右值
10;
"11111"
最佳实践：
cpp 复制代码 
int main()
{
	// 左值：可以取地址
	// 以下的p、b、c、*p、s、s[0]就是常⻅的左值
	int* p = new int(0);
	int b = 1;
	const int c = b;
	*p = 10;
	string s("111111");
	s[0] = 'x';

	cout << &p << endl;
	cout << &b << endl;
	cout << &c << endl;
	cout << &(*p) << endl;
	cout << &s << endl;
	cout << (void*) & s[0] << endl;

	// 右值：不能取地址
	double x = 1.1, y = 2.2;
	// 以下⼏个10、x + y、fmin(x, y)、string("11111")都是常⻅的右值
	10;
	x + y;
	fmin(x, y);
	string("11111");

	//编译报错
	//cout << &10 << endl;
	//cout << &(x+y) << endl;
	//cout << &(fmin(x, y)) << endl;
	//cout << &string("11111") << endl;


	return 0;
}

我们对左值取地址看看结果：

我们对右值取地址看看结果：

我们可以看到编译错误：&要求左值（不可对右值取地址）

3.2 左值引用和右值引用

  • Type& r1 = x; Type&& rr1 = y; 第一个语句是左值引用，左值引用是给左值取别名；第二个是右值引用，右值引用是给右值取别名。
  • 左值引用不能直接引用右值，但 const 左值引用可以引用右值。
  • 右值引用不能直接引用左值，但右值引用可以引用 move(左值)。
  • template <class T> typename remove_reference<T>::type&& move (T&& arg);
  • move 是库中的一个函数模板，本质内部是进行强制类型转换，还涉及引用折叠知识（后续细讲）。
  • 变量表达式都是左值属性，一个右值被右值引用绑定后，右值引用变量的表达式属性是左值。
  • 语法层面，左值引用和右值引用都是取别名，不开空间；汇编底层都是用指针实现，二者无区别。底层实现和上层语法意义有时背离，不要混为一谈、互相佐证，否则易陷入迷途
最佳实践：
左值引用给左值取别名：
cpp 复制代码 
int main()
{
	// 左值：可以取地址
	// 以下的p、b、c、*p、s、s[0]就是常⻅的左值
	int* p = new int(0);
	int b = 1;
	const int c = b;
	*p = 10;
	string s("111111");
	s[0] = 'x';
	double x = 1.1, y = 2.2;

	// 左值引⽤给左值取别名
	int& r1 = b;
	int*& r2 = p;
	int& r3 = *p;
	string& r4 = s;
	char& r5 = s[0];

	return 0;
}
右值引用给右值取别名：
cpp 复制代码 
int main()
{
	// 左值：可以取地址
	// 以下的p、b、c、*p、s、s[0]就是常⻅的左值
	int* p = new int(0);
	int b = 1;
	const int c = b;
	*p = 10;
	string s("111111");
	s[0] = 'x';
	double x = 1.1, y = 2.2;

	// 右值引⽤给右值取别名
	int&& rr1 = 10;
	double&& rr2 = x + y;
	double&& rr3 = fmin(x, y);
	string&& rr4 = string("11111");

	return 0;
}
const左值引用引用右值：
cpp 复制代码 
int main()
{
	// 左值：可以取地址
	// 以下的p、b、c、*p、s、s[0]就是常⻅的左值
	int* p = new int(0);
	int b = 1;
	const int c = b;
	*p = 10;
	string s("111111");
	s[0] = 'x';
	double x = 1.1, y = 2.2;

	// 左值引⽤不能直接引⽤右值，但是const左值引⽤可以引⽤右值
	//int& rx1 = 10;
	const int& rx1 = 10;
	const double& rx2 = x + y;
	const double& rx3 = fmin(x, y);
	const string& rx4 = string("11111");

	return 0;
}
右值引用引用move(左值)：
cpp 复制代码 
int main()
{
	// 左值：可以取地址
	// 以下的p、b、c、*p、s、s[0]就是常⻅的左值
	int* p = new int(0);
	int b = 1;
	const int c = b;
	*p = 10;
	string s("111111");
	s[0] = 'x';
	double x = 1.1, y = 2.2;

	// 右值引⽤不能直接引⽤左值，但是右值引⽤可以引⽤move(左值)
	//int&& rrx1 = b;
	int&& rrx1 = move(b);
	int*&& rrx2 = move(p);
	int&& rrx3 = move(*p);
	string&& rrx4 = move(s);
	string&& rrx5 = (string&&)s;

	return 0;
}

右值引用的自身属性是左值！！！（后续给大家结合例子细讲）

3.3 引用延长生命周周期

右值引用可用于为临时对象延长生命周期，const 的左值引用也能延长临时对象生存期，但这些对象无法被修改

最佳实践：
cpp 复制代码 
class A
{
public:
	A()
	{
		cout << "A()" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
};

int main()
{
	A aa1;

	A();

	//左值引用延长生命周期
	//const A& ref1 = A();

	//右值引用延长生命周期
	//A&& ref2 = A();

	cout << "main end" << endl;

	return 0;
}
左值引用延长生命周期：

注：先构造的后析构，后构造的先析构！！！（构造函数与析构函数中详细讲解）

右值引用延长生命周期：

注：先构造的后析构，后构造的先析构！！！（构造函数与析构函数中详细讲解）

3.4 左值和右值的参数匹配

  • C++98 中，实现一个const左值引用作为参数的函数，实参传递左值和右值都可以匹配。
  • C++11 以后，分别重载左值引用、const左值引用、右值引用作为形参的f函数时，实参是左值会匹配f(左值引用)，实参是const左值会匹配f(const 左值引用)，实参是右值会匹配f(右值引用)。
  • 右值引用变量在用于表达式时属性是左值，这个设计此处会感觉怪异，下一小节讲解右值引用的使用场景时，就能体会这样设计的价值

我们先来实现一个const左值引用作为参数的函数，看看是否可以使实参传递左值和右值都可以匹配

cpp 复制代码 
void f(const int& x)
{
	std::cout << "到 const 的左值引用重载 f(" << x << ")\n";
}


int main()
{
	f(10);

	int a = 20;
	f(a);

	const int b = 30;
	f(b);

	//右值引用本身的属性是左值
	int&& x = 1;
	f(x);		// 调⽤ f(int& x)
	f(move(x)); // 调⽤ f(int&& x)

	return 0;
}

我们再来实现一下左值引用重载与右值引用重载

cpp 复制代码 
void f(int& x)
{
	std::cout << "左值引用重载 f(" << x << ")\n";
}

void f(const int& x)
{
	std::cout << "到 const 的左值引用重载 f(" << x << ")\n";
}

void f(int&& x)
{
	std::cout << "右值引用重载 f(" << x << ")\n";
}

int main()
{
	f(10);

	int a = 20;
	f(a);

	const int b = 30;
	f(b);

	//右值引用本身的属性是左值
	int&& x = 1;
	f(x);		// 调⽤ f(int& x)
	f(move(x)); // 调⽤ f(int&& x)

	return 0;
}

图解：

这里我们可以清楚的看到：明明是右值引用，为什么会调用到左值引用重载的函数上呢？

**这就是前面跟大家提到的：**右值引用的自身属性是左值！！！

3.5 右值引用和移动语义的使用场景

3.5.1 左值引用主要使用场景回顾

左值引用主要使用场景是在函数中左值引用传参和左值引用传返回值时减少拷贝，同时还可以修改实参和修改返回对象的价值。左值引用已经解决大多数场景的拷贝效率问题，但是有些场景不能使用传左值引用返回，如addStrings和generate函数，C++98 中的解决方案只能是被迫使用输出型参数解决。那么 C++11 以后这里可以使用右值引用做返回值解决吗？显然是不可能的，因为这里的本质是返回对象是一个局部对象，函数结束这个对象就析构销毁了，右值引用返回也无法概念对象已经析构销毁的事实

3.5.2 移动构造和移动赋值
  • 移动构造函数是一种构造函数，类似拷贝构造函数，移动构造函数要求第一个参数是该类类型的引用，但不同的是要求这个参数是右值引用；如果还有其他参数，额外的参数必须有缺省值。
  • 移动赋值是一个赋值运算符的重载，与拷贝赋值构成函数重载，类似拷贝赋值函数；移动赋值函数要求第一个参数是该类类型的引用，但不同的是要求这个参数是右值引用。
  • 对于像string/vector这样的深拷贝的类或者包含深拷贝的成员变量的类，移动构造和移动赋值才有意义。因为移动构造和移动赋值的第一个参数都是右值引用的类型，其本质是要 "窃取" 引用的右值对象的资源，而非像拷贝构造和拷贝赋值那样去拷贝资源，以此提高效率。下面的bit::string样例实现了移动构造和移动赋值，需结合场景理解
3.5.3 右值引用和移动语义解决传值返回问题
cpp 复制代码 
class Solution {
public:
	// 传值返回需要拷⻉
	string addStrings(string num1, string num2) {
		string str;
		int end1 = num1.size() - 1, end2 = num2.size() - 1;
		// 进位
		int next = 0;
		while (end1 >= 0 || end2 >= 0)
		{
			int val1 = end1 >= 0 ? num1[end1--] - '0' : 0;
			int val2 = end2 >= 0 ? num2[end2--] - '0' : 0;
			int ret = val1 + val2 + next;
			next = ret / 10;
			ret = ret % 10;
			str += ('0' + ret);
		}
		if (next == 1)
			str += '1';
		reverse(str.begin(), str.end());
		return str;
	}
};

右值对象构造，只有拷贝构造，没有移动构造的场景

  • 图 1 展示了 vs2019 debug 环境下编译器对拷贝的优化，左边为不优化的情况下，两次拷贝构造，右边为编译器优化的场景下连续步骤中的拷贝合二为一变为一次拷贝构造。
  • 需要注意的是在 vs2019 的 release 和 vs2022 的 debug 和 release，下面代码优化为非常恐怖，会直接将 str 对象的构造，str 拷贝构造临时对象，临时对象拷贝构造 ret 对象，合三为一，变为直接构造。要理解这个优化要结合局部对象生命周期和栈帧的角度理解，如图 3 所示。
  • linux 下可以将下面代码拷贝到 test.cpp 文件，编译时用 g++ test.cpp -fno-elide-constructors 的方式关闭构造优化，运行结果可以看到图 1 左边没有优化的两次拷贝

右值对象构造，有拷贝构造，也有移动构造的场景

  • 图 2 展示了 vs2019 debug 环境下编译器对拷贝的优化，左边为不优化的情况下，两次移动构造，右边为编译器优化的场景下连续步骤中的拷贝合二为一变为一次移动构造。
  • 需要注意的是在 vs2019 的 release 和 vs2022 的 debug 和 release，下面代码优化为非常恐怖，会直接将 str 对象的构造，str 拷贝构造临时对象，临时对象拷贝构造 ret 对象，合三为一，变为直接构造。要理解这个优化要结合局部对象生命周期和栈帧的角度理解，如图 3 所示。
  • linux 下可以将下面代码拷贝到 test.cpp 文件，编译时用 g++ test.cpp -fno-elide-constructors 的方式关闭构造优化，运行结果可以看到图 1 左边没有优化的两次移动

右值对象赋值，只有拷贝构造和拷贝赋值，没有移动构造和移动赋值的场景

  • 图 4 左边展示了 vs2019 debug 和 g++ test.cpp -fno-elide-constructors 关闭优化环境下编译器的处理，一次拷贝构造，一次拷贝赋值。
  • 需要注意的是在 vs2019 的 release 和 vs2022 的 debug 和 release，下面代码会进一步优化，直接构造要返回的临时对象，str 本质是临时对象的引用，底层角度用指针实现。运行结果的角度，我们可以看到 str 的析构是在赋值以后，说明 str 就是临时对象的别名

右值对象赋值，既有拷贝构造和拷贝赋值，也有移动构造和移动赋值的场景

  • 图 5 左边展示了 vs2019 debug 和 g++ test.cpp -fno-elide-constructors 关闭优化环境下编译器的处理，一次移动构造，一次移动赋值。
  • 需要注意的是在 vs2019 的 release 和 vs2022 的 debug 和 release，下面代码会进一步优化，直接构造要返回的临时对象，str 本质是临时对象的引用，底层角度用指针实现。运行结果的角度，我们可以看到 str 的析构是在赋值以后，说明 str 就是临时对象的别名
3.5.4 右值引用和移动语义在传参中的提效
  • 查看 STL 文档我们发现 C++11 以后容器的push和insert系列的接口都增加了右值引用版本
  • 当实参是一个左值时，容器内部继续调用拷贝构造进行拷贝，将对象拷贝到容器空间中的对象
  • 当实参是一个右值，容器内部则调用移动构造，将右值对象的资源转移到容器空间的对象上
  • 把我们之前模拟实现的bit::list拷贝过来，支持右值引用参数版本的push_back和insert
  • 其实这里还有一个emplace系列的接口，但是这个涉及可变参数模板，我们需要把可变参数模板讲解以后再讲解emplace系列的接口
相关推荐
xlq223226 小时前
15.list（上）
数据结构·c++·list
云帆小二6 小时前
从开发语言出发如何选择学习考试系统
开发语言·学习
光泽雨6 小时前
python学习基础
开发语言·数据库·python
Elias不吃糖6 小时前
总结我的小项目里现在用到的Redis
c++·redis·学习
AA陈超7 小时前
使用UnrealEngine引擎，实现鼠标点击移动
c++·笔记·学习·ue5·虚幻引擎
百***06017 小时前
python爬虫——爬取全年天气数据并做可视化分析
开发语言·爬虫·python
jghhh017 小时前
基于幅度的和差测角程序
开发语言·matlab
fruge7 小时前
自制浏览器插件：实现网页内容高亮、自动整理收藏夹功能
开发语言·前端·javascript
No0d1es7 小时前
电子学会青少年软件编程（C/C++）六级等级考试真题试卷（2025年9月）
c语言·c++·算法·青少年编程·图形化编程·六级
曹牧7 小时前
Java中处理URL转义并下载PDF文件
java·开发语言·pdf
热门推荐
01GitHub 镜像站点02今天 Cloudflare 全球事故，连 GPT 和你的网站都一起“掉线”了03UV安装并设置国内源04BongoCat - 跨平台键盘猫动画工具05安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）06Linux下V2Ray安装配置指南07全球最强模型Grok4，国内已可免费使用！（附教程）08Google Antigravity：无法登录？早期错误、登录修复和用户反馈指南09Valdi：Snapchat 开源的新一代跨平台 UI 框架10Labelme从安装到标注：零基础完整指南