【C++】C++11 新特性详解（下）

原创 已于 2025-10-11 12:26:32 修改 · 1.1k 阅读 · 32 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #C++11 #lambda #stl

于 2025-10-11 12:15:16 首次发布

文章目录

上文链接

一、类的新功能

1. 默认的移动构造和移动赋值

C++11 之前的类中，有 6 个默认成员函数：构造函数、析构函数、拷贝构造函数、拷贝赋值重载、取地址重载和 const 取地址重载，最重要的是前 4 个，后两个用处不大，默认成员函数就是我们自己不显式写编译器会生成一个默认的。C++11 新增了两个默认成员函数：移动构造函数和移动赋值运算符重载。

如果自己没有实现移动构造函数，且析构函数、拷贝构造、拷贝赋值重载、移动赋值重载也都没有实现，那么编译器会自动生成一个默认的移动构造。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝。对于自定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调用移动构造，没有实现就调用拷贝构造。

如果自己没有实现移动赋值重载函数，且析构函数、拷贝构造、拷贝赋值重载、移动构造也都没有实现，那么编译器会自动生成一个默认移动赋值。默认生成的移动赋值函数，对于内置类型成员会执行逐成员按字节拷贝。对于自定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调用移动构造，没有实现就调用拷贝构造。(默认移动赋值跟上面移动构造完全类似)

反之编译器则不会自动提供移动构造和移动赋值。

2. default 和 delete

C++11 可以让你更好的控制要使用的默认函数。假设你要使用某个默认的函数，但是因为一些原因这个函数没有默认生成。比如：我们提供了拷贝构造，就不会生成移动构造了，那么我们可以使用 default 关键字显式指定移动构造生成。

如果能想要限制某些默认函数的生成，在 C++98 中，可以只生明该函数且设置成 private，这样只要其他人想要调用就会报错。而在 C++11 中更简单，只需在该函数声明加上 = delete即可，该语法指示编译器不生成对应函数的默认版本，称 = delete 修饰的函数为删除函数。

请添加图片描述

二、lambda

1. lambda 表达式语法

lambda 表达式本质是一个匿名函数对象，跟普通函数不同的是它可以定义在函数内部。

lambda 表达式语法使用层而言没有类型，所以我们一般是用 auto 或者模板参数定义的对象去接收 lambda 对象。

lambda 表达式的格式如下：

[capture-list] (parameters)-> return type {  function boby; };

[capture-list]：捕捉列表，该列表总是出现在 lambda 函数的开始位置，编译器根据 [] 来判断接下来的代码是否为 lambda 函数，捕捉列表能够捕捉上下文中的变量供 lambda 函数使用，捕捉列表可以传值捕捉和传引用捕捉，下面的演示中暂时将捕捉列表设置为空，关于它的详细介绍会在后面提到。注意捕捉列表为空时 [] 不能省略。

(parameters)：参数列表，与普通函数的参数列表功能类似。如果不需要参数传递，则可以连同 () 一起省略。

->return type：返回值类型，用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。一般返回值类型明确情况下，也可省略，由编译器对返回类型进行推导，不过还是建议显式写出来。

{function boby}：函数体，函数体内的实现跟普通函数完全类似，在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量，函数体为空也不能省略。

#include<iostream>

using namespace std;

int main()
{
	// 一个简单的 lambda 表达式 
	auto add1 = [](int x, int y)->int { return x + y; };
	cout << add1(1, 2) << endl;

	// 1、捕捉为空也不能省略 
	// 2、参数为空可以省略 
	// 3、返回值可以省略，可以通过返回对象自动推导 
	// 4、函数体不能省略 
	auto func1 = []
	{
		cout << "hello world" << endl;
		return 0;
	};

	func1();
	int a = 0, b = 1;

	auto swap1 = [](int& x, int& y)
	{
		int tmp = x;
		x = y;
		y = tmp;
	};

	swap1(a, b);
	cout << a << ":" << b << endl;

	return 0;
}
  • 输出
3
hello world
1:0

2. 捕捉列表

