C++ 基础入门篇

文章目录

命名空间
- 输入与输出
- - 缺省参数
  - - 函数重载
    - - 引用和const引用
      - inline（内联函数）

命名空间

定义：命名空间需要用到namespace关键字，其后跟着命名空间的名字（自定义），再接着就是一对花括号，花括号里的内容可以是定义的变量，函数或者结构体

//对命名空间的定义
namespace fun
{
	int a = 1;
	int add(int left,int right)
	{
		return left + right;
	}
	struct Node
	{
		int data;
		int* next;
	}
}
int main()
{
	// ...
	return 0;
}

作用： 命名空间只能使用在全局域中，要知道，不同的域可以定义同一个变量，但在同一个域中不能定义同一个变量，防止在定义某个变量时与全局域产生冲突，空间命名在全局域中就起到了隔离的作用，其在全局域中形成一个命名空间域，该域与全局域互不干涉

若不使用命名空间，在编译时，系统就会出现下面的报错：

在这里插入图片描述
产生冲突时，命名空间就起到了作用：

在这里插入图片描述
可看到，rang成功打印，并未与在全局域中头文件中的rand产生冲突。在访问命名空间的成员时，需要用到" : : " 域作用限定操作符，在该操作符前添上自定义的命名空间名，在其后添上所要访问的成员即可。对于全局域中变量的访问，也可以用此操作符，在该操作符前的位置不添任何东西即可

命名空间中定义的变量，函数或结构体作用的范围是全局

在这里插入图片描述
可以看到在全局域中定义的函数，也可使用命名空间中定义的变量

命名空间的嵌套定义

一个命名空间中可以有多个子命名空间：
在这里插入图片描述
编译查找一个变量/声明时，默认只会在局部和全局域查找，所以想要查找命名空间里的变量/声明的话，有三种方式：

指定访问命名空间

namespace fun
{
	int a = 10;
	int add(int x, int y)
	{
		return x + y;
	}
}
int main()
{
	printf("%d\n",fun::a); // 指定访问命名空间中的变量a
	return 0;
}

全部展开

namespace fun
{
	int a = 22;
	int b = 10;
}
using namespace fun; //将命名空间域全部展开成全局域
int main()
{
	printf("%d\n",a); // 展开之后命名空间中的变量可当成全局域使用
	printf("%d\n",b);
	return 0;
}

全部展开相当于将命名空间中的成员全部暴露在全局域中，这样的方式一般不适用于多人合作时使用，一般适用于个人做一些练习或简单程序时

部分展开

namespace fun
{
	int x = 1;
	int y = 0;
}
unsing fun::x; // 只对命名空间中的x进行展开
int main()
{
	printf("%d\n",x);
	printf("%d\n",fun::y);
	return 0;
}

C++标准库都放在一个叫std(stdandar)的命名空间中
当项目工程中多文件中定义了同名的namespace，编译器会自动认为是同一个namespace，不会产生冲突

输入与输出

与C语言相比，C++的输入和输出会更加的灵活，来看下面的代码：

在这里插入图片描述

”iostream“是标准输入，输出流的库，因为C++的标准库都被放在std的命名空间中，所以在访问库时须以访问命名空间的方式，来对库进行访问
std::cin 是istream类的对象，主要是面向窄字符的标准输入流
std::cout 是ostream类的对象，主要是面向窄字符的标准输出流
std::endl 是一个函数，相当于一个换行符加刷新缓冲区
<< 是流的插入/输出运算符，>> 是流的提取/输入运算符

与C语言相比，C++的输入和输出不用一个指定格式或者多个格式，在写代码时，更加的方便

int main()
{
	int i = 10;
	char b = 'A';
	std::cout << i << std::endl << b << std::endl; // 不同类型的变量进行同时输出
	return 0;
}

缺省参数

概念：缺省参数是在声明或定义函数时，为函数设定一个缺省值（默认值），在调用函数时，若没有指定实参，则该函数就默认使用设定好的缺省值；若指定了实参，则使用实参的值

