C++语法

关键字

1：namespace

作用：1保护命名空间内的变量和函数 2解决相同变量和函数命名冲突

编译默认查找优先级：局部>全局=展开的namespace命名空间内的变量和函数(如果全局有了，则命名空间内的不展开，否则会冲突报错)

Example：

1. 正常的命名空间定义

namespace bit
{
// 命名空间中可以定义变量/函数/类型
int rand = 10;
int Add(int left, int right)
{
return left + right;
}
}

2.命名空间可以嵌套

namespace N1
{
int a;
int b;
int Add(int left, int right)
{
return left + right;
}
namespace N2
{
int c;
int d;
int Sub(int left, int right)
{
return left - right;
}
}
}

2:Using

作用：展开命名空间内的变量和函数

Example:

1.全展开

#include<iostream>
//展开cout和endl函数的命名空间
using namespace std;

namespace bit
{
// 命名空间中可以定义变量/函数/类型
int a = 0;
int b = 1;
int Add(int left, int right)
{
return left + right;
}
}


using namespace bit;

int main()
{

 cout<<a<<endl;
 cout<<add(1,2)<<endl;
 

 return 0;

}

2.指定展开

#include<iostream>
//展开cout和endl函数的命名空间
using namespace std;
namespace bit
{
	// 命名空间中可以定义变量/函数/类型
	int a = 0;
	int b = 1;
	int Add(int left, int right)
	{
		return left + right;
	}
}

//指定展开bit中Add函数
//‘::’为指定展开操作符
using bit::Add;

int main()
{
	//而此时bit中变量a未展开则会报错
	//cout << a <<endl;
	cout <<Add(1, 2)<<endl;
	return 0;
}

缺省参数

1：概念

缺省参数是声明或定义函数时为函数的参数指定一个缺省值。在调用该函数时，如果没有指定实
参则采用该形参的缺省值，否则使用指定的实参。

Example

1：全缺省

#include<iostream>
using namespace std;

// 全缺省
void F2(int a = 10, int b = 20, int c = 30)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
}


int main()
{
	F2(1, 2, 3);
	F2(1, 2);
	F2(1);
	F2();

	// 注意必须顺序传，不能跳跃着传
	// F2(1, ,2);


	return 0;
}

2半缺省

#include<iostream>
using namespace std;

// 半缺省，注意必须从右往左缺省，否则会造成传参歧义，报错
void F3(int a, int b = 20 , int c = 30)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
}

int main()
{
	
	F3(1);
	F3(1, 2);
	F3(1, 2, 3);

	return 0;
}

注意

1. 半缺省参数必须从右往左依次来给出，不能间隔着给
2. 缺省参数不能在函数声明和定义中同时出现

如果声明与定义位置同时出现，恰巧两个位置提供的值不同，那编译器就无法确定到底该
用那个缺省值。

函数重载

1概念：

这是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这
些同名函数的形参列表(参数个数 或 类型 或 类型顺序)不同，常用来处理实现功能类似数据类型
不同的问题。

Example:

#include<iostream>
using namespace std;

// 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()
{
cout << "f()" << endl;
}
void f(int a)
{
cout << "f(int a)" << endl;
}

// 3、参数类型顺序不同
void f(int a, char b)
{
cout << "f(int a,char b)" << endl;
}
void f(char b, int a)
{
cout << "f(char b, int a)" << endl;
}

int main()
{

 Add(10, 20);//int
 Add(10.1, 20.2);//double

 f();//无参
 f(10);//有参
 f(10, 'a');//(int , char)
 f('a', 10);//(char , int)
 return 0;
}

原因

为什么C语言不支持函数重载，而C++支持函数重载？

在C/C++中，一个程序要运行起来，需要经历以下几个阶段：预处理、编译、汇编、链接

预处理：展开头文件/宏替换/条件编译........

编译：检查语法，生成汇编代码   .c/.cpp/.h文件   转化为  .i文件

汇编：把汇编代码转成二进制代码  .i文件  转换为 .o文件

链接：生成可执行文件 .o文件  转换为  .s文件

最终生成.exe可执行文件

【预编译阶段：.c/.cpp文件语法检查时，主函数有函数调用，只要存在函数声明就可以通过语法检查（而函数是否有实际定义并不知道）

 //编译阶段：（函数的地址实际是函数的定义，里面存放着一些需要操作的指令，有了函数的定义才能生成一堆汇编指令，第一句地址就是函数的地址）而在汇编时，C++对函数名相同，而形参列表(参数个数 或 类型 或 类型顺序)不同的函数进行一定规则的函数名修饰（不同编译器修饰规则不同），这样就可以区分了，因此可以实现函数重载，而C语言没有这个操作 //

汇编阶段：把汇编代码转成二进制代码     //链接阶段:链接时，就要用函数名去.o文件里面查找对应的函数地址(如果没有函数定义，则地址不存在，会报链接错误）//

最终形成了可执行的.exe文件】

引用

1：概念

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空
间，它和它引用的变量共用同一块内存空间。
比如：李逵，在家称为"铁牛"，江湖上人称"黑旋风"。实际上是同一个人。

Example:

1.引用在定义时必须初始化

#include<iostream>
using namespace std;

int main()
{

 int a = 10;
 // int& ra; // 该条语句编译时会出错
 int& ra = a;//<====定义引用类型
 printf("%p\n", &a);
 printf("%p\n", &ra);//实际上打印的同一地址

 return 0;
}

2. 一个变量可以有多个引用

#include<iostream>
using namespace std;

int main()
{

 int a = 10;
 int& ra = a;
 int& rra = a;


 return 0;
}

3.常引用

#include<iostream>
using namespace std;

int main()
{

const int a = 10;
//int& ra = a; // 该语句编译时会出错，a为常量
const int& ra = a;
// int& b = 10; // 该语句编译时会出错，b为常量
const int& b = 10;
double d = 12.34;
//int& rd = d; // 该语句编译时会出错，类型不同
const int& rd = d;//为何此处可以，这里发生了隐式转换
                   //转换的过程中d的整数部分被拷贝到一个临时变量里面
                   //这个临时变量具有常性（相当于加上了const），是不能更改的
                   //因此对于引用变量要加上const
                   //表达式，类型转换，都会产生临时变量，它们的结果都会暂存在临时变量里面
              
 return 0;
}

4.引用传参比传值传参效率更高，因为减少了拷贝的操作

5.语法上引用不开空间，底层实现上要开空间，日常谈论上引用不开空间（语法层和底层有时要注意隔离开）（就像老婆饼是老婆做的吗？）

#include<iostream>
using namespace std;



int main()
{
  int*ptr = nullptr;
   int& r = *ptr;//会报错吗？
                  //不会的，因为底层上r只是存储了空指针，这儿并没有对空指针进行解引用
                   //加上 cout<<r<<endl 便会报错，这儿对空指针进行了解引用
}

6.引用++和指针++的意义不同，引用++是对引用变量值+1，而指针++则是指针向后移动指针类型大小的字节

注意引用时的权限问题，例如一个被 const修饰后的变量，被引用时的引用变量没加上const修饰，会造成引用变量的权限放大，可以修改原变量存储的值的问题导致编译失败，反之权限缩小是没有问题的