文章目录
命名空间
解决c语言命名冲突问题
1.我们自己定义的变量，函数可能和库里面重名冲突
2.但是进入公司项目组里面，做的项目通常比较大，多人协助，会导致代码中命名冲突 c语言无法解决这个问题，除非换名字 c++提出了新语法，叫命名空间，
3.命名空间里面可以包含各种东西，函数，结构体，变量
#include<stdio.h> #include<stdlib.h> int rand = 0; int main() { printf("%d", rand);//如果没加stdlib.h这个头文件的化， //是可以正常运行的，但是如果包了这个头文件时，rand就是里面的函数 //因为在预处理的时候，头文件展开，里面有rand这函数 printf("%d", rand);//以十进制方式打印，出来的是地址 return 0; }
namespace空间-----是一个域
#include<stdio.h> //定义了一个叫b的命名空间，命名空间是全局的 namespace b { //他们还是一个全局变量，放到静态域， int rand = 0;//加这个就是为了避免冲突 int a = 1; } int a = 0;//全局域 int main()//函数里面叫局部域 //编译器会先在局部去找，再去全局去找，否则就会报错 { printf("%d\n", rand); printf("%d\n", b::rand);//::叫做域作用限定符，意思是去取左边这个域里面的，很明显要去b这个域里卖弄去找 int a = 1; printf("%d\n", a);//a为局部域里面去找 printf("%d\n", ::a);//a到左边的空白域里面去找，就是去全局域里面去找 return 0; }
namespace也可以嵌套包含
对嵌套包含的要用两层：：
//命名空间里面还可嵌套 namespace bt//命名空间里面不仅可以定义变量，还可以定义函数，类型 { int rand = 10; int add(int left, int right) { return left + right; } struct node { int val; struct node* next; }; namespace n1 { int d = 2; } } //使用命名空间里面的的东西 //不同文件里面定义的同样的命名空间，会被合并成一个，命名空间 int main() { bt::rand = 10;//使用其与其他进行隔离 struct bt:: node nt;//要加bt：：才可以找得到里面的东西 bt::add(1, 2);//这样就可以找到了，只是影响了编译器找的规则 bt::n1::d = 2;//运用指定，这样子可以把嵌套的引用出来 //这种可以做到最好的命名隔离， return 0; }
c++的输入输出
#include<iostream> //输入输出流 //using namespace std; //c++库的实现定义在一个std的一个命名空间中， int main() { cout << "hello world" << endl; return 0; }
#include<iostream> using std::cout; using std::endl; using std::cin; int main() { std::cout << "hello world" << std::endl; return 0; }
#include<iostream> using namespace std; //cout可以自动识别类型 int main() { cout << "hello world" << endl;//endl是用来换行的 double d = 1.2; int k = 12; cout << d <<" "<<k<< endl;//自动识别类型不用%d，不可以控制小数点的位数，c++d输入输出可以混在一起写 cin >> k >> d;//把数据流向k和d return 0; }
缺省
全缺省和半缺省
//缺省参数 void func1(int a = 0)//如果func1里面传了参数，就和传的是一样的，如果func1里面没有传参数，相当于实参是0，形参是a //把缺省值去当作实参传给a { cout << a << endl; } void func2(int a = 1, int b = 2, int c = 3)//全缺省 { cout << a << " " << b << " " << c << endl; } //半缺省，缺省一部分参数，必须从右往左缺省,必须连续缺省 void func3(int a,int b=32,int c=89) { cout << a << " " << b << " " << c << endl; } int main() { func(1); func1(); func2();//啥都不传 func2(13, 42);//从左往右给 func3(13);//a必须要传，缺省的可以不传 return 0; } struct stack { int* a; int top; int capacity; }; void stackinit(struct stack*ps,int capcity=4) { ps->a = (int*)malloc(sizeof(int) * capcity); ps->top = 0; ps->capacity = capcity; } /*int main() { struct stack st; stackinit(&st);//不知道栈最多可以存多少数据，就用缺省值初始化 stackinit(&st, 100);//知道最多可以存多少数据，就传值，减少增容次数，提高效率 return 0; }*/ //缺省参数不能同时在声名与定义中出现，推荐大家写在声名，方便查找
函数重载
函数重载：是函数的一种特殊情况，同一个函数有不同功能， 这些同名函数的形参列表（参数个数或类型或顺序）不同，用来处理实现功能类似的不同问题
函数名相同的不同函数
//1.参数的类型不同 int add(int left, int right) { cout<<left << " " << right << endl; return left + right; } double add(double left, double right) { cout << left << " " << right << endl; return left + right; } //2参数个数不一样 void f() { cout << "f()" << endl;//没传参数就调用他 } void f(int a) { cout << "f(int a)" << endl;//传了参数就调用他 } //顺序不同 void fs(int a, char b) { cout << " fs(int a, char b)" << endl; } void fs(char b,int a) { cout << " fs(char b,int a)" << endl; } //返回值不同不能构成承载，返回值不同不能区分，参数不同可以区别的 //void a(int a) //int a(int a) //缺省值不同，不能构成重载 //1. //void cz(int a) //{ // cout << "as" << endl; //} //void cz(int a = 21) //{ // cout << "asd" << endl; //} //2.形参个数不同，构成重载，但是使用的时候要小心 void as() { cout << "ead" << endl; } void as(int a = 21) { cout << "as" << endl; } int main() { cout << add(3, 2) << endl; cout<<add(3.3, 8.3)<<endl; f(); f(1); fs(2, 's'); fs('a', 32); as();//存在歧义 return 0; }
引用
引用就是给别的变量取别名
int main() { int a = 10; int b = a;//把a的值赋给b //引用定义。 int& c = a;//引用，在变量名和类型的中间就是一个引用，是a的引用， //c是a的别名 //c和a的地址和值都是一样的 //引用在语法层，我们要理解为这里没有开一个新空间，就是对原来的取了一个新名称叫做b //如李逵，黑旋风都是一个人 int a = 20;//a和c都改成20， int c = 30;//c和a都改成了30， //如李逵吃饭了，黑旋风也吃了 //黑旋风吃饱了，李逵也吃饱了 int* p = &a;//单独就是取地址 return 0; }
int main() { int a = 0; int& b = a;//相同类型不会产生临时变量 double c = 1.1; int m = c;//会产生一个临时变量, //同样类型的截断，类型的提升都会产生一个临时变量 //函数的返回 //传值返回也是临时变量 const int& r = c;//r是c的临时变量的别名，把精度丢了 cout << r<<m << endl; return 0; }
引用的特性
1.引用必须初始化
2.一个变量可以有多个引用
3.引用只能用一个实体
int main() { //1.引用在定义的时候必须初始化，引用是取别名，要说清楚是给谁取别名 int a = 10; int& b = a; //2.一个变量可以有多个引用， int k = 3; int& kt = k; int& ktt = k;//相当于可以有很多个外号， int& m = kt;//这样也可以，kt，k，m，kkt都是一个空间，一个人可以有很多个名字 //3.引用一旦引用了一个实体，再不能引用其他实体了， int d = 10; int& dt = d; int c = 20; //1.这里有两层，是让dt变成c的别名呢？ 否 //还是把c赋值给dt呢？ 是 //经过调试是把c赋值给dt，dt和d的值都变成了20 dt = c; return 0; }
引用的应用
1.引用做函数参数
void swap(int* a, int* b) { int tmp = *a; *a = *b; *b = tmp; } //cpp的实现 //1.做参数 void swap(int& r1, int& r2)//r1是x的引用，x的别名，传引用，传地址和传引用功能相同 ，形参的改变可以改变实参 { int t = r1; r1 = r2; r2 = t; } //传值和传地址，传引用构成重载，但是调用时，传值和传引用存在歧义，不知道是传值还是传引用， int main() { int x = 0, y = 1; swap(&x, &y); swap(x, y);//传引用 return 0; }
void slistpushback(slistnode*& phead, slistdate x)//指针的引用，别名不混在一起，phead的改变就是改变plist，不用传二级指针，好认识 { slistnode* newnode = buynode(x); //那么我们这个时候要找尾 //找到尾节点的指针 if (phead == NULL) { phead = newnode; } else { slistnode* tail = phead;//我们要让tail走到尾部去，而非走到空 while (tail->next != NULL) { tail = tail->next; }//找到了尾节点,链接新节点 tail->next = newnode; } }
//指针也可以使用引用 int main() { int a = 10; int& b = a; int* p = &a; int*& p2 = p; //p2也是地址，p也是地址，p2是p的别名 return 0; }
int* single(int* num, int numsize, int& returnsize)//returnsize就是传回去的长度的别名 {}
2.引用做返回值
传值返回会有拷贝，就会有空间
传引用返回就不会有拷贝，原样返回
如果使用的变量在函数使用完之后没有销毁或者返回的空间较大，就用引用返回
int dd(int a, int b) { int c = a + b; return c;//返回的是c的临时拷贝，相当于int tmp=3被传回去了，只能调用一次，调用完了之后就会变成随机值 } int& d(int a, int b) { int c = a + b; return c;//f这里返回的就是c别名， //c传给int& tmp,就是c，所以不会有拷贝造成的空间浪费 } //但是如果函数返回的时候，返回的对象出了函数的作用域还没有销毁，就可以用传引用返回 int& cout() { static int n = 12; n++; //…… return n;//n是一个静态变量，出了函数域不会消失，所以用传引用返回 }
int main() { int ret = dd(1,2); //int& ret=dd(1,2),这样是不行的 int r = d(1, 2); //这样写会存在非法访问，因为add(1,2)的返回值是c的引用，所以add栈帧销毁了以后，回去访问c位置的空间 //如果add函数栈帧销毁了，清理空间那么取c值的时候，取到的就是随机值，给ret就是随机值，当然这个取决于编译器的的实现 cout << ret << endl; cout << r << endl; return 0; }
struct stack { int* a; int top; int capacity; }; void func1(struct stack st)//传值参数，会有拷贝，有空间开辟，原样拷贝 { } void func(struct stack* st)//传地址参数，指针开辟了4个字节 { } //引用做参数，随时都可以，可以1.提高效率，2.形参的修改可以影响实参，输出型参数 void func(struct stack& rst)//传引用参数，rst就是st的别名，没有开辟空间 { } int main() { struct stack st; func1(st); //指针和引用可以构成函数重载，因为指针和引用是两种不同类型的参数 func(&st); func(st); return 0; } //传引用返回的价值 //1.提高效率，2.修改返回变量 int& at(int i)//处理作用域，还在就很有用 { static int a[10];//第一次进入就创建了一个数组 return a[i];//返回这数组第i个位置的别名 //变成了可读可写的， }
常引用
用const进行修饰，在做参数的时候尽量都加一个const进行修饰
//尽量使用const引用进行传参 void f(const int& a) { cout << a << endl; } //const 引用通吃 // const type& 可以接收各种类型的对象 int main() { //权限被放大了，a从一个只读不写的，变成b一个可读可写的就是错的 //const int a = 10; //int& b = a; //权限不变，就可以 const int a = 10; const int& b = a;// //权限缩小 int c = 2; const int& d = c;//从可读可写的变成只读不写的是可以的 double d = 1.11; int i = d;//类型转化，把d的整形部分转过去,不加引用可以 //int& k = d;// //d的临时变量是具有常性，只读不写，而int&具有可读可写， //普通引用引的是左值，const引用引的是右值 //临时变量具有常性，不能被修改， //const 接收就是常量了 return 0; }
引用的优点：
引用和指针的不同点
1.引用在概念上定义一个变量的别名（没有开空间），指针存储一个变量的地址
2.引用在定义的时候必须初始化，指针最好初始化，但是不初始化也不会报错（会变成野指针）
3.引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个相同类型的实体（如我们在链表的时候指向不同的地方）
4.没有NULL的引用，但是有NULL 的指针
5.在sizeof里面的含义不同，引用为引用类型的大小，但是指针是地址空间所占字节大小（32位下是4个字节或64位里面的8个字节）
6.引用自加**++是引用的那个实体+1**，而指针是指针指向偏移一个类型的大小
7.访问实体方式不同，指针需要解引用，引用编译器里面会自己处理
8.有多级指针没有多级引用，引用比指针更加安全
extern “C”
c++程序，调用c的库，再c++程序中加extern "C"
告诉c++编译器，{}里面的函数是用c的编译器编译的，链接的时候，用c的函数名规则去找，就可以链接上了,只有c++才认识extern “c”
c程序，调用c++的库，再c++库中加extern “C”
c掉c++，c++的静态库就会用c的函数名修饰规则去处理以下函数，所以就不能用重载
//在c程序调用c++时候，在c++库里面加extern "C" #ifdef __cplusplus #define EXTERN_C extern "C" #else #define EXTERN_C #endif // __cplusplus
内联函数inline
我们在每次调用函数都会建立栈帧，有栈帧就会有消耗,需要建立栈帧，栈帧中要保存一些寄存器，结束后又要恢复，
可以看到这些都是有消耗的，对于频繁调用的小函数，能否优化一下呢，
c语言可以用宏，来操作避免栈帧的建立
#define ad(x,y) ((x)+(y));
c++的实现方法inline，内联函数
有了inline就不需要去用c的宏，因为宏很复杂，很容易出错 inline但是展开的话，指令就会特别多
1.inline是一种以空间换时间的做法，省去调用函数栈帧的过程，所以代码量长的函数，或者递归函数就不适合用inline，展开之后就会有特别多的指令，变得很大
所以小函数比较适合用inline
2.inline对于编译器只是一个建议，编译器会自动识别，递归或长的编译器会自动忽视inline
3.inline函数声名和定义不能分离，.h和.cpp都要加一个inline，
结论：短小或频繁使用的函数就定义成inline
inline int add(int x, int y)//这样就不会建立栈帧，内联函数，默认是不会展开的，没有函数调用了 { int ret = x + y; return ret; } inline void swap(int& a, int& b)//swap也会经常会出现 { int tmp = a; a = b; b = tmp; }