例：
在这里插入图片描述
可知，当第一次调用函数时，没有指定实参，a的值默认为缺省值4；当第二次调用函数时，指定了实参44，a的值为指定的实参

分类：

全缺省：函数中有多个参数，每个参数都指定一个缺省值

在这里插入图片描述
调用全缺省参数时，传参只能从左往右传，不可跳跃传参

半缺省：函数中有多个参数，参数中至少有一个以上设定有缺省值

在这里插入图片描述
设定缺省参数时，只能从右往左依次设定缺省值，不可跳跃设定

注：在设定缺省参数时，若函数的定义与声明是分离的，那么只能在函数声明时给定缺省值

函数重载

概念：C++支持在同一作用域中出现同名的函数，但要求函数的参数类型不同，或者函数的参数个数不同，这样的同名函数就被称作函数重载，函数重载弥补了C语言中出现的功能相同，但不能定义为同名函数的现象

分类：

参数类型不同

可见，两次都调用了同名的add函数，但实质上这两个函数并不相同，只是功能上相同
参数个数不同

在这里插入图片描述

参数顺序不同

顺序不同，本质上其实也是类型不同

引用和const引用

概念：引用就是给变量取别名

定义：

int main()
{
	int i = 10;
	int& ri = i;
	return 0;
}

从上面的代码来看，ri就是 i 的别名， i 是被引用的变量，而 ri 是引用变量，编译器不会给引用变量另外开辟空间，而是与它所引用的变量公用同一个空间，由此可推出，ri 与 i 共用一个空间，若引用变量改变则被引用变量也会改变，反之，亦如此
在这里插入图片描述
引用的特性：

定义引用变量时必须初始化
一个变量可以有多个引用
一个引用变量一旦引用了一个变量，就不可再引用其他变量了（C++的引用不能改变指向）

从上面的代码来看，将e赋值给了b，但是b的地址也不会改变，b已经有了引用变量a，便不会再引用其他变量

引用的使用方式：

作参数

在这里插入图片描述
我们知道，通常实现两个数交换的函数，实参传的是地址，需要用指针接收，然后再对指针进行解引用，而上面的代码，传的是值，分别用引用变量来进行接收，然后进行两个数的交换，体现了改变引用变量就会改变被引用变量这一个特点

指针的引用

typedef struct Node
{
	int data;
	struct Node* next;
}SL,*phead;

void SeqListInit(phead& plist,int x) 
			//这里的引用相当于 phead& plist = list
{
	SL* tmp = (SL*)malloc(sizeof(SL));
	if (tmp == NULL)
	{
		perror("malloc fail!");
		exit(-1);
	}
	tmp->data = x;
	tmp->next = NULL;
	plist = tmp;
}

int main()
{
	phead plist = NULL;//plist用来存放链表头结点的地址
	//对链表进行初始化
	SeqListInit(plist, 4);
	return 0;
}

代码结果：
在这里插入图片描述

我们知道，在对链表进行初始化时，想要改变一级指针的指向就需要取一级指针的地址，然后用二级指针来接收，通过对二级指针的解引用，就可改变一级指针的指向。但是使用C++的引用，就可以代替指针传参，也可以改变一级指针的指向，这样可较好的简化程序，避免指针混淆

作返回值
用栈顶元素来举个例子：

系统在进行编译时，会有返回值的临时拷贝，并非直接将要返回的对象（st.arr[st.top-1]）直接返回，所以在返回值的类型为int时，系统会为返回值开辟一个空间作为临时对象，来存储返回值，然后再返回临时对象（相当于返回的是要返回的对象的临时拷贝），所以在实行++StackTop(st)的操作时，其实是对临时对象进行++，而临时对象具有常性不能对其进行++的操作；而如果引用作为返回值，则相当于返回的是 st.arr[st.top-1] 的别名，即可以直接对别名进行修改，不会对其进行报错，系统在编译时也不会对其进行拷贝和开辟一个临时空间，