lambda 表达式中默认只能用 lambda 函数体和参数中的变量，如果想用外层作用域中的变量就需要进行捕捉。

  • 第一种捕捉方式是在捕捉列表中显式地传值捕捉和传引用捕捉，捕捉的多个变量用逗号分割。如 [x， y，&z] 表示对 x 和 y 值捕捉，对 z 引用捕捉。此时在函数体内可使用 x、y 和 z。

  • 第二种捕捉方式是在捕捉列表中隐式捕捉，我们在捕捉列表写一个 = 表示隐式值捕捉，在捕捉列表写一个 & 表示隐式引用捕捉，这样我们 lambda 表达式中用了哪些变量，编译器就会自动捕捉哪些变量。

  • 第三种捕捉方式是在捕捉列表中混合使用隐式捕捉和显式捕捉。如 [=, &x] 表示其他变量隐式值捕捉，对 x 引用捕捉；[&,x,y] 表示其他变量引用捕捉，对 x 和 y 值捕捉。当使用混合捕捉时，第一个元素必须是 & 或 =，并且 & 混合捕捉时，后面的捕捉变量必须是值捕捉。同理 = 混合捕捉时，后面的捕捉变量必须是引用捕捉。

lambda 表达式如果在函数局部域中，可以捕捉 lambda 位置之前定义的变量，不能捕捉静态局部变量和全局变量，静态局部变量和全局变量也不需要捕捉，lambda 表达式中可以直接使用。这也意味着 lambda 表达式如果定义在全局位置，捕捉列表必须为空。

默认情况下， lambda 捕捉列表是被 const 修饰的，也就是说传值捕捉的过来的对象不能修改，如果想要修改，那么可以用 mutable 加在参数列表的后面取消其常量性，也就说使用该修饰符后，传值捕捉的对象就可以修改了，但是修改还是形参对象，不会影响实参。使用该修饰符后，参数列表不可省略 (即使参数为空)。

int x = 0;
// 捕捉列表必须为空，因为全局变量不用捕捉就可以用，没有可被捕捉的变量 
auto func1 = [] { x++; return x; };  // x 可以修改

int main()
{
	cout << func1() << endl;  // 1

	// 只能用当前 lambda 局部域和捕捉的对象和全局对象 
	int a = 0, b = 1, c = 2, d = 3;
	auto func1 = [a, &b]
	{
		// 值捕捉的变量默认不能修改，引用捕捉的变量可以修改 
		// a++;
		b++;
		int ret = a + b;
		return ret;
	};
	cout << func1() << endl;  // 2

	// 隐式值捕捉 
	// 用了哪些变量就捕捉哪些变量 
	auto func2 = [=]
	{
		int ret = a + b + c;
		return ret;
	};
	cout << func2() << endl;  // 4

	// 隐式引用捕捉 
	// 用了哪些变量就捕捉哪些变量 
	auto func3 = [&]
	{
		a++;
		c++;
		d++;
	};
	func3();
	cout << a << " " << b << " " << c << " " << d << endl;  // 1 2 3 4

	// 混合捕捉 1 
	auto func4 = [&, a, b]
	{
		// a++;
		// b++;
		c++;
		d++;
		return a + b + c + d;
	};
	func4();
	cout << a << " " << b << " " << c << " " << d << endl;  // 1 2 4 5

	// 混合捕捉 2 
	auto func5 = [=, &a, &b]
	{
		a++;
		b++;
		//c++;
		//d++;
		return a + b + c + d;
	};
	func5();
	cout << a << " " << b << " " << c << " " << d << endl;  // 2 3 4 5

	// 局部的静态和全局变量不能捕捉，也不需要捕捉 
	static int m = 0;
	auto func6 = []
	{
		int ret = x + m;
		return ret;
	};
	cout << func6() << endl;  // 1

	// 传值捕捉本质是一种拷贝,并且被 const 修饰了 
	// mutable 相当于去掉 const 属性，可以修改了 
	// 但是修改了不会影响外⾯被捕捉的值，因为是一种拷贝 
	auto func7 = [=]() mutable  // 这里 () 不能省略
	{
		a++;
		b++;
		c++;
		d++;
		return a + b + c + d;
	};
	cout << func7() << endl;  // 18
	cout << a << " " << b << " " << c << " " << d << endl;  // 2 3 4 5

	return 0;
}
  • 输出
1
2
4
1 2 3 4
1 2 4 5
2 3 4 5
1
18
2 3 4 5

3. lambda 的应用

在学习 lambda 表达式之前，我们使用的可调用对象只有函数指针和仿函数对象，函数指针的类型定义起来比较麻烦，仿函数要定义一个类，相对也会比较麻烦。而使用 lambda 去定义可调用对象，既简单又方便。

