C++入门——下卷（函数重载+内联函数详解）

C++入门——下卷

• 函数重载
• • • 1，什么是函数重载？
    • 2，程序的编译链接的过程及C++为何支持重载(详细！！）
    • 3，C++如何支持C，C如何支持C++
• 内联函数
• • • 1,面试题
    • 2,什么是内联函数==详解!==
• auto
• 指针空值nullptr(C++11)

函数重载

1，什么是函数重载？

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

例如：
如果有两个函数是这样的
int Add(int x,int y){}
long Add(int x,int y){};
那么此时编译器便会报错，因为此时函数的参数种类，数目以及排列顺序都是一样的，那么即使返回值不同，调用Add函数的时候编译器是不知道调用哪个函数的，所以会报错.

2，程序的编译链接的过程及C++为何支持重载(详细！！）

我写的这个编译链接过程是大致的，只是为了帮助理解函数重载

3，C++如何支持C，C如何支持C++

我们必须先理解一个道理：语言这种东西一定是向前兼容的。
旧的语言被创造出来，我们已经用它写了很多程序项目什么的，我们如果想让旧语言和新语言兼容的话，那么一定是在新的语言上改动——也就是不管是C++支持C还是C支持C++，都是在C++的程序中做改变。
C++支持C
用的是c语言的库或者函数，但是写的是c++的代码
在C++的程序中只在C语言的库或者函数前加extern “C”，意思是告诉编译器，
将该库按照C语言规则来编译。

C支持C++
在C程序和C++程序中分别加一个条件编译：

重点理解函数在符号表中的命名规则即可！

内联函数

1,面试题

如果C语言中要实现频繁调用一个void Add(int x,int y){int c = x+y;return c;}
那么C语言是如何实现的？
答：
是“宏”
那么宏的优缺点是什么？
答：
优点：
1.增强代码的复用性。
2.提高性能。
缺点：
1.不方便调试宏。（因为预编译阶段进行了替换）
解释
由于宏是预编译程序来处理，其替换的函数不会进入到符号表中，所以在运行时，不会带来额外的时间和空间开销，而函数会在运行时执行压栈出栈的操作，存在函数调用的开销。所以宏是不可以调试的，而函数可以进行单步调试。
2.导致代码可读性差，可维护性差，容易误用。
3.没有类型安全的检查
解释一下：
假设我们现在要求写出上述Add函数的宏
会发现也许会出现如下几种错误情况：

#define ADD(int x, int y) return x + y;
#define ADD(x, y) return x + y;
#define ADD(x, y) (x + y);
#define ADD(x, y) x + y

这都是错误的。
正确的应该是这样的#define ADD(x,y)((x)+(y))
可以看出即使是一个很强的大佬，那么也无法很顺畅的写出有关函数的宏，正是因为宏的晦涩难懂，同时也不支持调试，所以C++引入了内联函数

2,什么是内联函数详解!

以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数压栈的开销，内联函数提升程序运行的效率。不用像宏那样还要各种设置，直接在函数前面加一个inline

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

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

}
int main()
{
	int a1 = Add(2, 3);
	int a2 = Add(3, 3);
	int a3 = Add(4, 3);
	cout << a1 << endl;
	cout << a2 << endl;
	cout << a3 << endl;
 	return 0;
}

特点

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

2. inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归等等，编译器优化时会忽略掉内联。
   根基上述特点1，2稍微解释一下：
   假设我们有一个函数，代码一共有20行，并且我们需要调用1000次，如果是用inline替换的话， 这个时候函数空间的使用就是20*1000但是这个时候如果是函数调用的话使用的空间就是1000+20，因为调用的函数都是同一个地址，只需要每次call一次就可以了，所以这个时候编译器会选择直接忽视inline函数然后直接函数调用，这个时候也是可以调试的，inline起作用的时候也是不能调试的

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

   inline int Add(int x, int y)
   {
   int c = x + y;
   c += 1;
   c += 1;
   c += 1;
   c += 1;
   c += 1;
   c += 1;
   c += 1;
   c += 1;
   c += 1;
   c += 1;
   c += 1;
   return c;

   }
   int main()
   {
   int a1 = Add(2, 3);
   int a2 = Add(3, 3);
   int a3 = Add(4, 3);
   cout << a1 << endl;
   cout << a2 << endl;
   cout << a3 << endl;
   return 0;
   }

这个时候转到反汇编会发现，直接就是call，他们就不会被展开了，这样验证了，inline是根据编译器自主来的，不是认为能决定的。

auto

C++11中，标准委员会赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。
eg; int a = 10;
auto b = a;此时的b的类型就是int
auto c = 'a’此时c的类型就是char是由编译器自动推导的
所以这也决定了：使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto的实际类型。因此auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译期会将auto替换为变量实际的类型。
auto的使用细则
1，1. auto与指针和引用结合起来使用用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&
2. 在同一行定义多个变量
当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。
eg：auto a = 1,b = 2.7;会出先编译错误,因为a和b的初始化表达式类型不同
auto不能推导的场景
1,auto不能作为函数的参数
2. auto不能直接用来声明数组
auto还有一个大杀器，就是auto可以用于for循环。

注意：for循环迭代的范围必须是确定的
对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供begin和end的
方法，begin和end就是for循环迭代的范围。
auto用于迭代器才是真的爽，可惜现在还没学到，后续会更新啦hh

指针空值nullptr(C++11)

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

#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif

可以看到，NULL可能被定义为字面常量0，或者被定义为无类型指针(void*)的常量。不论采取何种定义，在使用空值的指针时，都不可避免的会遇到一些麻烦，比如

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

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