C++入门

C++入门

1. C++关键字(C++98)

C++总计63个关键字，C语言32个关键字

**ps：**下面只是看一下C++有多少关键字，不对关键字进行具体的讲解。

asm	do	if	return	try	continue
auto	double	inline	short	typedef	for
bool	dynamic_cast	int	signed	typeid	public
break	else	long	sizeof	typename	throw
case	enum	mutable	static	union	wchar_t
catch	explicit	namespace	static_cast	unsigned	default
char	export	new	struct	using	friend
class	extern	operator	switch	virtual	register
const	false	private	template	void	true
const_cast	float	protected	this	volatile	while
delete	goto	reinterpret_cast

2. 命名空间

命名冲突问题：（C语言没有很好地解决这个问题）

1、自定义变量、函数与库里的重名冲突

2、团队合作后，与其他人的代码命名冲突

#include <stdio.h>
#include <stdlib.h>

// 定义1个叫bit的命名空间 - 域
// 命名空间中可以定义变量/函数/类型
namespace bit
{
    // 命名空间属于全局变量，放在静态区
    int rand = 0;
    
    int Add(int left, int right)
    {
        return left+right;
    }
    
    struct Node
    {
    	struct Node* next;
    	int val;	
    };
}

int main()
{
    printf("hello world\n");
    printf("%d\n", rand);// 局部 -> 全局 - 若全局也找不到变量，则error
    printf("%d\n", bit::rand);// 到命名空间内寻找变量
	
    // 命名空间的使用
    bit::rand = 10;
    struct bit::Node node;
    bit::Add(1,2);
    
    return 0;
}

• 命名空间起“隔离”的作用，影响编译器查找的规则
• 命名空间中可以定义变量/函数/类型
• 命名空间属于全局变量，放在静态区

2.1 命名空间的定义

命名空间规定了寻找的路径

//1. 普通的命名空间
namespace ly // ly为命名空间的名称
{
    // 命名空间中的内容，既可以定义变量，也可以定义函数
    int a;
    int Add(int left, int right)
    {
        return left + right;
    }
}

int main()
{
    ly::a = 10;
    ly::Add(1, 2);

    return 0;
}

//2. 命名空间可以嵌套
namespace N2
{
    int a;
    int b;
    int Add(int left, int right)
    {
        return left + right;
    }

    namespace N3
    {
        int c;
        int d;
        int Sub(int left, int right)
        {
            return left - right;
        }
    }
}

int main()
{
    N2::Add(1, 2);
    N2::N3::Sub(1, 2);

    return 0;
}

//3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合并到同一个命名空间中。
// "List.h"
namespace ly
{
    struct ListNode
    {
        // ...
    };

    void ListInit();
    void ListPushBack(struct ListNode* phead, int x);
}

// "List.c"
#include "List.h"
namespace ly
{
    void ListInit()
    {
        // ...
    }

    void ListPushBack(struct ListNode* phead, int x)
    {
        // ...
    }
}

// "test.c"
#include "List.h"
int main()
{
	struct ly::ListNode ln;
	ly::ListInit();

	return 0;
}

2.2 命名空间使用

命名空间中成员该如何使用呢？

namespace N
{
     int a = 10;
     int b = 20;
     int Add(int left, int right)
     {
     return left + right;
     }
     int Sub(int left, int right)
     {
     return left - right;
     }
}

• 加命名空间名称及作用域限定符（很好地做到命名隔离，但是使用繁琐，每次使用都要展开）

int main()
{
     printf("%d\n", N::a);
     return 0; 
}

• 使用using将命名空间中某个成员引入（用于展开命名空间中常用的）

using N::b;
int main()
{
     printf("%d\n", N::a);
     printf("%d\n", b);
     return 0; 
}

• 使用using namespace将命名空间中所有成员引入（全部展开到全局，使用方便，但隔离便失效了，慎用）

using namespce N;
int main()
{
     printf("%d\n", N::a);
     printf("%d\n", b);
     Add(10, 20);
     return 0; 
}

3. C++输入&输出

C++库的实现定义在一个叫std的命名空间中

#include <iostream> 
//using namespace std; // 指定命名空间，但此写法不好，全部展开则命名空间失效
// 推荐：将常用的展开
using std::cout;
using std::endl;