假设我们现在为一件商品定义了一个类：

struct Goods
{
	string _name; // 名字 
	double _price; // 价格 
	int _evaluate; // 评价 
	// ...

	Goods(const char* str, double price, int evaluate)
		:_name(str)
		, _price(price)
		, _evaluate(evaluate)
	{}
};

现在我们想要根据不同的标准对商品进行排序，根据以前学习的仿函数，我们可以得到下面的代码：

struct ComparePriceLess
{
	bool operator()(const Goods& gl, const Goods& gr)
	{
		return gl._price < gr._price;
	}
};

struct ComparePriceGreater
{
	bool operator()(const Goods& gl, const Goods& gr)
	{
		return gl._price > gr._price;
	}
};

int main()
{
	vector<Goods> v = 
	{
		{ "苹果", 2.1, 5 },
		{ "⾹蕉", 3, 4 },
		{ "橙⼦", 2.2, 3 },
		{ "菠萝", 1.5, 4 } 
	};

	// 类似这样的场景，我们实现仿函数对象或者函数指针支持商品中不同项的比较
	// 相对还是⽐较麻烦的
	sort(v.begin(), v.end(), ComparePriceLess());
	sort(v.begin(), v.end(), ComparePriceGreater());

	return 0;
}

有了 lambda 之后，上面的代码就可以修改成下面这样：

int main()
{
	vector<Goods> v = 
	{
		{ "苹果", 2.1, 5 },
		{ "⾹蕉", 3, 4 },
		{ "橙⼦", 2.2, 3 },
		{ "菠萝", 1.5, 4 } 
	};

	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
		return g1._price > g2._price;
		});
    
	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
		return g1._evaluate < g2._evaluate;
		});
    
	return 0;
}

这样一来，我们可以一眼看到排序的逻辑，增加了可读性，同时写起来也更加方便。

4. lambda 的原理

lambda 的原理和范围 for 很像，编译后从汇编指令层的角度看，压根就没有 lambda 和范围 for 这样的东西。范围 for 底层是替换为迭代器，而 lambda 底层是仿函数对象。也就说我们写了一个 lambda 以后，编译器会生成一个对应的仿函数的类。这个类的名称只有编译器知道，我们不知道，所以写 lambda 时才要配合 auto 去写。

仿函数的类名是编译按一定规则生成的，保证不同的 lambda 生成的类名不同，lambda 参数/返回类型/函数体就是仿函数中 operator() 的参数/返回类型/函数体，lambda 的捕捉列表本质是生成的仿函数类的成员变量，也就是说捕捉列表的变量都是 lambda 类构造函数的实参，当然隐式捕捉，编译器要看使用哪些就传那些对象。

三、包装器

1. function

std::function 是一个类模板，也是一个包装器。std::function 的实例对象可以包装存储其他的可以调用的对象，包括函数指针、仿函数、lambda 、bind 表达式等，存储的可调用对象被称为 std::function 的目标。若 std::function 不含目标，则称它为空。调用空 std::function 的目标导致抛出 std::bad_function_call 异常。

以下是 function 的原型，它被定义在头文件 <functional> 中。

请添加图片描述

函数指针、仿函数、lambda 等可调用对象的类型各不相同，std::function 的优势就是统一类型，对它们都可以进行包装，这样在很多地方就方便声明可调用对象的类型。

在使用该函数包装可调用对象时，模板参数需要用 <函数的返回类型(函数的参数类型的列表)> 的格式，具体见下面代码示例。

int f(int a, int b)
{
	return a + b;
}

struct Functor
{
public:
	int operator() (int a, int b)
	{
		return 10 * (a + b);
	}
};

class Plus
{
public:
	Plus(int n = 10)
		:_n(n)
	{}

	static int plusi(int a, int b)
	{
		return a + b;
	}

	double plusd(double a, double b)
	{
		return (a + b) * _n;
	}

private:
	int _n;
};

