C++内联函数-auto关键字-for循环-空指针

内联函数

1.1概念：

以 inline 修饰 的函数叫做内联函数， 编译时 C++ 编译器会在 调用内联函数的地方展开 ，没有函数调

用建立栈帧的开销，内联函数提升程序运行的效率。

#define _CRT_SECURE_NO_WARNINGS

int ADD(int left, int right)
{
	return left + right;
}

int main()
{
	int ret = ADD(2, 3);
	return 0;
}

如果使用内联函数（inline） 在编译期间编译器会用函数体替换函数的调用。

查看方式：

1. 在 release 模式下，查看编译器生成的汇编代码中是否存在 call Add

2. 在 debug 模式下，需要对编译器进行设置，否则不会展开 ( 因为 debug 模式下，编译器默认不

会对代码进行优化，以下给出 vs2013 的设置方式 )

#define _CRT_SECURE_NO_WARNINGS

inline int ADD(int left, int right)
{
	return left + right;
}

int main()
{
	int ret = ADD(2, 3);
	return 0;
}

1.2特性：

1. inline 是一种 以空间换时间 的做法，如果编译器将函数当成内联函数处理，在 编译阶段，会

用函数体替换函数调用 ，缺陷：可能会使目标文件变大，优势：少了调用开销（我理解为函数栈帧），提高程序运 行效率。

. inline 对于编译器而言只是一个建议，不同编译器关于 inline 实现机制可能不同 ，一般建

议：将 函数规模较小 ( 即函数不是很长，取决于编译器内部实现 ) 、 不 是递归、且频繁调用 的函数采用 inline 修饰，否则编译器会忽略 inline 特性。

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

了，链接就会找不到。

//"F.h"
#pragma once
#include<iostream>
using namespace std;

inline void f(int i);


//"F.cpp"
#define _CRT_SECURE_NO_WARNINGS
#include"F.h"
 void f(int i)
{
	 cout << i << endl;
}

//"Text.cpp"
#include"F.h"
int main()
{
	//int ret = ADD(2, 3);
	f(1);
	return 0;
}

auto关键字

2.1简介：

1.auto 修饰的变量，是具有自动存储器的局部变量

2.C++11 中，标准委员会赋予了 auto 全新的含义即： auto 不再是一个存储类型指示符，而是作为一

个新的类型指示符来指示编译器， auto 声明的变量必须由编译器在编译时期推导而得 。

#include<iostream>
using namespace std;
int Textauto(int i = 0)
{
	return i;
}
int main()
{
	int a = 10;
	auto b = a;
	auto c = 'a';
	auto d = Textauto(2);
//typeid是检查变量的类型
	cout << typeid(b).name() << endl;
	cout << typeid(c).name() << endl;
	cout << typeid(d).name() << endl;

	//auto e 不能通过编译，使用auto定义变量是必须对其进行初始化
	return 0;
}

注意：

使用 auto 定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导 auto

的实际类型 。因此 auto 并非是一种 “ 类型 ” 的声明，而是一个类型声明时的 “ 占位符 ” ，编译器在编

译期会将 auto 替换为变量实际的类型

int main()
{
	int x = 10;
	//用auto声明指针类型时，用auto和auto* 没有任何区别
	auto a = &x;
	auto* b = &x;
	//用auto声明引用类型时则必须加&
	auto& c = x;
	cout << typeid(a).name() << endl;
	cout << typeid(b).name() << endl;
	cout << typeid(c).name() << endl;
	*a = 20;
	*b = 30;
	c = 40;

//当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译
//器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。
    auto a = 1, b = 2;
    //auto c = 3, d = 4.0//该行代码会编译失败，因为c和d的初始化表达式类型不同
	return 0;
}

// 此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导
void TestAuto(auto a)
{}

auto 不能作为函数的参数

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

auto 不能直接用来声明数组

for循环

1.1（auto偷懒）

int main()
{
	int array[] = { 1,2,3,4,5 };
	for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
	{
		array[i] *= 2;
	}
	for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
	{
		cout << array[i] << ' ';
	}
	cout <<endl;
	范围for
	//依次自动取array中的数据，赋值给e..自动判断结束
	for (auto e : array)
	{
		cout << e << ' ';
	}
	cout << endl;

	//想要影响数组里面的值就必须用&（引用）
    //for循环后的括号由冒号“ ：”分为两部分：第一部分是范
    //围内用于迭代的变量，第二部分则表示被迭代的范围。
    //1. for循环迭代的范围必须是确定的
    //对于数组而言，就是数组中第一个元素和最后一个元素的范围；
	for (auto& e : array)
	{
		e *= 2;
	}
	cout << endl;
	for (auto e : array)
	{
		cout << e << ' ';
	}
	return 0;
}

空指针

1.1案例：

void f(int)
{
 cout<<"f(int)"<<endl;
}
void f(int*)
{
 cout<<"f(int*)"<<endl;
}
int main()
{
 f(0);
 f(NULL);
 f((int*)NULL);
 return 0;
}

NULL 可能被定义为字面常量 0 ，或者被定义为无类型指针 (void*) 的常量 。

注意：

1. 在使用 nullptr 表示指针空值时，不需要包含头文件，因为 nullptr 是 C++11 作为新关键字引入

的

NULL实际是一个宏，在传统的C头文件(stddef.h)中，可以看到如下代码： 

#ifndef NULL

#ifdef __cplusplus

#define NULL   0

#else

#define NULL   ((void *)0)

#endif

#endif