但是并不是任何场景都能用引用返回的，例如：

在这里插入图片描述
调用fun()这个函数，在该函数中创建了临时变量 i ，而当调用结束，函数销毁时，该临时变量 i 也会被销毁，而对引用了 i 的别名进行修改，会造成越界访问，所以引用临时变量不可作为返回值

注：引用和指针是相辅相成的，二者皆不可替代，指针可以改变指向的对象，但引用改变不了，C++使用引用能简化程序，避免使用复杂的指针

const引用

概念：被const修饰的变量会受到权限，不可修改，有const的对象必须用const引用

int main()
{
	const int x = 10;
	const int& rx = x; //x受到const的修饰，所以rx也必须用const
	return 0;
}

在使用const的过程中需要注意：不可放大const对象的权限，但可以缩小没有const对象的权限，缩小了之后，被引用的对象可修改，引用对象不可修改

不可放大权限

在这里插入图片描述
上述代码中的x受到了const的权限，当定义x的别名rx时，因为别名是不开辟空间的，与被引用对象共用同一块空间，x的空间受到限制，那么定义的x的别名rx也应受到限制，不可放大x空间的权限

可以缩小权限

可看到，第二条指令被const修饰，缩小了rx的权限，所以rx不可修改，但是x并未受到权限的影响，所以x可修改

对const运用的延伸

int main()
{
	const int x = 10;
	int y = x;
	return 0;
}

上述代码是正确的，不存在权限的放大，const修饰的是x的这块空间，而将x赋给y是一种赋值拷贝，y也不与x共用同一块空间，所以不存在权限的放大

int main()
{
	const int a = 10;
	const int* p1 = &a;
	int* p2 = p1;
	return 0;
}

上述代码是错误的，这属于权限的放大，第二条指令中，const修饰的不是p1本身，修饰的是p1所指向的空间a不可被修改，且a受到了const的修饰，而将p1赋值给p2时，p2也应受到const的限制

int main()
{
	int b = 20;
	const int* p1 = &b;
	const int* p2 = p1;
	return 0;
}

上述代码正确，属于权限的缩小，变量b可读可写，将b的地址赋给p1后，p1又受到了const的权限，所以p2也应受到const的权限

int main()
{
	int c = 30;
	int* const p1 = &c;
	int* p2 = p1;
	return 0;
}

上述代码时正确的，不存在权限的放大，const修饰p1本身，并非其指向的空间c，p2 = p1相当于一个赋值拷贝，不影响p2对空间c的读写

指针和引用的关系

引用不开辟空间，指针需要开辟空间来存储变量的地址
引用必须初始化，而指针可不初始化
引用的指向一旦确定则不再修改，而指针的指向可随时修改
引用了直接访问指向的对象，而指针需解引用才可访问
引用的大小根据所指向的对象的类型决定，指针的大小在32位平台下是4字节，在64位平台下是8字节
引用的安全性较高于指针

注：引用在语法上是不开辟空间的，但在汇编底层中，其实跟指针是一样的，也需要开辟空间：

int main()
{
	int x = 10;
	int& rx = x;
	rx += 1;

	int* px = &x;
	*px += 1;
	return 0;
}

上述代码的汇编层如下：
在这里插入图片描述
可以看到，底层的汇编指令一模一样，所以引用的底层实现，与指针的实现是一样的

inline（内联函数）

概念：inline放在返回值的前面，用来修饰函数。编译器会对调用的inline函数进行展开，展开之后就不需要再建立函数栈帧，可提高程序的效率，inline函数的出现其实就是代替C语言中的宏，宏的使用直接在预处理阶段直接展开，可提高效率，但是宏的坑太多，所以就有了inline的出现

例如：

#include <iostream>
using std::cout;
using std::endl; 
inline int add(int x,int y)
{
	int ret = x + y;
	return ret;
}
int main()
{
	int sum = add(1,2);
	cout << sum << endl;
	return 0;
}