int main()
{
	// 包装各种可调用对象 
	function<int(int, int)> f1 = f;
	function<int(int, int)> f2 = Functor();
	function<int(int, int)> f3 = [](int a, int b) { return (a + b) / 2; };

	// 统一类型之后就可以装在容器中
	vector<function<int(int, int)>> func = { f1, f2, f3 };
	for (auto f : func)
	{
		cout << f(1, 2) << endl;
	}

	// 成员函数要指定类域并且前面加 & 才能获取地址

	// 包装静态成员函数时可以加 & 可以不加，不加 & 时会隐式转换为函数指针
	function<int(int, int)> f4 = &Plus::plusi;
	// function<int(int, int)> f4 = Plus::plusi;  // OK
	cout << f4(1, 1) << endl;

	// 包装普通成员函数 
	// 普通成员函数还有一个隐含的 this 指针参数
	// 注意这里绑定时传对象或者对象的指针过去都可以
	// 从底层的角度看这个参数都是为了拿到这个对象，传指针就是 ->* 去拿，传对象就是用 .*
	function<double(Plus*, double, double)> f5 = &Plus::plusd;
	Plus pd;
	cout << f5(&pd, 1.1, 1.1) << endl;

	function<double(Plus, double, double)> f6 = &Plus::plusd;
	cout << f6(pd, 1.1, 1.1) << endl;

	function<double(Plus&&, double, double)> f7 = &Plus::plusd;
	cout << f7(move(pd), 1.1, 1.1) << endl;
	cout << f7(Plus(), 1.1, 1.1) << endl; 

	return 0;
}
  • 输出
3
30
1
2
22
22
22
22

2. function + lambda 的简单应用

【题目链接】

150. 逆波兰表达式求值 - 力扣（LeetCode）

class Solution {
public:
    // 建立一个操作符与函数的映射
    // 想要把函数放进容器里就可以用包装器
    map<string, function<int(int, int)>> opFuncMap = 
    {
        {"+", [](int x, int y){return x + y;} },
        {"-", [](int x, int y){return x - y;} },
        {"*", [](int x, int y){return x * y;} },
        {"/", [](int x, int y){return x / y;} }
    };

    int evalRPN(vector<string>& tokens) 
    {
        stack<int> st;
        for(auto& t : tokens)
        {
            if(opFuncMap.count(t))
            {
                int right = st.top(); st.pop();
                int left = st.top(); st.pop();
                st.push(opFuncMap[t](left, right));
            }
            else st.push(stoi(t));
        }
        
        return st.top();
    }
};

3. bind

bind 是一个函数模板，它也是一个可调用对象的包装器，可以把它看作一个函数适配器，对接收的可调用对象进行处理后返回一个新的可调用对象。bind 可以用来调整参数个数和参数顺序。

请添加图片描述

和 function 一样，bind 也在头文件 functional 中。

调用 bind 的一般形式：auto newCallable = bind(callable, arg_list); 其中 newCallable 本身是一个可调用对象，arg_list 是一个逗号分隔的参数列表，对应给定的 callable 的参数。当我们调用 newCallable 时，newCallable 会调用 callable，并传给它 arg_list 中的参数。

arg_list 中的参数可能包含形如 _n 的名字，其中 n 是一个整数，这些参数是占位符，表示 newCallable 的参数，它们占据了传递给 newCallable 的参数的位置。数值 n 表示生成的可调用对象中参数的位置：

  • _1 为 newCallable 的第一个参数；
  • _2 为 newCallable 的第二个参数；
  • 以此类推。

_1/_2/_3…这些占位符放到了一个叫 placeholders 的命名空间中。

光说可能有些抽象，下面来看一下它的具体使用：

using placeholders::_1;
using placeholders::_2;
using placeholders::_3;

int Sub(int a, int b)
{
	return (a - b) * 10;
}

int SubX(int a, int b, int c)
{
	return (a - b - c) * 10;
}

class Plus
{
public:
	static int plusi(int a, int b)
	{
		return a + b;
	}
	double plusd(double a, double b)
	{
		return a + b;
	}
};

