【C++】——入门基础（万字总结！！！
目录
-
- C++关键字
- C++命名空间
- C++输入和输出
- 缺省参数
- 函数重载
- 引用
- 内联函数
- auto关键字(C++11)
- 基于范围的for循环(C++11)
- 指针空值nullptr(C++11)
C++关键字
C++命名空间
在C/C++中，变量、函数和后面要学到的类都是大量存在的，这些变量、函数和类的名称将都存在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的。
示例代码：
#include 会报出如下错误：
更改代码：
#include 域作用限定符::
#include 命名空间的定义：
定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{} 中即为命名空间的成员。
1、 命名空间中可以定义变量/函数/类型
namespace std
{
// 命名空间中可以定义变量/函数/类型
int rand = 10;
int Add(int left, int right)
{
return left + right;
}
struct Node
{
struct Node* next;
int val;
};
}
int main()
{
printf("%d\n", std::rand);
printf("%d\n", std::Add(1, 2));
struct std:: Node node;
}
打印命名空间的变量时，必须要使用域作用限定符修饰，否则默认认为是访问全局变量，会报错
2、命名空间全部展开（授权）：可能会导致命名空间内定义的变量或函数等与全局范围内的变量或函数冲突，不建议
namespace std
{
// 命名空间中可以定义变量/函数/类型
int rand = 10;
int Add(int left, int right)
{
return left + right;
}
struct Node
{
struct Node* next;
int val;
};
}
using namespace std;//命名空间全部展开（授权）
int main()
{
printf("%d\n", std::rand);
printf("%d\n", Add(1, 2));
struct std::Node node;
}
3、命名空间部分展开（授权）：如果还会导致冲突，则不建议展开
namespace std
{
// 命名空间中可以定义变量/函数/类型
int rand = 10;
int Add(int left, int right)
{
return left + right;
}
struct Node
{
struct Node* next;
int val;
};
}
using std::Add;//命名空间部分展开（授权）
int main()
{
printf("%d\n", std::rand);
printf("%d\n", Add(1, 2));
struct std::Node node;
}
4、命名空间可以嵌套
namespace N1
{
int a;
int b;
int Add(int left, int right)
{
return left + right;
}
namespace N2
{
int c;
int d;
int Sub(int left, int right)
{
return left - right;
}
}
}
int main()
{
printf("%d", N1::N2::Sub(2, 4));//调用
return 0;
}
现在我们就可以来理解c++中的using namespace std
#include std是c++标准库的命名空间，c++库中命名的所有东西都会放到这个命名空间中，避免我们定义的东西和c++中定义的发生冲突。
同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中
同一个命名空间里不能定义相同名字的变量
一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中
C++输入和输出
1、使用cout标准输出对象(控制台)和cin标准输入对象(键盘)时，必须包含< iostream >头文件以及按命名空间使用方法使用std。
2、cout和cin是全局的流对象，endl是特殊的C++符号，表示换行输出，他们都包含头文件中。
3、 <<是流插入运算符，>>是流提取运算符
4、使用C++输入输出更方便，不需要像printf/scanf输入输出时那样，需要手动控制格式。C++的输入输出可以自动识别变量类型。
输出运算符打印变量时，自动识别类型
int main()
{
int i;
double j;
cin >> i >> j;
cout << i << endl;
cout << j << endl;
cout << &i << endl;
cout << &j << endl;
return 0;
}
缺省参数
缺省参数是声明或定义函数时为函数的参数指定一个缺省值。在调用该函数时，如果没有指定实参则采用该形参的缺省值，否则使用指定的实参
void func(int a = 1)
{
cout << a << endl;
}
int main()
{
func(2);//传参时，使用指定的实参
func();//没有传参，就使用参数的默认值
return 0;
}
1、全缺省参数：从左向右显示参数
void Func(int a = 10, int b = 20, int c = 30)
{
cout << "a = " << a << endl;
cout << "b = " << b << endl;
cout << "c = " << c << endl;
}
int main()
{
Func(1,2,3);//传参时，使用指定的实参
Func();
Func(1);//传一个默认传给第一个形参
Func(1,2);//传2个默认传给前两个形参
return 0;
}
2、半缺省参数：必须从右向左，给缺省值
void Func(int a, int b = 10, int c = 20)
{
cout << "a = " << a << endl;
cout << "b = " << b << endl;
cout << "c = " << c << endl;
}
int main()
{
Func(1,2,3);
Func(1);
Func(1,2);
return 0;
}
注意：缺省参数不能在声明和定义同时给，同时给会报错。
声明当中给缺省参数，定义不给
#include 函数重载
1、 函数重载：是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这
些同名函数的形参列表(参数个数 或 类型 或 类型顺序)不同，常用来处理实现功能类似数据类型
不同的问题。
2、C语言不允许同名函数
3、C++允许同名函数，但是要求构成函数重载
4、构成函数重载的条件：函数名相同，参数不同（类型不同，个数不同，类型顺序不同）
1、参数类型不同构成函数重载
#include 2、参数个数不同构成函数重载
void f()
{
cout << "f()" << endl;
}
void f(int a)
{
cout << "f(int a)" << endl;
}
int main()
{
f();
f(1);
return 0;
}
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()
{
f(1, 'c');
f('d', 3);
return 0;
}
引用
概念：
引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空
间，它和它引用的变量共用同一块内存空间。
int main()
{
int a = 0;
int& b = a;//a的别名b（引用）
cout << &a << endl;
cout << &b << endl;//取地址
return 0;
}
引用使用的是同一块内存空间
int main()
{
int a = 0;
int& b = a;//a的别名b（引用）
b++;
a++;
cout << a << endl;//2
cout << b << endl;//2
return 0;
}
引用特性：
1、引用在定义时必须初始化
2、一个变量可以有多个引用
3、引用一旦引用一个实体，再不能引用其他实体
1、做函数参数
void Swap(int& left, int& right)
{
int temp = left;
left = right;
right = temp;
}
int main()
{
int a = 10;
int b = 0;
Swap(a,b);
cout << a << endl;
cout << b << endl;
return 0;
}
2、引用做返回值
int& Count()//返回的值是n的别名
{
int n = 0;
n++;
return n;
}
int main()
{
int ret = Count();
cout << ret << endl;
return 0;
}
上述代码会有一个问题：如果空间被清了返回的值就是一个随机值，如果空间没有被清理返回的值就是1
int& Count()//返回的值是n的别名
{
int n = 0;
n++;
return n;
}
int main()
{
int& ret = Count();
cout << ret << endl;
cout << ret << endl;
return 0;
}
#include 第一次调用结果是1，第二次调用之前清理了栈帧，原内存空间被覆盖，所以是随机值
上面代码都不能使用引用返回，如果使用引用返回是不安全的。
注意：如果函数返回时，出了函数作用域，如果返回对象还在(还没还给系统)，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回。
3、传值、传引用效率比较
以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低。
#include #include 静态变量，全局变量，堆上动态申请的变量可以用引用返回提高程序运行效率，不能用引用返回临时变量，局部变量，出了函数作用域会被销毁的变量。
传引用传参（任何时候都可以）
1、提高效率
2、输出型参数（形参的修改影响实参）
传引用返回（出了函数作用域对象还在不在）
1、提高效率
2、修改返回对象
3、常引用
在引用的过程中，权限可以平移，权限可以缩小，权限不可以放大
int main()
{
const int a = 0;
//权限的放大，不可以
//int& b = a;
//int b = a;//赋值是一种拷贝，不受控制
//权限的平移
const int& c = a;
//权限的缩小
int x = 0;
const int& y = x;
return 0;
}
4、引用和指针的区别
在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。
在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。
引用不完全等价于指针
5、引用和指针的区别（不同点）
1、引用概念上定义一个变量的别名，指针存储一个变量的地址。
2、引用在定义上必须初始化，指针没有要求
3、引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
4、没有NULL引用，但有NULL指针
5、在sizeof中含义不同：引用结果为引用类型大小，但指针始终是地址空间所占字节数（34位平台下4字节，64位平台下8字节）
6、引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型大小
7、有多级指针，但是没有多级引用
8、访问实体方式不同，指针需要显示解引用，引用编译器自己处理
9、引用比指针使用起来相对安全
内联函数
宏函数
#define ADD(x,y)( (x)+(y))
1、内联函数
以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数调用建立栈帧的开销，内联函数提升程序运行的效率。
inline int add(int x, int y)
{
return x + y;
}
int main()
{
int ret = add(1, 2);
return 0;
}
2、内联特性：
- inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用，缺陷：可能会使目标文件变大，优势：少了调用开销，提高程序运行效率。
- inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。
3、内联说明只是向编译器发出的一个请求，编译器可以选择忽略这个请求
4、内联函数在符号表里没有地址，内联函数在调用的地方就已经展开了
3、inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到
运行结果：
编译报错，链接错误，inline内联函数被展开，在符号表中找不到函数地址
宏的优缺点？
优点：
1、增强代码的复用性
2、提高性能
缺点：
1、不方便调试
2、代码的可读性差，可维护性差，容易误用
3、没有类型安全的检查
c++有哪些类型代替宏
- 常量定义 换用const enum
- 短小函数定义 换用内联函数
auto关键字(C++11)
auto自动推导变量类型，根据=右边的值自动推导=左边值的类型
int main()
{
int a = 0;
auto b = a;
auto c = &a;
auto& d = a;
return 0;
}
1、普通场景下auto没有价值，类型很长的情况下auto才有价值
2、auto不能作为函数的参数
3、auto不能直接用来声明数组
c++中typeid（变量）.name（）可以查看变量类型
基于范围的for循环(C++11)
范围for，基于范围去访问
依次取数组中的数据赋值给e
自动判断结束
自动迭代
一般情况下都和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
//范围for，基于范围去访问
//依次取数组中的数据赋值给e
//自动判断结束
//自动迭代
for (auto e : array)
{
cout << e << " ";
}
cout << endl;
return 0;
}
int main()
{
int array[] = { 1, 2, 3, 4, 5 };
for (auto& x : array)//使用引用才能改变数组array的值
{
x *= 2;
}
for (auto e : array)
{
cout << e << " ";
}
cout << endl;
return 0;
}
指针空值nullptr(C++11)
NULL实际是一个宏，在传统的C头文件(stddef.h)中，可以看到如下代码：
#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif
NULL可能被定义为字面常量0，或者被定义为无类型指针(void*)的常量。不论采取何
种定义，在使用空值的指针时，都不可避免的会遇到一些麻烦
注意nullptr使用：
- 在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的。
- 在C++11中，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同。
- 为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr。