命名空间
在自己定义的变量函数，可能会和库中的函数、变量等重名发生冲突，在C语言中没有含好的办法解决
例如
#include <stdlib.h>
int rand = 0;error, stdlib中存在rand的命名
在C/C++中，变量、函数和后面要学到的类都是大量存在的，这些变量、函数和类的名称将都存在于全局作用域中，可能会导致很多冲突并且C语言无法很好的处理这种冲突。
在C++中，使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染namespace关键字的出现就是针对这种问题的。
定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{}中即为命名空间的成员。
#include <stdlib.h>
namespace temp
{
int rand = 0;
}
定义了一个叫 temp的命名空间(域)
就不会出错了，rand只属于temp这个域里面
如何访问呢？
需要使用作用域限定符：：
#include <stdlib.h>
namespace temp
{
int rand = 0;
}
int main()
{
printf("%d\n",rand);
这个rand会先在局部寻找，没找到再去全局找，全局没找到就会报错，局部和全局都有按就近原则
::rand表示去全局变量找，不加就是就近原则，局部中的
printf("%d\n",temp::rand);
这个rand规定到temp这个域中去找
return 0;
}
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;
}
}
using N::b; 只展开N这个域中的b
int main()
{
printf("%d\n", N::a);
printf("%d\n", b);
printf("%d\n",N::Add(1,2));
return 0;
}
using namespce N; 把整个域展开，但是隔离就失效了
int main()
{
printf("%d\n", a);
printf("%d\n", b);
Add(10, 20);
return 0;
}
并且同一个工程中的相同的命名空间，最后会合并为同一个，例如.h文件和.cpp文件中都有 namespace temp，最后会被 合并为同一个namespace temp，但是 .cpp 和 .h的namespace temp中内容的命名不能是相同的
.cpp
namespace N1 // N1为命名空间的名称
{
// 命名空间中的内容，既可以定义变量，也可以定义函数
int a;
int Add(int left, int right)
{
return left + right;
}
}
.h
namespace N1
{
int Mul(int left, int right)
{
return left * right;
}
}
同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。
- ：：可以做到最好隔离，但也使用不变（项目当中最好使用这个）
- using 成员 用于展开常用的
- using namespace 全部展开，使用很方便，但隔离完全失效
C++中的输入输出
#include<iostream>
using namespace std; 这句意义是c++库的实现定义在std的命名空间中，练习时暂时先全部展开，方便练习
int main()
{
cout<<"Hello world!!!"<<endl;
等价 printf("Hello world!!!\n");
int a;
cin >> a >> endl;
等价 scanf("%d",&a);
return 0;
}
cout是流插入，把Hello world!!!，输出到控制台，cin是流读取，从键盘读取到a里，endl是换行
使用cout标准输出(控制台)和cin标准输入(键盘)时，必须包含< iostream >头文件以及std标准命名空间。
在C++中，cin和cout不需增加数据格式控制，比如：整形–%d，字符–%c，自动识别类型
#include <iostream>
using namespace std;
int main()
{
int a;
double b;
char c;
cin>>a; 等价 scanf("%d",&a)
cin>>b>>c; 等价 scafn("%lf%c",&b,&c)
cout<<a<<endl; 等价 printf("%d\n",a);
cout<<b<<" "<<c<<endl; 等价 printf("%lf %c \n",b,c);
return 0;
}
但是C++输出浮点数时，是有几位显示几位，并且控制小数点位数 比C麻烦一些，实际应用中c和c++谁方便用谁
缺省参数
缺省参数是声明或定义函数时为函数的参数指定一个默认值。在调用该函数时，如果没有指定实参则采用该默认值，否则使用指定的实参
void TestFunc(int a = 0)
{
cout<<a<<endl;
}
int main()
{
TestFunc(); 没有传参时，使用参数的默认值，a=0
TestFunc(10); 传参时，使用指定的实参 a=10
}
全缺省参数
形参的所有参数都有缺省值
void Func(int a = 10,int b = 20, int c = 30)
{
cout<< a << endl;
cout<< b << endl;
cout<< c << endl << endl;
}
int main()
{
Func(); a=10，b=20，c=30
Func(1); a=1，b=20，c=30
Func(1,2); a=1，b=2，c=30
Func(1,2,3); a=1，b=2，c=3
return 0;
}
半缺省参数
void Func(int a ,int b = 20, int c = 30)
{
cout<< a << endl;
cout<< b << endl;
cout<< c << endl << endl;
}
注意：
1.半缺省参数，必须从右往左按顺序，不间隔着缺省
2.缺省参数在声明和定义时，不能同时出现，推荐写在声明
函数重载
函数重载是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，但必须满足以下三种情况之一：
- 参数类型不同
- 参数类型个数不同
- 参数类型顺序不同
重载和返回值、缺省参数没有关系，看的是数据类型
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(int a)
{
cout << "void f(int a)" << endl;
}
void f(int a,int b)
{
cout << "void f(int a,int b)" << endl;
}
3.参数类型顺序不同
void sub(double right,int left)
{
cout << "void add(double right,int left)" << endl;
}
void sub(int right,double left)
{
cout << "void sub(int right,double left)" << endl;
}
注意：下面这种情况，会出现调用不明确
void f1()
{
cout << "void f1()" << endl;
}
void f1(int a = 0)
{
cout << "void f1(int a = 0)" << endl;
}
当无参和缺省值的参数函数命名相同，传参时可以确定是调用下面的，不传参时，无法确定是调用哪一个
图解重载：
cpp和c的编译过程基本一致，如下：
通过汇编查看函数的地址：
上图所示就是为什么C++可以重载的简单解释，只是还有些具体细节没有体现
总结：c++编译生成的符号表中，会以函数名修饰（前缀+函数名长度+函数名+参数首字母），而C语言只会以函数名修饰，地址全部是相同的，所以c++支持重载，c不支持重载
引用
引用的概念：引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。
数据类型& 名字 = 引用实体
int c = 10;
int& a = c;
例如指针，是需要开辟新空间，来保存变量的地址，在语法层中，引用a没有开辟新空间，如上图,c和a属于同一块空间（同一个内存地址），只是名字不同，都可以使用这个空间进行读写操作
引用的特性
- 引用类型必须和引用实体是同种类型的
int a = 10;
double& b = a; error
- 引用在定义时必须初始化
int& c;
int d = 10;
c = d; error
- 一个变量可以有多个引用
int c = 40;
int& f = c;
int& d = c;
- 引用一旦引用一个实体，再不能引用其他实体
int e = 50;
int& i = e;
int j = 60;
i = j; error
引用是变量的别名，所以引用可以对引用的变量进行读写操作，他们属于同一块空间的两个名字，所以改变的也是变量本身
int main()
{
int i = 10;
int&j = i;
j = 20;
cout << "i: "<< i << endl;
i = 30;
cout << "j: "<< j << endl;
return 0;
}
常引用
1.权限不变
const int a = 10;
const int& b = a;
变量a和引用b的权限都是只读的
2.权限缩小
int c = 20;
const int& d = c;
c开辟了一块空间，这块空间的权限是可读可写的，引用的权限是只读的，权限缩小不会发生错误
3.权限放大
const int e = 20;
int& f = e; error
最开始e开辟了一块空间，这块空间的权限是只读的，而f引用这块空间，f的权限是可读可写的，造成权限 放大，就会发生错误
4.常量的引用
double i = 11.11;
int i1 = i;
//int& i2 = i;//error
const int& i3 = i;
const int& i4 = 10;
double赋值给int型时，先进行算术转换，之后发生截断，赋值时会把数据放到临时变量里，临时变量属于常量，只能读
所以i3可以看成是 常量的别名
10是常量，只能读不能写，要用const，所以i4可以看成是常量10的别名
使用场景
引用传参
void swap(int* p1,int* p2) 传地址
{
int temp = *p1;
*p1 = *p2;
*p2 = temp;
}
void swap(int& r1,int& r2) 传引用
{
int temp = r1;
r1 = r2;
r2 = temp;
}
int main()
{
int x = 1;
int y = 2;
swap(&x,&y);
cout << x << " " << y << endl;
int a = 3;
int b = 4;
swap(a,b);
临时在栈帧中，对a和b取两个别名为r1，r2
用别名交换数值等于a和b本身在交换（别名和变量是同一块内存的两个名字）
调用结束后，这个别名就随着栈帧销毁了
cout << a << " " << b << endl;
return 0;
}
效果相同，是等价的
1.传地址和传引用 功能上差不多，
2.传地址是把变量自己的变量传给指针存储，对指针解引用等于拿到变量本身
3.传引用是对变量取了个新的名字，实际的内存地址还是本身，只是这块地址多了个名字
之前学习单链表时，传参传的都是二级指针，这里就可以改用传引用了
typedef int code;
typedef struct SLTNode
{
code data;
struct SLTNode* next;
}STL;
--------------------------------------------------------------------
void STList_PushBack(STL** sp,int x）
-----------------------------------------------------------------------
void STList_PushBack(STL*& sp,int x)
-----------------------------------------------------------------------
{
STL* cur = *sp;
STL* newcur = (STL*)malloc(sizeof(STL));
if(newcur == NULL)
{
perror("malloc");
exit(-1);
}
newcur->data = x;
newcur->next = NULL;
if(cur == NULL)
{
*sp = newcur;
}
else
{
while(cur->next != NULL)
{
cur = cur->next;
}
cur->next = newcur;
}
}
int main()
{
STL*data = NULL;
//STList_PushBack(&data,1);
STList_PushBack(data,1);
//c++中就可以用引用，对STL*data取别名，STL*& sp 和STL*data都是同一个内存，只是名字不同
return 0;
}
因为在主函数中传参传的是一级指针，而在初始化时会把一级指针置空，传参传一级指针，形参是实参的临时拷贝，实参是NULL形参就是NULL，形参申请的动态内存只会保存在形参中，调用函数结束时，栈帧销毁，形参销毁，就会造成内存泄漏，并且在释放时也必须令一级指针本身置空，所以当时必须穿二级指针
这里可以改以传引用，等同于一级指针本身去接收新开辟的内存地址，释放时也可以直接使一级指针本身置NULL
（push开辟内存时也可以传返回传值，与传引用传二级指针效果相同）
引用做返回值
int Add(int x ,int y)
{
int c = x + y;
return c;
}
int main()
{
int ret = Add(1,2);
cout << ret << endl;
return 0;
}
随着函数调用结束，栈帧销毁,C也跟着销毁，但是C的值会拷贝在临时变量中，一般4或8字节，占用字节很小时，就会存在寄存器中
当返回的数据占用字节很大时会返回在调用函数的栈帧中
int& add(int x,int y)
{
int c = x + y;
return c;
}
int main()
{
int ret = add(1,2);
cout << ret << endl; //3
add(10,20);
cout << ret << endl; //30，c的栈帧数据被覆盖
return 0;
}
引用返回值是返回C的别名，当栈帧销毁时，C也会销毁，假如编译器销毁栈帧时不清除数值，会出现两种情况
1.后面执行的程序所消耗的栈帧，小于add所用的栈帧，不会覆盖到C的位置，可以读到C的值，但是属于非法访问
2.后面执行的程序所使用的栈帧大于上一次（add）所使用的栈帧，C栈帧的位置数据就被覆盖
所以，对于出了作用域的，如果返回对象还存在（没还给系统）可以用引用返回（如静态变量、全局变量），若还给系统了，则必须用返回值
int& at(int i)
{
static int a[10];
return a[i];
}
void init_printf()
{
int i;
for(i = 0;i < 10;i++)
at(i) = 10+i; //给数组初始化
for(i = 0;i < 10;i++)
cout << at(i) << endl;
}
a就是静态变量，只有在程序结束时才会销毁
传值与传引用的效率比较
#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;
}
当一个 特别大的数，而且是全局变量或静态区的时候，就用传引用，效率比传值提高很多（传返回值也是同理）
指针和引用的区别：
- 引用在定义时必须初始化，指针没有要求
- 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
- 没有NULL引用，但有NULL指针
- 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)
- 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
- 有多级指针，但是没有多级引用
- 访问实体方式不同，指针需要显式解引用，引用编译器自己处理
- 引用比指针使用起来相对更安全
引用和指针的汇编代码，对比可知没有区别，所以引用的底层还是指针，但是在语法层我们只把它当作对一个变量取别名，而且是不占用空间的
内联函数
以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数压栈的开销，内联函数提升程序运行的效率。
在C中，可以定义宏来提高效率
#define add(x,y) ((x)+(y))
int main()
{
printf("%d\n",add(1,2));
return 0;
}
宏是在预编译时，直接替换掉，但是替换后不便于调试，并且宏很容易出错，定义比较麻烦
c++中就增加了内联，只在调用的地方展开，不会申请栈帧空间
inline int add(int x,int y)
{
int ret = x + y;
return ret;
}
int main()
{
cout << add(1,2) << endl;
return 0;
}
在函数前面加上inline关键字，是建议编译器把他作为内联函数， 在release模式下，编译器生成的汇编代码中不存在call Add了
-
inline是一种以空间换时间的做法，省去调用函数额开销。所以代码很长或者有循环/递归的函数不适宜使用作为内联函数。
-
inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归等等，编译器优化时会忽略掉内联。
-
inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。
-
可以在同一个项目的不同源文件内定义函数名相同但实现不同的inline函数，inline函数会在调用的地方展开，编译不会出现他的符号表，所以符号表中不会有inline函数的符号名，不存在链接冲突。
宏的优势是替换，不会建立栈帧，而是直接替换，内联函数在编译时，C++编译器会在调用内联函数的地方展开，没有函数压栈的开销，内联函数提升程序运行的效率，有了内联，就不需要C的宏了，宏比较复杂，会出错不便调试
建议：短小频繁调用的函数用inline
auto关键字
C++11中，标准委员会赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。
int a;
auto b = a;
cout << typeid(b).name() << endl;
输出结果是 int
也就是auto能根据变量自动推导出数据类型
auto的使用细则：
1.必须在定义时初始化
2.auto和auto*没有区别
int x = 10;
auto px = &x;
cout << typeid(px).name() << endl; //int*
auto* ppx = &x;
cout << typeid(*ppx).name() << endl; //int
cout << typeid(ppx).name() << endl; //int*
auto& rx = x;
cout << typeid(rx).name() << endl; //int
3.auto不能作为函数的参数
4.auto不可以直接用来声明数组，可以声明数组的一个元素
范围for
在C语言中遍历一个数组元素
int arr[] = {1,2,3,4,5};
for(int i = 0;i < sizeof(arr)/sizeof(arr[0]);i++)
cout << arr[i] <<endl;
对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此C++11中引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。
//for(int e: arr)
for(auto e : arr)
cout << x <<endl;
这样就把数组遍历了
for(auto& e : arr)
e++;
通过引用，使数组的每个值都+1
指针空值nullptr(C++11)
// 指针空值nullptr
void f(int)
{
cout << "void f(int)" << endl;
}
void f(int*)
{
cout << "void f(int*)" << endl;
}
int main()
{
int* p1 = NULL;
int* p2 = 0;
f(NULL);
f(0);
f(nullptr);
return 0;
}
由于 NULL和0都是0类型，在调用时，会被认为是传参调用，所以c++新增进了 nullptr，使得类型更明确了
4203
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