int main()
{
    cout << "hello world" << endl;
    return 0;
}

#include <iostream>
using namespace std;// C++库的实现定义在一个叫std的命名空间中

int main()
{
    // << 流插入运算符
    cout << "hello world" << endl;// 理解："hello world"和换行(endl)流向cout
    cout << "hello world\n" ;// 以下等价
    printf("hello world\n");

    int i = 10;
    double d = 1.11;
    // cout可以自动识别类型
    cout << i << " " << d << endl;
    
    // >> 流提取
    cin >> i >> d;// 输入到i，d
    cout << i << " " << d << endl;// 输出
    return 0;
}

#include <iostream>
using namespace std;

struct Student
{
    char name[20];
    int age;
    // ...
};

int main()
{
    struct Student s = { "鹏哥",18 };
    // << 流插入运算符
    // cpp写法示例
    cout << "姓名:" << s.name << endl;
    cout << "年龄:" << s.age << endl << endl;
    
    // c写法示例
    printf("姓名:%s\n年龄:%d\n", s.name, s.age);

    // 流提取运算符
    cin >> s.name >> s.age;
    cout << "姓名:" << s.name << endl;
    cout << "年龄:" << s.age << endl << endl;

    scanf("%s%d", s.name, &s.age);
    printf("姓名:%s\n年龄:%d\n", s.name, s.age);
    return 0;
}

说明：

1. 使用cout标准输出(控制台)和cin标准输入(键盘)时，必须包含**< iostream >头文件以及std标准命名空间**。

   注意：早期标准库将所有功能在全局域中实现，声明在.h后缀的头文件中，使用时只需包含对应头文件即可。后来将其实现在std命名空间下，为了和C头文件区分，也为了正确使用命名空间，规定C++头文件不带.h；旧编译器(vc 6.0)中还支持格式，后续编译器已不支持，因此推荐使用 < iostream >+std的方式。

2. 使用C++输入输出更方便，不需增加数据格式控制，比如：整形–%d，字符–%c

3. 因为有了命名空间的隔离作用，自定义变量名如果与库里的cout等变量名相同便不会产生冲突，因此实际项目中不要轻易展开命名空间。（日常练习展开则无所谓）

4. 缺省参数

4.1 缺省参数概念

缺省参数是声明或定义函数时为函数的参数指定一个默认值。在调用该函数时，如果没有指定实参则采用该默认值，否则使用指定的实参。

#include <iostream>
using namespace std;

void TestFunc(int a = 0)
{
	 cout<<a<<endl;
}
int main()
{
    TestFunc(); // 没有传参时，使用参数的默认值0
    TestFunc(10); // 传参时，使用指定的实参10
}

4.2 缺省参数分类

• 全缺省参数：所有参数都赋缺省值

#include <iostream>
using namespace std;
void TestFunc(int a = 10, int b = 20, int c = 30)
{
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
    cout << "c = " << c << endl;
}

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

• 半缺省参数—缺省部分参数—必须从右往左缺省，且连续缺省

// 1.缺省2个参数
void TestFunc(int a, int b = 20, int c = 30)
{
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
    cout << "c = " << c << endl;
}

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

// 2.缺省1个参数
void TestFunc(int a, int b, int c = 30)
{
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
    cout << "c = " << c << endl;
}

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

注意：

1. 半缺省参数必须从右往左依次来给出，不能间隔着给
2. 缺省参数不能在函数声明和定义中同时出现,推荐写在声明

//a.h
void TestFunc(int a = 10);
// a.c
void TestFunc(int a = 20)
{

}
// 注意：如果声明与定义位置同时出现，恰巧两个位置提供的值不同，那编译器就无法确定到底该用哪个缺省值

3. 缺省值必须是常量或者全局变量

3. C语言不支持（编译器不支持）

4.3 缺省参数的应用

struct Stack
{
    int* a;
    int top;
    int capacity;
};

void StackInit(struct Stack* ps, int capacity = 4) // 缺省参数的应用
{
    ps->a = (int*)malloc(sizeof(int) * capacity);
    ps->top = 0;
    ps->capacity = capacity;
}

void StackPush(struct Stack* ps, int x)
{
    // ...
}

int main()
{
    struct Stack st;
    //StackInit(&st);// 不知道栈最多存多少数据，用缺省值初始化
    StackInit(&st, 100);// 知道栈最多存100数据，显示传值；可以减少增容次数，提高效率
    return 0;
}

5. 函数重载

5.1 函数重载概念

函数重载:是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数 或 参数类型 或 参数顺序)必须不同，常用来处理实现功能类似数据类型不同的问题。

#include <iostream>
using namespace std;

// 1、参数类型不同
int Add(int left, int right)
{
	cout << "int Add(int left, int right)" << endl;

	return left + right;
}

double Add(double left, double right)
{
	cout << "double Add(double left, double right)" << endl;

	return left + right;
}

// 2、参数个数不同
void f()
{
	cout << "f()" << endl;
}

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

// 3、参数顺序不同
void f(int a, char b)
{
	cout << "f(int a,char b)" << endl;
}

void f(char b, int a)
{
	cout << "f(char b, int a)" << endl;
}

int main()
{
	Add(1, 2);
	Add(1.1, 2.2);

	f();
	f(1);

	f(10, 'A');
	f('A', 10);

	return 0;
}

下列情况是否为函数重载？

// 1、缺省值不同，不能构成重载（与参数类型有关，和参数名字无关）
void f(int b)
{
	cout << "f()" << endl;
}

void f(int a = 0)
{
	cout << "f(int a)" << endl;
}

// 2、返回值不同，不能构成重载（调用时不能区分）
sho+rt Add(short left, short right)
{
     return left+right;
}
int Add(short left, short right)
{
     return left+right;
}

// 3、构成重载，但是使用时会有问题 ： f();---调用存在歧义
void f()// 无参
{
	cout << "f()" << endl;
}

void f(int a = 0)// 带参
{
	cout << "f(int a)" << endl;
}

int main()
{
	 f(); // 调用存在歧义
	 f(1);// 可以调用

	return 0;
}

5.2 函数重载原理

C不支持重载 and C++支持重载 的演示

vs根据文件后缀调用相应编译器，.c后缀调用c编译器，.cpp调用C++编译器

Linux不根据文件后缀区分，gcc命令行编译c文件，g++命令行编译C++文件

C不支持重载 and C++支持重载的原因？C++如何支持重载？

程序编译过程：

回顾编译器编译程序的过程：func.h func.c test.c

1. **预处理：**头文件展开、宏替换、条件编译、去掉注释

   生成：func.i test.i

2. **编译：**编译器检查语法，生成汇编代码

   生成：func.s test.s

3. **汇编：**汇编代码转换成二进制机器码

   生成：func.o test.o

4. **链接：**合并func.o test.o

   生成：a.out

Windows环境下main函数调用f();的过程：

C语言不支持函数重载，编译时两个重载函数的函数名相同，在func.o的符号表中存在歧义和冲突；链接时直接使用函数名标识和查找，也将存在冲突

C++支持重载

g++编译器修饰函数名规则：***_Z + 函数名长度 + 函数名 + 参数首字母***

C++的目标文件符号表不用函数名来简单标识和查找函数，引入***函数名修饰规则***（不同编译器有不同修饰规则）

• 通过函数名修饰规则，只要参数不同，func.o符号表里重载的函数就不存在二义性和冲突
• 链接时使用修饰后的函数名进行查找，test.o里的main函数调用两个重载函数时，查找地址也就不存在冲突

解释上图链接过程的地址由来：

1. 如果当前文件有函数的定义，则编译时直接用函数地址（每个.o文件都会生成符号表 ）
2. 如果当前文件只有函数声明，则其定义在其他xxx.cpp中，编译时也就没有地址；需要在链接时到其他对应xxx.o的符号表中根据函数修饰名字寻找，这也是链接的重要工作。

vs环境根据文件后缀调用相应编译器：.c文件使用c编译器，.cpp使用C++编译器

Linux不区分文件后缀，gcc使用c编译器，g++使用C++编译器

附另一Linux环境下调试结果：