int main()
{
	auto sub1 = bind(Sub, _1, _2);
	cout << sub1(10, 5) << endl;  // 50
	// bind 本质返回的一个仿函数对象 
	// 调整参数顺序 (不常用) 
	// _1 代表第一个实参，注意是实参，也就是 sub1 中的第一个参数
	// _2 代表第二个实参 
	// ...
	auto sub2 = bind(Sub, _2, _1);
	cout << sub2(10, 5) << endl;  // -50

	// 调整参数个数 (常用)
	auto sub3 = bind(Sub, 100, _1);  // 绑死了 Sub 中的第一个参数，始终为 100
    // 现在只需要传一个参数给 _1，_1 又传给 Sub 中的 b
	cout << sub3(5) << endl;  // 950

	auto sub4 = bind(Sub, _1, 100);  // 帮死了第二个参数
	cout << sub4(5) << endl;  // -950

	// 分别绑死第 1、2、3 个参数 
	auto sub5 = bind(SubX, 100, _1, _2);
	cout << sub5(5, 1) << endl;  // -940

	auto sub6 = bind(SubX, _1, 100, _2);
	cout << sub6(5, 1) << endl;  // -960

	auto sub7 = bind(SubX, _1, _2, 100);
	cout << sub7(5, 1) << endl;  // -960

	return 0;
}
  • 输出
50
-50
950
-950
940
-960
-960

4. bind + lambda 的简单应用

int main()
{
	// 计算复利的 lambda 
	auto func1 = [](double rate, double money, int year)->double 
    {
		double ret = money;
		for (int i = 0; i < year; i++)
		{
			ret += ret * rate;
		}
		return ret - money;
	};
    
	// 绑死一些参数，实现出支持不同年化利率，不同⾦额和不同年份计算出复利的结算利息
	function<double(double)> func3_1_5 = bind(func1, 0.015, _1, 3);
	function<double(double)> func5_1_5 = bind(func1, 0.015, _1, 5);
	function<double(double)> func10_2_5 = bind(func1, 0.025, _1, 10);
	function<double(double)> func30_3_5 = bind(func1, 0.035, _1, 30);
	
	cout << func3_1_5(1000000) << endl;
	cout << func5_1_5(1000000) << endl;
	cout << func10_2_5(1000000) << endl;
	cout << func30_3_5(1000000) << endl;
    
    return 0;
}
  • 输出
