c++杂谈-5

---

一、一些c++11新特性

1. decltype关键字及函数后置返回类型

在C++11中，decltype操作符，用于查询表达式的数据类型。

语法：decltype(expression）var;

decltype只分析表达式并得到它的类型，不会计算执行表达式。decltype分析函数也只是一种表达式，因此不必担心在使用decltype时调用了函数。

decltype的类型推导规则：

1. 如果expression是一个没有用括号括起来的标识符，则var的类型与该标识符的类型相同，包括const等限定符。
2. 如果expression是一个函数调用，则var的类型与函数的返回值类型相同（函数不能返回void，但可以返回void*）。
3. 如果expression是一个左值（能取地址）、或者用括号括起来的标识符，那么var的类型是expression的引用。
4. 如果上面的条件都不满足，则var的类型与expression的类型相同。

decltype可以结合typedef和using定义别名使用。

int func(){
...
}

short a = 5;
const* char b = "abc";
short& c = a;
short d = 3;

decltype(a) da; // da为变量的类型：short
decltype(b) db; // db为变量的类型：const* char
decltype(c)dc = d; // dc为引用类型：short&

decltype(func())dd = d; // dd为函数返回值类型：int
decltype(func)* de = func; // de为函数指针类型：int (*func)
de(); // 调用函数

decltype(++a)df; // df为左值引用类型：short &a
decltype((a))dg; // dg为引用类型：short &a

decltype(func)dh; // dh为func函数的类型：int func()
decltype((func))di; // di为func函数的引用：int (&di)()

decltype(func())dj; // auto e = func(); 这里dj和e都为int类型，但decltype不执行函数调用，而auto要求执行函数调用得到返回值（这样才能推导）。

使用auto的案例：

#include <iostream>

using namespace std;

template<typename T1, typename T2>
void func(T1 x, T2 y) {
	auto tmp = x + y; // 使用auto关键字来解决泛化参数的混合类型运算结果的类型问题
	cout << "tmp=" << tmp << endl;
}

int main(int argc, const char **argv) {
	short a = 5;
	char b = 3;
	func(a, b);

	return 0;
}

2. 函数后置返回类型

int func(int x,double y);

等同于：

auto func(int x,double y)-> int;

将返回类型移到了函数声明的后面。
auto是一个占位符（C++11给auto新增的角色），为函数返回值占了一个位置。
这种语法也可以用于函数定义：

auto func(int x, double y)->int {
	// 函数体。
}

整合decltype的案例：

#include <iostream>

using namespace std;

template<typename T1, typename T2>
auto func(T1 x, T2 y) -> decltype(x+y) {
	decltype(x+y) tmp = x + y;
	return tmp;
}

int main(int argc, const char **argv) {
	cout << "tmp=" << func(3.14, 5) << endl;

	return 0;
}

C++14标准对函数返回类型推导规则做了优化，函数的返回值可以用auto，不必尾随返回类型。

#include <iostream>

using namespace std;

template<typename T1, typename T2>
auto func(T1 x, T2 y) {
	decltype(x+y) tmp = x + y;
	// auto tmp = x + y; 也可以
	return tmp;
}

int main(int argc, const char **argv) {
	cout << "tmp=" << func(3.14, 5) << endl;

	return 0;
}

二、c++的内存模型

栈和堆的主要区别：

1. 管理方式不同：栈是系统自动管理的，在出作用域时，将自动被释放；堆需手动释放，若程序中不释放，程序结束时由操作系统回收。
2. 空间大小不同：堆内存的大小受限于物理内存空间；而栈就小得可怜，一般只有8M（可以修改系统参数）。
3. 是否产生碎片：对于栈来说，进栈和出栈都有严格的顺序（先进后出），不会产生碎片；而堆频繁地分配和释放，会造成内存空间的不连续，容易产生碎片，太多的碎片会导致性能的下降。

三、函数指针和回调函数

函数指针的主要用途就是回调函数。
函数的类型是指：返回值和参数列表（函数名和形参名不是）——形参只涉及个数与类型

int (*pfa)(int, string);
bool (*pfb)(int, string);

基本示例

#include <iostream>

using namespace std;

void func(int no, string str) {
	cout << "NO. " << str << endl;
}

int main(int argc, const char **argv) {
	int no = 3;
	string msg = "balabala...";

	void (*pfunc)(int, string); // 声明函数指针
	pfunc = func;
	pfunc(no, msg); // 用函数指针调用函数：c++方式
	(*pfunc)(no, msg); //  用函数指针调用函数：c方式

	return 0;
}

回调函数：函数由用户定义，但调用不由用户来完成，调用随后交给系统/框架去完成。

#include <iostream>

using namespace std;

void custome1() {
	cout << "custome1" << endl;
}

void custome2(string msg) {
	cout << "custome2: " << msg << endl;
}

void custome3(string msg) {
	cout << "custome3: " << msg << endl;
}

void framework(void (*callback)()) {
	cout << "void (*callback)()" << endl;
	callback();
}

void framework(void (*callback)(string)) {
	string msg = "internal";
	cout << "void (*callback)(string): " << msg << endl;
	callback(msg);
}

void framework(void (*callback)(string), string msg) {
	cout << "void (*callback)(string): " << msg << endl;
	callback(msg);
}

int main(int argc, const char **argv) {
	framework(custome1);
	framework(custome2);
	framework(custome3, "external");

	return 0;
}

四、函数模版的注意事项

1. 可以为类的成员函数创建模板，但不能是虚函数和析构函数。
2. 使用函数模板时，必须明确数据类型，确保实参与函数模板能匹配上。

swap<int>();

3. 使用函数模板时，推导的数据类型必须适应函数模板中的代码。
4. 使用函数模板时，如果是自动类型推导，不会发生隐式类型转换，如果显示指定了函数模板的数据类型，可以隐式类型转换。

template<typename T>
T Add(T a, T b){
	return a+b;
}
...
int a=10;
char b=73;
int c=Add(a,b); //报错：不能进行隐式转换。
int d=Add<int>(a,b); //编译通过：显式指定函数模版的数据类型，可以完成隐式转换。

5. 函数模板支持多个通用数据类型的参数。
6. 函数模板支持重载，可以有非通用数据类型的参数。