1. 实际我们的项目通常是由多个头文件和多个源文件构成，通过C语言阶段学习的编译链接可以知道：【当前a.cpp中调用了b.cpp中定义的Add函数时】，编译后链接前，a.o的目标文件中没有 Add的函数地址，因为Add是在b.cpp中定义的，所以Add的地址在b.o中。那么怎么办呢？
2. 链接阶段就是专门处理这种问题，链接器看到a.o调用Add，但是没有Add的地址，就会到b.o的符号表中找Add的地址，然后链接到一起。
3. 链接时，面对Add函数，链接器会使用哪个名字去找呢？这里每个编译器都有自己的函数名修饰规则。
4. Windows下vs的修饰规则非常复杂，而Linux下gcc的修饰规则简单易懂，下面使用gcc演示修饰后的名字。
5. 下图可以看出gcc的函数修饰后名字不变，而g++的函数修饰后变成【_Z+函数长度+函数名+类型首字母】。

• 采用C语言编译器编译后结果

结论：在linux下，采用gcc编译完成后，函数名字的修饰没有发生改变。

• 采用C++编译器编译后结果

结论：在linux下，采用g++编译完成后，函数名字的修饰发生改变，编译器将函数参数类型信息 添加到修改后的名字中。

• Windows下名字修饰规则

对比Linux会发现，windows下C++编译器对函数名字修饰非常诡异，但道理都是一样的。

通过这里就理解了C语言没办法支持重载，因为同名函数没办法区分。而C++是通过函数修饰规则来区分，只要参数不同，修饰出来的名字就不一样，就支持了重载。

【扩展学习：C/C++函数调用约定和名字修饰规则】

[C++函数重载](C++的函数重载 - 吴秦 - 博客园 (cnblogs.com))

[C/C++的调用约定](C/C++ 函数调用约定_狮子的专栏-优快云博客)

6. 引用

6.1 引用概念

引用不是新定义一个变量，而是给已存在的变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。

类型& 引用变量名(对象名) = 引用实体；

#include <iostream>
using namespace std;
int main()
{
    int a = 10;
    // 引用定义
    // 注意：引用类型必须和引用实体是同种类型的
    int& b = a;

    // 取地址
    int* p = &b;

    return 0;
}

引用在语法层，理解为并未开辟新空间，只是对原有的变量取了一个新名称

6.2 引用特性

1. 引用在定义时必须初始化
2. 一个变量可以有多个引用
3. 引用一旦引用一个实体，再不能引用其他实体

int main()
{
    // 1.引用在定义时必须初始化
    int a = 10;
    int& b; // 该条语句编译时会出错

    // 2.一个变量可以有多个引用
    int a = 10;
    int& b = a;
    int& c = a;
    int& d = b;

    // 3. 引用一旦引用一个实体，再不能引用其他实体
    int a = 10;
    int& b = a;

    int c = 20;
    b = c;
          // 可能存在2种含义：
          // 1、将b作为c的别名？否
          // 2、把c赋值给b？是

    int* p1 = &a;
    p1 = &c;// 相比之下，指针指向会发生变化
    return 0;
}

6.3 使用场景

1. 做参数

// 传址 _Z4swappipi
void Swap(int* p1, int* p2)
{
    int tmp = *p1;
    *p1 = *p2;
    *p2 = tmp;
}

// 传引用 _Z4swapriri
void Swap(int& r1, int& r2)
{
    int tmp = r1;
    r1 = r2;
    r2 = tmp;
}

// 传值 _Z4swapii
void Swap(int r1, int r2)
{
    int tmp = r1;
    r1 = r2;
    r2 = tmp;
}

// 3个构成重载
// 但Swap(x,y)调用时存在歧义，究竟调用传值还是传引用
// 类似之前所讲：以下2个构成重载，但调用存在歧义
// void f();
// void f(int x = 0, int y = 0);

int main()
{
    int x = 0, y = 1;
    Swap(&x, &y);
    Swap(x, y);

    return 0;
}

int main()
{
    int a = 10;
    int& b = a;

    int* p1 = &a;
    int*& p2 = p1;

    return 0;
}

在引用的用法之前，传二级指针

引用的实例：传一级指针的别名

phead（形参）是plist（实参）的别名，phead的改变就是改变plist

SLTNode* 还可以在typedef时取新的名字

引用做参数的实例还有2个：（视频 11-28-C++基础续50‘）