45678.4
77284
280085
1.80679e+06
C++11 新特性 ① | C++11 常用关键字实战详解
dvlinker的技术专栏
09-05 2万+
本文结合工作实践详细介绍C++11 常用关键字，以供借鉴或参考。
【C++】C++11特性的详解
浩瀚之水的专栏
04-11 1473
C++11 是现代 C++ 的基石，通过智能指针、移动语义、Lambda 等特性大幅提升代码的安全性、性能和可读性，奠定了后续版本（C++14/17/20）的基础。建议优先掌握 auto、智能指针、右值引用和 Lambda 表达式，以快速提升开发效率。
C++11新特性详解与实战应用
wgr050505的博客
08-30 1820
C++11带来的新特性极大地丰富了C++语言的功能性，同时也提高了开发者的生产力。从自动类型推导到线程支持，每一项特性都旨在让开发者能够写出更高效、更安全、更易读的代码。希望这篇文章能帮助你更好地理解和使用这些强大的工具！
C++23新特性详解：迈向更现代化的C++
码事漫谈
04-10 2700
C++23作为C++语言的最新版本，引入了许多新特性和改进，旨在进一步提升C++语言的功能和开发效率。这些新特性不仅提高了代码的可读性和可维护性，还优化了编译器的性能和程序的执行效率。C++23的发布标志着C++语言在现代化道路上又迈出了坚实的一步，为开发者提供了更多的工具和可能性，以应对日益复杂的编程挑战。
C++ | C++11新特性解析：现代编程的里程碑
LiHongyu05的博客
08-14 2124
在2003年，C++标准委员会提交了一份技术勘误表（TC1），使得C++03成为C++98之后的最新标准。然而，C++03主要是对C++98标准中的漏洞进行修复，语言的核心部分并没有大的改动。因此，人们通常将这两个标准合并称为C++98/03标准。从C++0x到C++11，C++标准经过了长达十年的发展，带来了约140个新特性和对C++03标准中约600个缺陷的修正。这使得C++11更像是从C++98/03中孕育出的一种新语言。
C++ 11新特性详解
qq_61635026的博客
10-02 3300
在2003年C++标准委员会曾经提交了一份技术勘误表(简称TC1)，使得C++03这个名字已经取代了C++98称为C++11之前的最新C++标准名称。不过由于C++03(TC1)主要是对C++98标准中的漏洞进行修复，语言的核心部分则没有改动，因此人们习惯性的把两个标准合并称为C++98/03标准。从C++0x到C++11，C++标准10年磨一剑，第二个真正意义上的标准珊珊来迟。相比于C++98/03，C++11则带来了数量可观的变化，其中包含了约140个新特性，以及对C++03标准中约600个缺陷的修正，
【C++11】C++的新特性（详解）
weixin_63449996的博客
05-27 2015
详细解析了C++11新增的容器与方法功能。
详解c++新特性—c++11
怀秋秋意的博客
05-24 3209
详解c++新特性—c++11
学懂C++（五十三）：全面解析：C++11 标准及其新特性详解
编程技术探索者，分享C/C++、C#、Java、数据库等开发经验，聚焦实战技巧与AI兴趣，助力编程爱好者成长。
09-09 3132
学懂C++：全面解析：C++11 标准及其新特性详解
C++ sort()排序详解
热门推荐
晴空๓
05-05 57万+
本文对C++中的sort()做了一个比较详细的说明，包括为什么选择使用sort()、sort()函数的实现原理、sort()的使用方法等等。
C++ 11新特性之大括号初始化详解
01-01
本文主要给大家介绍了关于C++11新特性之大括号初始化的相关内容，分享出来供大家参考学习，下面话不多说了，来一起看看详细的介绍： C++11之前，C++主要有以下几种初始化方式： //小括号初始化 string str(hello); ...
【C++编程语言】C++11新特性详解：智能指针、右值引用及Lambda表达式在现代C++开发中的应用
07-10
内容概要：本文详细介绍了C++11引入的新特性，涵盖自动类型推导（auto）、范围基的for循环、lambda表达式、智能指针、移动语义、初始化列表、静态断言、线程支持、新标准库组件、委托构造函数、显式类型转换、用户...
详解c++11新特性之模板的改进
08-19
C++11 模板改进详解 C++11 对于模板的改进主要有三方面：模板的右尖括号、模板的别名和函数模板的默认模板参数。 首先，C++11 之前是不允许两个右尖括号出现的，会被认为是右移操作符，所以需要中间加个空格进行...
C++现代化开发：C++11-14-17-20新特性详解.md
09-06
现代C++从C++11到C++20各版本的新特性，以及它们在开发中的应用。C++11作为重大变革版本，引入了自动类型推导、基于范围的for循环、Lambda表达式、智能指针、右值引用和移动语义等，显著提升了代码简洁性和性能。C++...
Parasoft C/C++test如何解决在VC6环境中单元测试的LNK2005错误
2501_91602431的博客
11-05 536
Parasoft C/C++test是一款专为C/C++代码设计的自动化测试工具，通过静态代码分析、单元测试和运行时错误检测等功能，帮助开发团队在早期发现并修复缺陷，提升代码质量和开发效率 。在实际使用中，尤其是在VC6此类旧版开发环境中执行单元测试时，可能会因环境兼容性问题触发链接错误。
【C语言】localtime和localtime_r；strftime和strftime_l
Ape's IT Blog
11-05 715
localtime和localtime_r是C标准库中用于将时间戳转换为本地时间的函数，主要区别在于线程安全性和存储方式。
【C++】多态（1）：多态定义&&实现及虚函数的重写
zzzsde的博客
11-09 1104
多态是指在继承关系下，不同的类对象调用同一函数时，产生不同行为的现象。例如，Student 类继承自 Person 类，Person 对象调用 “买票” 函数执行全价逻辑，而 Student 对象调用同名的 “买票” 函数则执行优惠逻辑。
《C语言点滴》——笑着入门，扎实成长
最新发布
码事漫谈
11-09 192
第 2～13 章把数据类型、运算符、控制流、函数、数组、指针、结构体、文件、调试等“硬骨头”挨个敲碎；不同于《C 陷阱与缺陷》的“错误案例大合集”，本书习惯先给出正确范式，再用 1～2 段最精简的代码把原理跑通；C 语言语法简单，却“贴近机器”，初学者常被指针、数组越界、格式串错误等问题绊倒。如果你第一次学 C，却不想“从入门到放弃”，把《C 语言点滴》放在手边。每章末尾会“贴心”地引用 K&R、C FAQ、C 标准库等经典资料，告诉你“学完了该往哪儿钻”。二、写作风格：把“枯燥”写成“脱口秀”
C Primer Plus 12.9 编程练习
Auroruaur0rua的博客
11-05 252
【代码】C Primer Plus 12.9 编程练习。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值