目录
2.使用using namespace 命名空间名称 引入（全展开）
一.命名空间
1.命名空间作用
命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的。
2.命名空间定义
定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{}
中即为命名空间的成员。
namespace 命名空间名字
{
....
}
#include<stdio.h>
//
namespace wws
{
//命名空间可以含变量，函数，结构体
int rand = 0;
void Add(int a, int b)
{
printf("%d", a + b);
}
struct Node
{
struct Node* p;
int val;
};
}
//命名空间可以嵌套
namespace qlsf
{
namespace wws
{
//命名空间可以含变量，函数，结构体
int rand = 0;
void Add(int a, int b)
{
printf("%d", a + b);
}
struct Node
{
struct Node* p;
int val;
};
}
}
//同一个工程中可以有同名的命名空间 编译器会合成在一起 （命名空间可以不连续）
// 例如在 .h .cpp中有重名的命名空间会合在一起
//test.h
namespace wws
{
int rand = 0;
}
//test.cpp
namespace wws
{
struct Node
{
struct Node* p;
int val;
};
}3.命名空间的使用
1.加命名空间和作用域限定符 (指定引用)
#include<stdio.h>
//
namespace wws
{
//命名空间可以含变量，函数，结构体
int rand = 0;
void Add(int a, int b)
{
printf("%d", a + b);
}
struct Node
{
struct Node* p;
int val;
};
}
int main()
{
//加命名空间名称及作用域限定符
printf("%d", wws::rand);
}2.使用using namespace 命名空间名称 引入（全展开）
namespace wws
{
//命名空间可以含变量，函数，结构体
int rand = 0;
void Add(int a, int b)
{
printf("%d", a + b);
}
struct Node
{
struct Node* p;
int val;
};
}
//全展开
using namespace wws;
int main()
{
printf("%d", rand);
}3.使用using将命名空间中某个成员引入（部分展开）
namespace wws
{
//命名空间可以含变量，函数，结构体
int rand = 0;
void Add(int a, int b)
{
printf("%d", a + b);
}
struct Node
{
struct Node* p;
int val;
};
}
//部分展开
using wws::rand;
int main()
{
printf("%d", rand);
}二.C++输出，输入
使用cout标准输出对象(控制台)和cin标准输入对象(键盘)时，必须包含< iostream >头文件
以及按命名空间使用方法使用std。
三.缺省函数
1.缺省参数的定义
缺省参数是声明或定义函数时为函数的参数指定一个缺省值。在调用该函数时，如果没有给函数参数传值，就使用缺省值。
注意：缺省值必须是常量或者全局变量（防止改变）
案例
2.全缺省和半缺省
全缺省（每一个参数都指定一个缺省值）
半缺省 函数参数一定要从右往左缺省
举个反例
void Funt2（int a=10,int b）
{
......
}int main()
{
Funt2(1);
}像这样从左往右缺省，只传一个值时，b就无法得到值
即使传2个值同样编译也是通不过去的
缺省参数只能从右往左缺省参数，不能跳跃传参，指定传参。
3.缺省参数的说明和定义
缺省参数不能在函数声明和定义中同时出现
如果同时出现，会报错
但缺省参数在声明给，定义不给编译也是可以通过的（尽量不要同时出现）
四.函数重载
1.函数重载定义
C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数 或 类型 或 类型顺序)不同，常用来处理实现功能类似数据类型不同的问题。
#include<iostream>
using namespace std;
namespace wws
{
void funt(int a, int b)
{
cout << a << b << endl;
}
//参数个数不同
void funt(int a, int b,int c)
{
cout << a << b <<c<< endl;
}
//参数类型不同
void funt(int a, double b)
{
cout << a << b << endl;
}
//参数顺序不同
void funt(double a, int b)
{
cout << a << b << endl;
}
}
using namespace wws;
int main()
{
funt(1, 2);
funt(1, 2, 3);
funt(1, 2.3);
funt(2.3, 1);
}注意：
1.函数重载必须是在同一个作用域中才存在。分别在两个作用域的同名函数即使同时展开，也是不能称作函数重载。（如果同名函数的参数部分还完全相同的话就会发生调用不明确）
2.但如果两个函数函数名和参数是一样的，返回值不同是不构成重载的，因为调用时编译器没办法区分。
3.两个函数函数名一样，参数都是同一个变量，但有一个被const修饰，也构成函数重载。
如果两个作用域的同名函数的参数部分不完全相同，同时展开编译时也是可以找到对应的函数的
2.为什么C语言不支持函数重构
简单来说，C语言是根据函数名称来找函数的，而C++是根据修饰后的函数名称。（参数 个数，类型，顺序不同 函数名称变化不同）
五.引用
1.引用概念
引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空
间，它和它引用的变量共用同一块内存空间。
实例
2.引用的的特点
1.引用可以嵌套（就像一个人可以有多个别名）
2.引用在定义时必须初始化
3.引用不能像指针一样 改变指向的变量（初始化完后就不能改变）
4.因为编译器不会为引用变量开辟内存空间，对引用变量用 sizeof() 计算的变量的大小
5.对数组引用要知道它的数组的大小
6.对变量引用时权限不能变大（只能进行缩小 或者 平移）
7.类型转换（duoble b=3.14; int i=b）/ 表达式运算(int a=x+y) 过程中会产生临时变量，对临时变量进行引用会发生权限的放大（临时变量是常量不能改变）
8.语法层面上引用变量是不开空间，指针变量开空间。但底层上引用也是通过指针的方式实现的（也开辟空间）
9.引用没有空引用，但不是绝对的（int& r = *ptr;仍可以编译通过）
3.引用的实践
引用可以一定程度上代替指针的作用
六.内联函数
1.内联函数定义
以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数调
用建立栈帧的开销，内联函数提升程序运行的效率。
#include<iostream>
using namespace std;
inline int Add(int a, int b)//内敛函数
{
return a + b;
}
int main()
{
int ret = 0;
ret = Add(1, 2);//此时不会通过函数名来找下一步指令，而是直接把Add函数直接展开
return 0;
}2.内敛函数的特性
1.nline只是建议编译器把内敛函数展开，具体是否展开要看编译器是怎么实现的，一般把不
是递归、且频繁调用的函数采用inline修饰。
2. inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用，缺陷：可能会使目标文件变大，优势：少了调用开销，提高程序运行效率。
3. inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址
了，链接就会找不到。
//Test.h
#pragma once
inline int Add(int a, int b);
//Test.cpp
#include"Test.h"
inline int Add(int a, int b)
{
return a + b;
}
//main.cpp
#include<iostream>
using namespace std;
#include"Test.h"
int main()
{
int ret = 0;
ret = Add(1, 2);
return 0;
}//Test.h
#pragma once
inline int Add(int a, int b)
{
return a + b;
}
//main.cpp
#include<iostream>
using namespace std;
#include"Test.h"
int main()
{
int ret = 0;
ret = Add(1, 2);
return 0;
}建议直接在.h声明+定义
3.class类中的内敛函数
在类的声明内部声明和定义的函数叫做内联成员函数，如下面例子，函数funt1是普通的成员函数，函数funt2是隐式的内联函数，函数funt3是显式的内联函数。
//.h
class A
{
public:
void funt1();//普通成员函数 声明与定义分离（在不同文件）
void funt2()//隐式内敛成员函数 声明和定义不分离（都在类内部）
{
cout << "隐式内敛";
}
inline void funt3();//显式内敛成员函数 声明与定义分离(声明在类内，定义在类外。在同一个文件)
private:
};
inline void A::funt3()
{
cout << "显式内敛";
}
int main()
{
return 0;
}
//.cpp
#include"Test.h"
void A::funt1()
{
cout << "普通成员函数";
}七.auto关键字
1.auto作用
可以当作任何变量的单位
2.auto使用细则
1.auto定义变量时要初始化
2.auto可以接收任何类型，auto*必须是指针类型。
3.auto不能在同一行定义多个不同类型的变量
4.auto不能当函数参数（函数要确定参数的大小）
5.auto不能声明数组
3.typedef重命名
typedef也可以实现auto类似的功能，但是并不方便，况且更容易出错。
八.基于范围的for循环
我们可以通过这种方法来便捷的遍历数组。
自动取数组中的值来赋给i，自动++，直到结束。
注意：for(auto i : a) a必须是数组名 i为数组下标 不能是指针变量（想从第二个开始遍历，a+1是不行的）
同样下面的代码也是不行的
void funt(int a[])
{
for (auto i : a)
{
cout << i << ' ';
}
}
typedef char* pstring;
int main()
{
int a[6] = {1,2,3,4,5,6};
funt(a);
return 0;
}因为数组不支持传参，传过去的只是数组首元素地址。
如果想改变数组中的元素，可以采用引用的方式
九.指针空值nullptr
NULL实际是一个宏，在传统的C头文件(stddef.h)中是这样定义的
#define NULL 0
可以看到，NULL可能被定义为字面常量0，或者被定义为无类型指针(void*)的常量。
因此会产生这样的代码
我们funt(NULL)是想打印出int*，但还是调用到了funt(int).
为了解决这个问题我们可以使用nullptr，它等价于（int*）NULL.
为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr
1332
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
