目录

一. 内联函数

1.概念

2. 特性

3.C语言的宏与C++的inline

二、auto关键字(C++11)

1. auto简介

2.auto的使用细则

3.auto不能推导的场景

4.基于范围的for循环(C++11)

5. 范围for的使用条件

三、 指针空值nullptr(C++11)

1. C++98中的指针空

一. 内联函数

1.概念 以 inline 修饰 的函数叫做内联函数， 编译时 C++ 编译器会在 调用内联函数的地方展开 ，没有函数调用建立栈帧的开销，内联函数提升程序运行的效率。

如果在上述函数前增加inline关键字将其改成内联函数，在编译期间编译器会用函数体替换函数的调用。

查看方式： 1. 在 release模式 下，查看编译器生成的汇编代码中是否存在 call Add 2. 在 debug模式 下，需要对编译器进行设置，否则不会展开 ( 因为 debug模式 下，编译器默认不会对代码进行优化，以下给出vs2013 的设置方式 )

inline在调用的地方，直接进行展开

 

2. 特性 1. inline 是一种 以空间换时间 的做法，如果编译器将函数当成内联函数处理，在 编译阶段，会用函数体替 换函数调用。 缺陷： 可能会使目标文件变大 优势： 少了调用开销，提高程序运行效率

2. inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建议：将函数规模较小、不是递归、频繁调用的函数采用inline修饰，否则如果定义为inline的函数体内部实现代码指令长度比较长（10 行左右，不同编译器不同）/递归等，编译器优化时会忽略内联。

下图为《C++prime》第五版关于inline的建议：

 3. inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。

// F.h
#include 
using namespace std;

inline void func(int a,int b);


// F.cpp
#include "F.h"

void func(int a,int b)
{
    int c = a + b;
	c = a * b;
	c = a * b;
	c = a + b;
	c = a / b;
	c = a * b;
	c = a * b;
}


// main.cpp
#include "F.h"

int main()
{
	func(1,2);
	return 0;
}

3.C语言的宏与C++的inline

#define ADD(a,b) ((a)+(b))

// 预处理--替换
int main()
{
	ADD(1, 2); // ((1) + (2))
    //满足宏的三种情形


	if (ADD(1, 2)) // 	if (((1)+(2))) //宏定义后不能接 ';'
	{}

	ADD(1, 2) * 3; // ((1)+(2))*3

	int x = 1, y = 2;
	ADD(x|y, x&y); // ((x|y)+(x&y))   (x|y+ x&y)  // + 优先级大于 | 和 &

	return 0;
}

宏的优点：1、复用性变强 2、宏函数提高效率，减少栈帧的建立

宏的缺点：1、可读性差，复杂  2、没有类型安全检查  3、不方便调试

C++中基本不再建议使用宏，《effective C++》一个条款说明：尽量使用 const、enum、inline去代替宏 .

inline几乎解决宏函数的缺点，同时兼具他的优点

二、auto关键字(C++11)

1. auto简介 C++11 中，标准委员会赋予了 auto 全新的含义即： auto 不再是一个存储类型指示符，而是作为一个新的类型 指示符来指示编译器， auto 声明的变量必须由编译器在编译时期推导而得

int TestAuto()
{
	return 10;
}

int main()
{
	int a = 10;
	auto b = a; // 自动推导类型
	auto c = 'a';
	auto d = TestAuto();
	cout << typeid(b).name() << endl;
	cout << typeid(c).name() << endl;
	cout << typeid(d).name() << endl;
    
    //auto e; 无法通过编译，使用auto定义变量时必须对其进行初始化

	return 0;
}

【注意】

使用 auto 定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导 auto 的实际类 型 。因此 auto 并非是一种 “ 类型 ” 的声明，而是一个类型声明时的 “ 占位符 ” ，编译器在编译期会将 auto 替换为 变量实际的类型 。

2.auto的使用细则 1. auto 与指针和引用结合起来使用 用 auto 声明指针类型时，用 auto 和 auto* 没有任何区别，但用 auto 声明引用类型时则必须加 &

int main()
{
	int x = 10;
	//auto a = &x;  //error    int*
	auto* b = &x;  // int* 强调一定要传指针
	auto& c = x;   // int 强调c是一个引用

	cout << typeid(a).name() << endl;
	cout << typeid(b).name() << endl;
	cout << typeid(c).name() << endl;

	return 0;
}

2. 在同一行定义多个变量 当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对 第一个类型进行推导，然后用推导出来的类型定义其他变量 。

void TestAuto()
{
	auto a = 1, b = 2;
	auto c = 3, d = 4.0; // 该行代码会编译失败，因为c和d的初始化表达式类型不同
}

3.auto不能推导的场景 1. auto 不能作为函数的参数

void TestFor(int array[])//array实际是数组首元素地址的拷贝，auto不具备接受数组地址来打印整个数组的功能
{
	for (auto& e : array)  //error
		cout << e << endl;
}

2. auto 不能直接用来声明数组

void TestAuto()
{
   int a[] = {1,2,3};
   auto b[] = {4，5，6};
}

3. 为了避免与 C++98 中的 auto 发生混淆， C++11 只保留了 auto 作为类型指示符的用法 4. auto 在实际中最常见的优势用法就是跟以后会讲到的 C++11 提供的新式 for 循环，还有 lambda 表达式等进行配合使用。

4.基于范围的for循环(C++11) 1. 范围 for 的语法 在 C++98 中如果要遍历一个数组，可以按照以下方式进行：

int main()
{
	int a[] = { 1, 2, 3, 4, 5, 6 };

	for (int i = 0; i < sizeof(a) / sizeof(int); ++i)
	{
		a[i]++;
	}

	for (int i = 0; i < sizeof(a) / sizeof(int); ++i)
	{
		cout << a[i] << " ";
	}
	cout << endl;

	// 范围for
	// 自动依次取a的数据，赋值给e
	// 自动迭代，自动判断结束
	for (auto& e : a)
	{
		e--;
	}

	for (auto e : a)
	{
		cout << e << " ";
	}
	cout << endl;

	return 0;
}

对于一个 有范围的集合 而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此 C++11 中引入了基于范围的for 循环。 for 循环后的括号由冒号 “ ： ” 分为两部分：第一部分是范围内用于迭代的变量， 第二部分则表示被迭代的范围 。 注意：与普通循环类似，可以用 continue 来结束本次循环，也可以用 break 来跳出整个循环 。

5. 范围for的使用条件 1. for 循环迭代的范围必须是确定的 对于数组而言，就是数组中第一个元素和最后一个元素的范围 ；对于类而言，应该提供 begin 和 end 的方法，begin 和 end 就是 for 循环迭代的范围。 注意：以下代码就有问题，因为 for 的范围不确定

void TestFor(int array[])
{
    for(auto& e : array)
    cout<< e < 
  
三、 指针空值nullptr(C++11)  
  
1. C++98中的指针空值 
   
   
    NULL
    实际是一个宏，在传统的
    C
    头文件
    (stddef.h)
    中，可以看到如下代码： 
    
   
  
  
  
#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif
 
  
   可以看到，
   NULL
   可能被定义为字面常量
   0
   ，或者被定义为无类型指针
   (void*)
   的常量
   。不论采取何种定义，在使用空值的指针时，都不可避免的会遇到一些麻烦，比如
   
   
   
void f(int)
{
	cout << "f(int)" << endl;
}

void f(int*)
{
	cout << "f(int*)" << endl;
}

int main()
{
	int* p = NULL;
	f(0);       //int
	f(NULL);    //int
	f(p);       //int*

	// C++11 nullptr 关键字 替代NULL
	f(nullptr);  //int*
	int* ptr = nullptr;

	return 0;
}
 
   
    在
    C++98
    中，字面常量
    0
    既可以是一个整形数字，也可以是无类型的指针
    (void*)
    常量，但是编译器默认情况下将其看成是一个整形常量，如果要将其按照指针方式来使用，必须对其进行强转(void *)0
    。 
    
   
    注意： 
    
   
 
    
     1. 
     在使用
     nullptr
     表示指针空值时，不需要包含头文件，因为
     nullptr
     是
     C++11
     作为新关键字引入的
     。 
     
     
     
      2. 
      在
      C++11
      中，
      sizeof(nullptr) 
      与
       sizeof((void*)0)
      所占的字节数相同。 
      
     
      3. 
      为了提高代码的健壮性，在后续表示指针空值时建议最好使用
      nullptr
      。