C++复习--C++对C的扩展

C++复习（一、从C到C++）

---

# 一、 命名空间 C语言只有一个全局作用域，所有的全局标识符共享，所有当链接后可能发生命名冲突。 在C++中提出的**命名空间**的概念： 命名空间将全局作用域分成不同的部分，不同空间的标识符可以同名而不冲突。

1. 使用某整个命名空间：
   语法：using namespace _spacename; //_spacename即命名空间的 名称

2. 仅使用某命名空间中的变量：
   语法： using name :: variable ; // name

3. 使用变量时，指定作用域
   语法： _name :: variable;

4. 定义一个命名空间：
   语法： namespace _name{ } ;

namespace A{
   int a = 10;
}
int main(){
   //使用A作用域中的变量a;
   int b = A::a;
   return 0;
}

5. c++将标准库中的内容都定义在名为std 的作用域中。

   //1.展开整个标准作用域
	using namespace std;

   cout << "hello world!" << endl;

   //2.仅用标准库中的cout
   using std::cout;
   cout << "hello world!" <<endl;

   //3.使用变量时，指定作用域
   std::cout << "hello world!" << std::endl;

二 、struct 类型增强

C语言中struct是定义一组变量的集合，编译器不认为这是一种新类型；
C++中struct是一个新类型的定义声明；

struct A{
	int a;
	int b;
	//同时也能在类中添加成员函数
	void showMember();
};
void A::showMember(){
	std::cout << "a = " << this->a << " "
		<< "b = " << this->b << std::endl;
}
int main(){
	//定义一个变量时，不用加struct
	A obj1;
	obj1.showMember();
	return 0;
}

三、引用

引用就是一个已定义变量的别名，可由两个标识符操作同一块内存空间。

语法： (类型) & 引用名 = 变量；

 int a = 10;
 int &b = a;
  b = 20;

1. 引用的本质

1. 引用是变量的别名，可以访问同一块内存，在一些场合可以代替指针
2. 引用相对于指针来说，有更好的可读性与使用性
3. 引用在C++内部实现是一个常指针，即引用标识符也会被分配内存空间

2. 引用作表达式左值、右值

1. 作左值时，会对其引用的内存进行操作
2. 作右值时，仅仅是一个数值

	int a = 10;
	int &b = a;//b是a的别名，操作同一块内存
	//1.
	int d = 20;
	b = d;//引用作左值，对内存空间进行操作; 内存中的数据被改变为20

	//2.
	int c;
	c = b;//引用作右值，是一个数值10; c 被赋值为10;

3. 引用作函数参数

1. 普通引用在声明时必须用其他变量初始化
2. 引用作函数参数时，声明不用被初始化

int Add(int& a, int& b){
	return a + b;
}

4. 常引用

语法： const (类型) & 别名 = 变量;

int x = 20;
const int &y = x;

1. 常引用让变量拥有只读属性，不能通过 y 修改 x 标识的内存的值
2. 当普通引用 引用一个字面量时，字面量没有内存，这条语句会报错；
3. 当使用const修饰时，则C++编译器会给n分配内存，使n为此内存块的变量名

4. 常引用字面量的值不可被改变：编译器会报错
综上所得：

即 const int &n = const int * const n;

三、内联函数

C++中使用内联函数代替宏片段：关键字 inline
在遇到需要多次调用代码片段少，逻辑简单的场景时，用内联函数会提升程序运行效率。
内联函数会在使用的地方直接展开运行。

eg：#define MYFUNC(a,b) ((a)<(b)?(a):(b)
替换为 inline int myfunc(int &a,int &b){
		return a < b ? a : b;
}	

1. 内联函数的意义

1. inline是以空间换时间，省去函数入栈与返回的开销
2. 内联函数在最终链接后生成的代码中是没有定义的，C++编译器直接将函数体插入调用的地方

2. 宏的缺点及内联函数的缺点

1. 宏的缺点：不能调试，易出错，无类型检查
2. 内联的缺点：多次重复调用会使调用的地方代码指令体量变大，执行程序时内存消耗变多；
   inline是向编译器的请求，其不一定允许
   inline不建议声明与定义分开，展开后无函数地址，在链接时找不到对应函数
   内联函数不能出现循环与递归。
3. 注：在类中实现定义的成员函数也会被编译器默认为内联函数；

四、函数重载

C++中可以对函数进行重载，即同名的函数实现不同的功能

1. 函数重载的条件

1. 参数个数不同
2. 参数类型不同
3. 参数类型相同但顺序不同
4. 注：返回值不是可重载的条件

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

2. 函数重载实现的原理

C++在编译函数时，会使用不同于C语言的标识符修饰规则；同名的重载函数在符号表中的符合不相同，于是调用时会按对应的参数来调用重载函数

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

由此函数在符号表中的符号为_Z3addii

int add(int a,int b ,char c);
double add(double *a , double *b);

由以上两个函数得到的符号为: Z3addiic 与_Z3addPdS
同名函数的符号不相同，调用时也就调用的是 符合类型的 函数

五、函数默认参数

在C++中，函数声明或定义时为参数设置一个默认值

int add(int x,int y = 10);
//或
int add(int x = 10 ;int y = 10);

1. 调用时可以省略有默认值的参数，编译器会自动填充
2. 缺省参数一定要从右边开始
3. 若默认值带有二义性，则编译不会通过
   如：

int add(int x = 10 ;int y );
在调用时add(20);就会产生二义性，编译器不知道20是传给x还是y的。

4. 注：缺省参数不是函数重载的条件

六、auto关键字与基于范围的for循环

关键字auto
auto 是自动类型推导，在赋值时自动推导正在定义的变量的类型

1.运用场景

//1.推导内置类型
int a = 10;
auto b = a;

//2.推导自定义类型
struct A{
	int a ;
	int* next;
}
A ave;
ave.a = 10;
ave.next = nullprt;

auto c = ave;

2.基于范围的for循环

在C++11中引入的自动遍历

语法：for(auto e : arr){ }

将arr数组中的元素依次取出，赋值给变量 e 并对其操作。

int arr[10] = {0};
for(auto e: arr){
	cout<< e <<endl;
}

：：若期望对原数组元素进行修改，则可以和引用一起使用

语法：for(auto &e : arr){ }

int arr[10] = {0};
for(auto &e: arr){
	e++;
}

最有效的是在对STL容器遍历时应用，增加代码可读性

for(std::vector::iterator it = v.begin();it!=v.end();it++) -------->for (auto &e : v)

	std::vector<int> v;
	for (auto &e : v){
	//for(std::vector::iterator it = v.begin();it!=v.end();it++)

	}

3. auto 不能使用的场景

1. auto 不能作为函数参数

2. auto 不能声明数组
   

3. 数组的范围必须确定，传参退化的指针不能使用
   

4. 自定义类型的迭代器需要支持 ++ 与 == 操作；即对++ 与 == 运算符重载