C++基础知识

最新推荐文章于 2024-06-15 18:06:06 发布

ABdolphin

最新推荐文章于 2024-06-15 18:06:06 发布

阅读量665

点赞数 5

文章标签： c++

本文链接：https://blog.csdn.net/2302_81705247/article/details/138513032

版权

1，命名空间

namespace +自定义名称{ }；里面可以包含变量，函数，结构等等。当想要使用其中的变量时，会使用“：：”称为：域作用限定符。

（1）如果加了域作用限定符，就会从指定的域中寻找，如果不加，则会全局进行寻找.

（2）可以在命名空间中再命名空间，这时如果想使用内部命名空间中的变量时可以采用xxx::x::rand（外部命名空间名称为xxx，内部命名空间名称为x，rand为定义在x中的变量）

（3）在命名空间外调用结构体时，写法稍有不同： struct xxx::Node node;(命名空间的名称为xxx，结构体名称为Node)

（4）可以多次命名空间，如果命名空间的名称相同，命名空间就会合并

（5）在命名空间中不能定义俩个相同的变量，除非在命名空间内，再建立一个命名空间，这时，虽然外部命名空间与内部命名空间有一个名称相同的变量，但是他们的域不同，所以并不冲突

（6）展开命名空间的方式有三种：

1>全部展开（全部授权）using namespace xxx;（xxx为命名空间名称）

2>部分展开（部分授权）using xxx::add;（xxx为命名空间名称，add为命名空间内部的函数名称），之后就可以直接使用命名空间中的add函数了

3>展开指定变量，例如：xxx::add，每次使用add时，都要这样来展开

（7）using namespace std ：std是c++标准库的命名空间

namespace world
   int rand = 0;
   int add(int a, int b) {
       return a + b;
   }
   struct Node {
       struct Node* next;
       int val;
   };
   namespace xxx {
       int rand = 0;
   }
}
int main() {
   printf("%p\n", rand);//从全局中找
   printf("%p\n", world::rand);//“域作用限定符”，从规定的域中找
   printf("%d\n", world::add);//如果不加“world:: ”会从全局寻找，寻找不到
   printf("%d\n", world::xxx::rand);
   struct world::Node node;
}

2，缺省参数

缺省参数：是指在声明或定义函数时为函数的参数指定一个默认值

（1）分为全缺省和半缺省

//全缺省
void func1(int a = 1, int b = 2, int c = 3) {
cout << a <<b<<c<< endl;
}
//半缺省
void func2(int a , int b = 2, int c = 3) {
cout << a << b << c << endl;
}

（2）当函数有多个（n）参数，调用函数式，只传入少于多个参数（<n）时，采用从左到右一次传入,例如：func1(10,20);，func打印出来的为10 20 3.

（3）缺省参数的应用：

namespace xx {
   typedef struct Stack {
   int* a;
   int top;
   int capacity;
}ST;
void StackInit(ST* ps, int N = 4) {
   ps->a = (int*)malloc(sizeof(int) * 4);
   ps->top = 0;
   ps->capacity = 0;
}

ST st1;
StackInit(&st1, 10);
for (size_t i = 0;i < 10;i++) {
StackInit(&st1, i);
}
ST st2;
StackInit(&st2, 10);
for (size_t i = 0;i < 100;i++) {
StackInit(&st1, i);
}

可以根据所需空间的不同，开吧、开辟不同大小的空间
ST st3;
StackInit(&st3);//默认开辟4块空间

3，函数重载

函数重载：在同一作用域，函数名相同，参数不同（类型不同，个数不同，类型的顺序不同）
注：返回值不同不能构成重载！！

例如：

int func(int a,double b){…… }

int func(double b,int a){ …… }

int func(int a){…… }

int func(double b){ …… }

4，编译器处理的流程

Tst.cpp
//预处理：头文件展开，宏替换，去掉注释，条件编译(#ifdef),
//Test.i
//编译：检查语法，生成汇编代码（指令级代码）
//Test.s
//汇编：将汇编代码生成二进制的机器码
//Test.o
//链接：合并连接，生成可执行程序
//a,out/xx.exe

5，&

&：类型后面加&，表示引用变量名（底层逻辑与指针相似）

（1）int a = 0;
int& b = a;相当于给a取了另一个名字
cout << &a << endl;
cout << &b << endl; a，b指的同一块空间

（2）

int a = 0;
int& b = a;将a重命名
int x = 2;
b = x;对a/b进行赋值,并没有改变指向

（3）注意：

1,引用必须在定义的地方初始化
2，一个变量可以有多个引用
3，引用一旦引用一个实体，再不能引用其他实体

举例：
void swap(int& x, int& y) {//相当于这里直接对实参x，y进行操作
   int tmp = x;
   x = y;
   y = tmp;
}

swap(x, y);

（4）传引用返回

int& count() {
   int n = 0;
   n++;
   return n;
}//返回的值为n的别名，非常危险！！！（类似于野指针）

//int ret = count();//打印的结果可能是1，也可能是随机值,取决于栈帧清没清
//cout << ret << endl;
//cout << ret << endl;

//int& ret = count();
//cout << ret << endl;//1

//cout << ret << endl;//随机值

//cout是一个函数，函数调用先传参，先把ret的值传过去，然后再栈帧上开辟内存，可能会将ret的值覆盖掉，所以第二次打印为随机值

int& add(int a, int b) {
int c=a + b;
return c;
}

int& ret = add(1, 2);
add(3, 4);
cout << ret << endl;//7

原因与上述相似，ret指向 add(1, 2)结束后，回收的空间，但add(3, 4)，将add(1, 2)开辟的空间重新覆盖，而那块ret指向的空间也被覆盖，重新利用，里面的值也发生改变（变为了3+4的值）所以打印ret=7

注意！！！：以上皆为传引用返回的错误示范，知道上述大致原因即可，书写代码时不要这样书写！！

（5）注意：

如果函数返回时，出了函数作用域，如果返回对象还在，可以使用引用返回。如果已经还给系统了，则必须使用传值返回！！！

传引用传参（任何时候都可以）
//1，提高效率（比如传入一个较大的数组，直接对数组本身进行修改，省去了多次拷贝的过程）
//2,输出型参数（形参的修改，影响实参）

传引用返回（出了函数作用域，对象还在）
//1，提高效率
//2，修改返回对象（例子如下：）

书写顺序表的时候，想要打印和修改时，是需要书写两个接口才能实现，但是如果使用传引用返回，则只需要书写一个接口就可以实现，

struct SeqList {
   int* a;
   int size;
   int capacity;
};

c的接口设置：
int SLAT(struct SeqList* ps, int i) {
   assert(i < ps->size);
   return ps->a[i];
}
int SLModify(struct SeqList* ps, int i,int x) {
   assert(i < ps->size);
   return ps->a[i]=x;
}

c++的接口：

int& SLAT(struct SeqList& ps, int i) {
assert(i < ps.size);
return ps.a[i];
}

打印：cout<<SLAT(s, 0)<<endl;

修改：SLAT(s, 0) = 1（1为修改后的数值）