目录
面试题1. C语言为什么不支持重载？C++支持？C++底层是如何支持重载的？
1. C++关键字(C++98)
C++总计63个关键字，C语言32个关键字
2. 命名空间
在C/C++中，变量、函数和类都是大量存在的，这些变量、函数和类的名称将都存在于全局作用域中，可能会导致冲突。使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字 污染，namespace关键字的出现就是针对这种问题的。
2.1 命名空间定义
C语言中命名冲突问题：
//namespace 定义的是一个域
//用于解决C语言命名冲突问题
//eg:命名冲突
//C语言的库中，有两个函数用scanf和strlen名称
//假设代码里，想用这两个名称命名变量，就会产生冲突
int main()
{
//定义到局部不会报错，但用的时候会报错(定义到全局不用也会报错)
int scanf = 10;
int strlen = 20;
//以下均会报错,且C语言解决不了冲突的问题
scanf("%d", &scanf);
printf("%d\n", scanf);
printf("%d\n", strlen);
return 0;
}定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{}中即为命名空间的成员。
//使用C++命名空间，进行名字的隔离
//1. 普通的命名空间
namespace N1 // N1为命名空间的名称
{
//命名空间中的内容，既可以定义变量，也可以定义函数
int scanf = 10;
int strlen = 20;
int Add(int left, int right)
{
return left + right;
}
}
//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;
}
}
}
//3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。
//注意：同一个域里不能定义同名的变量或函数
namespace N1
{
int Mul(int left, int right)
{
return left * right;
}
}
int main()
{
//默认访问局部其次是全局
//由于局部没有，访问全局的头文件,所以此时打印的是库函数的地址
printf("%x\n", scanf); //411433
printf("%x\n", strlen); //4113d4
//指定访问N1命名空间
printf("%x\n", N1::scanf); //a
printf("%x\n", N1::strlen); //14
//指定命名空间后，才能调用N1里的函数
int a = N1::Add(1, 2);
printf("%d\n", a); //3
//访问嵌套命名空间的内容
int b = N2::N3::Sub(5, 3);
printf("%d\n", b); //2
return 0;
}注：一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中
2.2 命名空间的使用
C++库为了防止命名冲突，把自己库里的东西都定义在std的命名空间中，要使用标准库中的东西，有三种方式
① 加命名空间名称及作用域限定符
指定命名空间，缺陷: 麻烦，每个地方要用都要制定，但是这是最规范的使用方式
② 使用using namespace 命名空间名称引入
把std整个展开:using namespace std ,相当于库里的东西都到全局域了 ，缺陷: 如果自己定义的和库的冲突了就无法解决了，所以规范的工程项目中是不推荐这种方式的，日常练习无所谓
③ 使用using将命名空间中成员引入
对部分常用的库里面的东西展开，是针对1和2折中的方案，在项目中经常使用
//C++库为了防止命名冲突，把自己库里的东西都定义在了一个std的命名空间中
//要使用标准库中的东西，有三种方式
//1. 指定命名空间
// -> 缺陷: 麻烦，每个地方要用都要制定，但是这是最规范的使用方式
//2. 把std整个展开:using namespace std ,相当于库里的东西都到全局域了
// ->缺陷: 如果自己定义的和库冲突了就无法解决了
// 所以规范的工程项目中是不推荐这种方式的，日常练习无所谓
//3. 对部分常用的库里面的东西展开，是针对1和2折中的方案，在项目中经常使用
using std::cout;
using std::endl;
//using namespace std;
int main()
{
//1. 指定命名空间
std::cout << "hello world" << std::endl;
// 2.把std整个展开,上面写了using namespace std;下面直接用即可
cout << "hello world" << endl;
// 3.对部分常用的库里面的东西展开
cout << "hello world" << endl;
std::string s; //没展开的就不能直接使用
return 0;
}3. C++输入&输出
#include<iostream>
//cout 是ostream类型全局对象
//cin 是istream类型全局对象
//endl 是全局的换行符号
int main()
{
std::cout << "hello world!" << std::endl;
//对比C语言printf和scanf区别是：
//可以自动识别类型
int a = 10;
int* p = &a;
//c语言打印
printf("%d,%p\n", a, p);
//c++打印
std::cout << a << "," << p << std::endl;
return 0;
}说明：
1. 使用cout标准输出(控制台)和cin标准输入(键盘)时，必须包含< iostream >头文件以及std标准命名空间。
注意：早期标准库将所有功能在全局域中实现，声明在.h后缀的头文件中，使用时只需包含对应头文件即可，后来将其实现在std命名空间下，为了和C头文件区分，也为了正确使用命名空间，规定C++头文件不带.h；旧编译器(vc 6.0)中还支持格式，后续编译器已不支持，因此推荐使用 +std的方式。
2. 使用C++输入输出更方便，不需增加数据格式控制，比如：整形--%d，字符--%c
4. 缺省参数
4.1 缺省参数概念
缺省参数是声明或定义函数时为函数的参数指定一个默认值。在调用该函数时，如果没有指定实参则采用该默认值，否则使用指定的实参。缺省参数可以使调用更灵活。
//缺省参数
void TestFunc(int a = 0)
{
cout << a << endl;
}
int main()
{
TestFunc(); // 0,没有传参时，使用参数的默认值
TestFunc(10); // 10,传参时，使用指定的实参
return 0;
}
4.2 缺省参数分类
① 全缺省参数
//全缺省
void TestFunc(int a = 10, int b = 20, int c = 30)
{
cout << "a = " << a << endl;
cout << "b = " << b << endl;
cout << "c = " << c << endl;
}② 半缺省参数
//半缺省
void TestFunc(int a, int b = 10, int c = 20)
{
cout << "a = " << a << endl;
cout << "b = " << b << endl;
cout << "c = " << c << endl;
}注意：
1. 半缺省参数必须从右往左依次来给出，并且连续，不能间隔着给
2. 缺省参数不能在函数声明和定义中同时出现
3. 缺省值必须是常量或者全局变量
4. C语言不支持（编译器不支持）
5. 函数重载
5.1 函数重载概念
函数重载 : 是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数 或 类型 或 顺序)必须不同，常用来处理实现功能类似数据类型不同的问题
//C语言不允许定义同名函数
//C++可以 -> 函数重载 -> 参数(类型或个数或顺序)不同
int Add(int left, int right)
{
return left + right;
}
double Add(double left, double right)
{
return left + right;
}
int main()
{
cout << Add(1, 2) << endl; //3
cout << Add(1.1, 2.2) << endl; //3.3
return 0;
}下面两个函数属于函数重载吗？
short Add(short left, short right)
{
return left + right;
}
int Add(int left, short right)
{
return left + right;
}答：不算，判断时，不看返回类型，只看函数名是否相同，参数个数或类型是否不同
面试题1. C语言为什么不支持重载？C++支持？C++底层是如何支持重载的？
答：通过函数名修饰规则搞定，待补充
面试题2. extern "C"的作用是什么？
答：待补充
5.2 名字修饰(name Mangling)
6. 引用
6.1 引用概念
引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。
int main()
{
int a = 10;
//b是a的引用(别名)
//注意区分引用和取地址，引用是类型后&变量，取地址是直接&变量
int& b = a;
b = 20;
//继续取别名
int& c = b;
c = 30;
return 0;
}注意：引用类型必须和引用实体是同种类型的
//引用的价值
//用别名就可以不用传地址进行交换
void swap(int& r1, int& r2)
{
int tmp = r1;
r1 = r2;
r2 = tmp;
}
void StackInit(struct Stack& s)
{
//...
}
int main()
{
int a = 1, b = 2;
swap(a, b); //c语言需要传地址
struct Stack st;
StackInit(st);
return 0;
}6.2 引用特性
1. 引用在定义时必须初始化
2. 一个变量可以有多个别名
3. 一旦引用一个实体，就不能引用其他实体
6.3 常引用
//权限可以缩小，但不能放大
int main()
{
const int a = 10;//用const修饰后，a只能读不能写
//int& ra = a;//报错，ra引用a属于权限放大(可读可写)
const int& ra = a; //正确代码
int b = 10;
int& rb = b;
const int& crb = b;//正确，ceb引用b属于权限的缩小，所以可以
int c = 10;
double d = 1.11;
d = c; //隐式类型转换，将int类型的c放到一个double类型的临时变量中，再赋值给d
//double& rc = c; //报错，报错原因并不是因为类型不同
const double& rc = c; //*正确代码，此时rc是c临时变量的别名，临时变量具有常性，所以加const就可以
return 0;
}6.4 使用场景
1. 做参数
void Swap(int& left, int& right)
{
int temp = left;
left = right;
right = temp;
}2. 做返回值(特殊场景)
传值返回 返回的是返回对象c的拷贝
//int Add(int a, int b)
//{
// int c = a + b;
// return c;
//}
//int main()
//{
// //int& ret = Add(1, 2); //报错，因为ret接收的是储存c的值的临时变量(不是c)，具有常性，需在前加上const
// const int& ret = Add(1, 2);
//
// return 0;
//}
//传引用返回 返回的是对象c的引用，其实就是c
//实际中，如果出了函数作用域，返回变量就不存在了，不能用引用返回;出了作用域还在:例如用static修饰
int& Add(int a, int b)
{
static int c = a + b;
return c;
}
int main()
{
int& ret = Add(1, 2);
cout << ret << endl; //3
return 0;
}注意：如果函数返回时，出了函数作用域，如果返回对象还未还给系统，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回。
下面代码输出什么结果？为什么？
int& Add(int a, int b)
{
int c = a + b;
return c;
}
int main()
{
int& ret = Add(1, 2);
Add(3, 4);
cout << "Add(1, 2) is :" << ret << endl; //7
return 0;
}6.5 传值、传引用效率比较
以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低，相反使用引用传参效率更高。
6.5.1 值和引用的作为传参的性能比较
#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; //11
cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl; //1
}
int main()
{
TestRefAndValue();
return 0;
}6.5.2 值和引用的作为返回值类型的性能比较
#include <time.h>
struct A { int a[10000]; };
A a;
// 值返回
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; //254
cout << "TestFunc2 time:" << end2 - begin2 << endl; //2
}
int main()
{
TestReturnByRefOrValue();
return 0;
}通过上述代码的比较，发现传值和指针在作为传参以及返回值类型上效率相差很大。只要符合条件，尽量使用引用传参、传返回值。
6.6 引用和指针的区别
在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。
int main()
{
int a = 10;
int& ra = a;
cout << "&a = " << &a << endl; //00B5FD7C
cout << "&ra = " << &ra << endl; //00B5FD7C
return 0;
}在底层实现角度，引用的底层也是类似指针存储地址的方式处理的，下面说的是语法角度。
int main()
{
int a = 10;
//在语法上，给a的这块空间取了个别名，没有新开空间
int& ra = a;
ra = 20;
//在语法上，定义了一个pa指针变量,开辟了4个字节，存储a的地址
int* pa = &a;
*pa = 20;
return 0;
}面试题*：引用和指针的不同点:
1. 在语法上，引用概念上定义一个变量的别名，指针存储一个变量地址
2. 引用在定义时必须初始化，指针没有要求
3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
4. 没有NULL引用，但有NULL指针
5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)
6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
7. 有多级指针，但是没有多级引用
8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理
9. 引用比指针使用起来相对更安全
7. 内联函数
7.1 概念
以 inline 修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数压栈的开销， 内联函数提升程序运行的效率。
以交换函数为例：调用Swap函数需要建立栈帧，建立栈帧是有代价的，C语言为了避免小函数建立栈帧，提供了宏函数支持，预处理阶段展开，那么C语言都已经解决了，为什么C++还要提供inline函数呢？(面试题：宏函数的缺点)
7.1.1 面试题：宏的优缺点
优点： 1.增强代码的复用性。 2.提高性能。
缺点： 1.不支持调试。（因为预编译阶段进行了替换） ，导致代码可读性差，可维护性差，容易误用。 2. 宏函数语法复杂，容易出错 3.没有类型安全的检查 。
写一个ADD的宏函数
//ADD的宏函数
//#define ADD(int x, int y) return x+y //典型错误写法
//#define ADD(x, y) (x)+(y); //典型错误写法,加了分号
//标准写法
#define ADD(x, y) ((x) + (y))C++有哪些技术替代宏？
1. 常量定义 换用const
2. 换用内联函数
//C++推荐将频繁调用的小函数，定义成inline(内联)，会在调用的地方展开。没有栈帧的开销
inline int Add(int x, int y)
{
return x + y;
}
int main()
{
int c = Add(1, 2);
cout << c << endl;
return 0;
}7.2 特性
1. inline是一种以空间换时间的做法，省去调用函数额开销。所以代码很长或者有循环/递归的函数不适宜使用作为内联函数。
2. inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归等等，编译器优化时会忽略掉内联。
3. inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。
// F.h
#include <iostream>
using namespace std;
inline void f(int i);
// F.cpp
#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 中被引用假设Sort()函数有100行指令，在10个地方调用，总计110条指令，但如果用inline修饰后，10个地方调用，展开后则变成1000条指令
当指令变多意味着什么？
答案：意味着编译出的可执行程序变大，导致安装软件的人体验变差，执行程序内存消耗变多。(指令的多少与效率高低无关，如果直接调用Sort会建立栈帧，效率反而低于直接执行1000条指令的inline Sort)
结论：频繁调用的小函数，建议定义成内联函数
8. auto关键字(C++11)
#include <map>
#include <string>
//以下语法,当前了解即可
//auto
int main()
{
int a = 10;
//int b = a;
auto b = a; //类型声明成auto，可以根据a的类型自动推导b的类型为int
map<string, string> m;
//map<string, string>::iterator it = m.begin();
//这里可以根据m.begin()自动推导到it的类型是map<string, string>::iterator
//这样写比较简洁
auto it = m.begin();
return 0;
}8.1 auto的使用细则
1. auto与指针和引用结合起来使用
用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&
2. 在同一行定义多个变量
当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。
void TestAuto()
{
auto a = 1, b = 2;
auto c = 3, d = 4.0; // 该行代码会编译失败，因为c和d的初始化表达式类型不同
}8.2 auto不能推导的场景
1. auto不能作为函数的参数
2. auto不能直接用来声明数组
3. auto在实际中最常见的优势用法就是与C++11提供的新式for循环，还有lambda表达式等进行配合使用
9. 基于范围的for循环(C++11)
9.1 范围for的语法
int main()
{
int array[] = { 1, 2, 3, 4, 5 };
//以前遍历数组的方式
for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
cout << array[i] << " ";
cout << endl;
// 1 2 3 4 5
//范围for，更简单，数组也可以直接遍历
//自动遍历，以此取出array中的元素，赋值给e，直到结束
for (auto e : array)
{
cout << e << " ";
}
cout << endl;
//1 2 3 4 5
//以上是"读"的操作，"写"的操作需要注意加引用符号
for (auto& ee : array) //ee是数组元素的临时拷贝，要想修改数组需要加引用符号
{
ee *= 2;
}
return 0;
}9.2 范围for的使用条件
1. for循环迭代的范围必须是确定的
对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供begin和end的方法，begin和end就是for循环迭代的范围。
注意：以下代码就有问题，因为for的范围不确定
void TestFor(int array[])
{
for (auto& e : array)
cout << e << endl;
}
//因为此处array作为形参是一个指针，而非数组了2. 迭代的对象要实现++和==的操作(之后再谈)
10. 指针空值nullptr(C++11)
//C++11
int main()
{
//以前使用的
int* p1 = NULL; //等价于 int* p1 = 0;
//C++推荐使用的
int* p2 = nullptr;
return 0;
}NULL实际是一个宏，NULL可能被定义为字面常量0，或者被定义为无类型指针(void*)的常量。不论采取何种定义，在 使用空值的指针时，都不可避免的会遇到一些麻烦，比如：
void f(int i)
{
cout << "f(int)" << endl;
}
void f(int* p)
{
cout << "f(int*)" << endl;
}
int main()
{
f(0); //期望匹配整形参数的f，结果:f(int)
f(NULL); //期望匹配指针参数的f，结果:f(int),因为NULL被替换成0了
f((int*)NULL);//f(int*)
f(nullptr); //f(int*)
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。
297
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