• 剑指Offer 56 数组中数字出现的次数 输出型参数
• 清华大学 二叉树遍历

2. 做返回值

以下先看函数栈帧中所讲过的传值返回：

所有的传值返回都会生成一个拷贝

• c不做返回值：

  因为Add函数执行完时，函数栈帧销毁；c的值拷贝在临时变量内作为返回值

• 临时变量存在哪？

  1、c如果比较小（4/8byte），一般是寄存器充当临时变量

  2、c如果比较大，临时变量放在调用Add函数的栈帧中

传引用返回：

当前代码的问题：

1、存在非法访问，因为Add(1,2)的返回值是c的引用，所以Add栈帧销毁以后，会去访问c位置空间

2、如果Add函数栈帧销毁，清理空间，那么取到的c值是随机值，ret也就是随机值（ps：是否清理空间数据取决于编译器，vs环境下销毁栈帧不清理）

3、物理上不存在tmp的空间，tmp相当于c的别名

以上代码暂不报错

但是下面代码有错误生成：

栈帧的使用：

调用完销毁；如果还有新的调用，可以使用已经销毁的栈帧空间

下图说明：如果新调用的函数栈帧空间覆盖了原有空间，将影响原先的c（ret）值

比喻：对内存的使用就像“租房子”一样，可重复使用

因此，慎用引用返回！

传值返回和传引用返回的区别：

以下举例说明：如果函数返回时，出了函数作用域，如果返回对象（属于静态变量、全局变量）还未还给系统，则可以使用引用返回；如果已经还给系统了，则必须使用传值返回。

// 传引用返回
int& Count()
{
 static int n = 0；
 n++;
 // ...
 return n;
}

// 传引用返回示例2
int& f()
{
    int* p = (int*)malloc(4);
    return *p;// 注意返回的是指针指向的空间
}

// 传值返回
int Add(int a, int b)
{
    int c = a + b;
    return c;
}

6.4 传值、传引用效率比较

以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低。

#include <time.h>
struct A { int a[10000]; };
void TestFunc1(A a) {}
void TestFunc2(A& a) {}
void TestRefAndValue()
{
    A a;
    // 以值作为函数参数
    size_t begin1 = clock();
    for (size_t i = 0; i < 10000; ++i)
        TestFunc1(a);
    size_t end1 = clock();
    // 以引用作为函数参数
    size_t begin2 = clock();
    for (size_t i = 0; i < 10000; ++i)
        TestFunc2(a);
    size_t end2 = clock();
    // 分别计算两个函数运行结束后的时间
    cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
    cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
}

int main()
{
    TestRefAndValue();
    return 0;
}

#include <time.h>
struct A{ int a[10000]; };
A a;
// 值返回---每次拷贝40000byte
A TestFunc1() { return a;}
// 引用返回---无拷贝
A& TestFunc2(){ return a;}
void TestReturnByRefOrValue()
{
 // 以值作为函数的返回值类型
 size_t begin1 = clock();
 for (size_t i = 0; i < 100000; ++i)
 TestFunc1();
 size_t end1 = clock();
 // 以引用作为函数的返回值类型
 size_t begin2 = clock();
 for (size_t i = 0; i < 100000; ++i)
 TestFunc2();
 size_t end2 = clock();
 // 计算两个函数运算完成之后的时间
 cout << "TestFunc1 time:" << end1 - begin1 << endl;
 cout << "TestFunc2 time:" << end2 - begin2 << endl;
}

通过上述代码的比较，发现传值和指针在作为传参以及返回值类型上效率相差很大。

**总结：**引用的作用主要体现在传参和传返回值

1、引用传参和传返回值，有些场景下面可以提高性能。（大对象+深拷贝对象）

2、引用传参和传返回值，输出型参数和输出型返回值。通俗地说，引用传参，有些场景下，形参的改变可以改变实参；引用传返回值，有些场景下，引用返回可以修改返回对象。

以下是修改返回对象示例：

const int N = 10;

int& At(int i)
{
    static int a[10];
    return a[i];
}

int main()
{
    for (size_t i = 0; i < N; ++i)
    {
        At(i) = 10 + i;
    }

    for (size_t i = 0; i < N; ++i)
    {
        cout << At(i) << " ";
    }
    cout << endl;

    return 0;
}

右值：表达式产生的临时变量、常量

右值不可以修改

*后续有学

6.5 常引用

int main()
{
	// 权限放大
    const int a = 10;// 权限只读
    int& b = a;// 权限可读可写，编译将报错
    
    // 权限不变 可以
    const int a = 10;
    const int& b = a;
    
    // 权限缩小 可以
    int c = 10;
    const int& d =c;
    
    double d = 11.11;
    int i1 = d;// 发生隐式类型转换
    int& i2 = d;// error
    const int& i3 = d;// 类型转换会产生临时变量，引用的是带常性的变量，必须带const修饰
    
	return 0;
}

再举一例说明const常引用：

int x1 = 1,x2 = 2;
const int& ret = x1 + x2;// x1+x2的值是临时变量（右值），引用时加const

假设x是一个大对象或者后面学习的深拷贝对象

使用引用传参，如果函数中不改变参数值x，尽量用const引用传参，同时也能减少拷贝

const Type & 可以接收各种类型的对象

// 常引用示例：
void f(const int& x)
//void f(int& x) // 不加const将报错，权限不对应
{
    cout << x << endl;
}

int main()
{
	// 权限放大
    const int a = 10;// 权限只读
    int& b = a;// 权限可读可写，编译将报错
    
    // 权限不变 可以
    const int a = 10;
    const int& b = a;
    
    // 权限缩小 可以
    int c = 10;
    const int& d =c;
    
    f(a);
    f(c);
    
	return 0;
}

6.6 指针和引用的区别

引用和指针的不同点:

1. 引用概念上定义一个变量的别名，指针存储一个变量地址

2. 引用在定义时必须初始化，指针最好初始化，但不初始化也不会报错

3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型 实体

4. 没有NULL引用，但有NULL指针

5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占 4个字节)

6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小

7. 有多级指针，但是没有多级引用

8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理

9. 引用比指针使用起来相对更安全，指针要考虑空指针、野指针等问题

   

**总结：**指针相比引用，使用更复杂，更容易出错。面试经常考察两者区别，理解记忆。

了解一下即可，使用时不去考虑底层汇编实现

语法层：

指针和引用是完全不同的概念

指针是开空间，存储变量地址

引用不开空间，仅仅是对变量取别名

底层汇编实现时：

引用是用指针实现的

下图说明：sizeof(引用变量)的大小是变量的大小

7. extern “C”

C++项目中调用由C实现的静态库

• 包含头文件
• C++项目工程属性中配置静态库的目录和添加静态库

链接需要注意添加静态库目录：Debug目录下是.lib文件

添加静态库

此时链接仍会报错，因为静态库内C语言的函数修饰规则和调用时C++的函数修饰规则不一样。

extern "C"的作用是告诉C++编译器括号内的函数由C编译器编译，链接时用C的函数名规则寻找

C项目中调用由C++实现的静态库

写法一：

C++程序预定义了标识符__cplusplus

C++程序内展开extern “C”，此时函数不再支持函数重载

写法二：

C++程序内展开extern “C”，C程序内宏替换为空

总结：

C++程序调用C的库，在C++程序中加extern “C”

C程序调用C++的库，在C++库中加extern “C”

8. 内联函数

调用函数需要建立栈帧，栈帧中要保存一些寄存器，结束时再恢复…

像以下频繁调用函数对内存有一定消耗。

int Add(int x, int y)
{
    int ret = x + y;
    return ret;
}

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

C语言提供了“宏”进行优化

#define ADD(x, y) ((x) + (y))// 宏的原理是替换

int main()
{
    cout << ADD(1, 2) << endl;
    int a = 0, b = 1;
    cout << ADD(a | b, a & b) << endl;
}

8.1 概念

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

以下是普通函数调用，需要建立栈帧

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

查看方式：

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

inline int Add(int x, int y)
{
    int ret = x + y;
    return ret;
}

int main()
{
    int ret = Add(1, 2);
    cout << ret << endl;
    return 0;
}

8.2 特性

1. inline是一种以空间换时间的做法，省去调用函数额开销。所以代码很长（10行以上）或者有循环/递归的函数不适宜使用作为内联函数。

   

2. inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归等，编译器优化时会忽略掉内联。

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

   // F.h
   inline void f(int i);
   
   // F.cpp
   #include <iostream>
   using namespace std;
   #include "F.h"
   
   void f(int i)
   {
    cout << i << endl;
   }
   
   // main.cpp
   #include "F.h"
   int main()
   {
    f(10);
    return 0;
   }
   // 链接错误：main.obj : error LNK2019: 无法解析的外部符号 "void __cdecl f(int)" (?f@@YAXH@Z)，该符号在函数 _main 中被引用
   

   f.cpp->f.o时，符号表中不会生成f函数的地址，因为inline函数不需要地址，都在调用的地方展开了

**结论：**短小、频繁使调用的函数建议定义成inline

9. auto关键字(C++11)

9.1 auto简介

在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量。

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

int main()
{
    int a = 0;
    auto b = a;// 自动推导b的类型 - int
    auto c = 'A';// 自动推导c的类型 - char
    auto d = 10.11;// 自动推导b的类型 - double

    // auto省略了const属性
    
    // typeid打印变量的类型
    cout << typeid(b).name() << endl;
    cout << typeid(c).name() << endl;
    cout << typeid(d).name() << endl;
    return 0;
}

#include <iostream>
#include <map>
#include <string>

int main()
{
    // 实际中auto的使用场景
    std::map<std::string, std::string> dict = { {"sotr","排序"},{"insert","插入"} };
    //std::map<std::string, std::string>::iterator it = dict.begin();
    auto it = dict.begin();// 相比上一行写法，auto根据右边的值自动推导it的类型，更简略

    return 0;
}

【注意】

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

9.2 auto的使用细则

1. auto与指针和引用结合起来使用

   用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&

int main()
{
    int x = 10;
    auto a = &x;// 取地址，int*
    auto* b = &x;// 仍是int*
    auto& c = x;// c是x的引用，类型：int

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

    *a = 20;
    *b = 30;
    c = 40;

    return 0;
}

2. 在同一行定义多个变量

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

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

9.3 auto不能推导的场景

1. auto不能作为函数的参数

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

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表达式等进行配合使用。

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

10.1 范围for的语法

对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此C++11中 引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量， 第二部分则表示被迭代的范围。

**注意：**与普通循环类似，可以用continue来结束本次循环，也可以用break来跳出整个循环。

int main()
{
    int array[] = { 1,2,3,4,5 };
    // C/C++遍历数组
    for (int i = 0; i < sizeof(array) / sizeof(int); ++i)
    {
        cout << array[i] << endl;
    }

    // C++11 范围for
    // 自动依次取数组array中的每个元素赋值给x
    //for (int x : array)
    for (auto x : array)
    {
        cout << x << endl;
    }

    // 范围for 把数组中每个值+1
    // e的生命周期只在单词循环内，而不是整个循环过程
    for (auto& e : array)
    {
        e++;
    }

    for (auto e : array)
    {
        cout << e << endl;
    }
    return 0;
}

10.2 范围for的使用条件

void TeatFor(int a[])
{
    // 范围for必须是数组名,数组传参却变成了int*
    for (auto& e : a)
    {
        cout << e << endl;
    }
}

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

11. 指针空值nullptr(C++11)

11.1 C++98中指针空值的定义

在良好的C/C++编程习惯中，声明一个变量时最好给该变量一个合适的初始值，否则可能会出现不可预料的错误，比如未初始化的指针。如果一个指针没有合法的指向，我们基本都是按照如下方式对其进行初始化：

int main()
{
    // C++98/03
    int* p1 = NULL;
    int* p2 = 0;

    //C++11，初始化空指针推荐用法
    int* p3 = nullptr;

    return 0;
}

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()
{
    f(0);
    f(NULL);
    f((int*)NULL);
    f(nullptr);// C++11
    return 0;
}

程序本意是想通过f(NULL)调用指针版本的f(int)函数，但是由于NULL被定义成0，因此与程序的初衷相悖。 在C++98中，字面常量0既可以是一个整形数字，也可以是无类型的指针(void)常量，但是编译器默认情况下 将其看成是一个整形常量，如果要将其按照指针方式来使用，必须对其进行强转(void*)0。

注意：

1. 在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的。
2. 在C++11中，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同。
3. 为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr。