C++基础语法

命名空间

对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的

namespacs dog//命名空间为dog
{
  void print(int a)
  {
    printf(" %d \n", a);
  }
  int a;
  int b;//可定义变量，也可定义函数
  
  namespace big_dog//可以嵌套
  {
    void fun1(int a)
    {
      printf("%d\n", a);
      int a;
      int b;
    }
  }
}

namespace dog//可以分段写，最后会整合在一起
{
  int c;
  int d;
  void fun2()
  {
    printf("hehe\n");
  }
}

void fun3()
{
  a = 10;//局部域
  dog::a = 20;//命名空间域
  dog::big_dog::a = 30;//命名空间域
  ::a = 40;//全局作用域
}

int main()
{
  fun3();
  return 0;
}

使用方式：

1. 命名空间+：：+成员
2. 引入成员using + 命名空间 + ：：+成员，后边使用时不用加作用域，成员暴露在全局域中，如果全局域中有同名成员，会导致命名冲突
3. 展开命名空间 using 命名空间，命名空间所有成员暴漏在全局域中

输入输出方式

头文件 + std命名空间

输出 cout << a << “\n”; 输出a\n

输入 cin >> b; 输入b

支持连续的输入输出

字符串指针输出内容

非字符串指针输出地址

缺省参数

给参数定义一个默认值，实际使用时，如果没有传参，对应的行参使用默认值，参数传递一个用一个（必须从第一个参数开始传递，参数要连续的传递）

void fun1(int a = 1, int b = 2, int c = 3)//全缺省
{
  std::cout << a << b << c << std::endl;
}
void fun2(int a, int b = 2, int c = 3)//半缺省，必须从右到左连续无间断
{
    std::cout << a << b << c << std::endl;
}
void fun3(int a = 1, int b = 2, int c)//非法
void fun4(int a = 1, int b, int c = 3)//非法
  
//错误写法，缺省值只能出现在声明或定义的地方，不能同时出现
void fun5(int a = 1, int b = 2, int c = 3);//声明
void fun5(int a = 100, int b = 200, int c = 300)//定义
{
    std::cout << a << b << c << std::endl;
}

函数重载

同一个作用域内声明几个功能类似的同名函数，这些同名函数的行参列表（参数个数或类型 或顺序）必须不同， 常用于处理实现功能类似数据类型不同的问题。

仅仅返回值不同，不能构成重载。

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

float Add(float a, float b)
{
	return a + b;
}

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

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

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

void test3()
{
	std::cout << Add((float)1.5, (float)1.6) << std::endl;
}

函数重载如何实现的

int Add(int a = 1, int b = 2)

编译器编译之后的底层函数名称：

• VS：C编译器 ：无法解析的外部符号 _Add
• VS：C++编译器：无法解析的外部符号 ？Add@@YAHH@Z
• g++编译器：_Z3Addii
• _Z：规定的前缀，3：函数名字的字数，Add：函数名，ii：有两个int类型参数

函数名修饰规则：

• C编译器：函数名中不包含参数信息
• C++编译器：函数名中包含参数信息

int Add(int a, int b)
//C编译器均为：_Add
//g++编译器：_Z3Addii
float Add(float a, float b)
//_Z3Addff
int Add(int a, int b, int c)
//_Z3Addiii
int Add(char a, int b)
//_Z3Addci
int Add(int a, char b)
//_Z3Addic

extern “C”

按照C语言规则编译

extern "C"{
  int sub(int a, int b);
  int mul(int a, int b);
}

引用

不是新定义一个变量，而是给已存在的变量去了一个别名，编译器不会为引用变量开辟内从空间，它和它的引用的变量公用同一块内存空间。

• 类型 + & + 引用名称

int a = 10;
int& ra = a;
int& ra2 = a;
const int b = 10;
const int& rb = a;
const int& r = 10;
//引用类型和引用实体必须是相同类型
double d = 2.0;
double& rd = d;
int c = d;
const int& rd2 = d;
//d隐式类型转换，生成一个临时int变量，rd2此时指向为此临时变量，而临时变量具有常性

void swap(int& ra, int& rb)
{
	int tmp = ra;
	ra = rb;
	rb = tmp;
}

int& Add2(int& ra)//int& Add3(int a),引用做返回值，注意返回值的周期一定要大于函数生命周期
{
	return ++ra;
}

void test4()
{
	int a = 10;
	int b = 20;
	swap(a, b);
	std::cout << a << b << std::endl;
	int& c = Add2(a);
	std::cout << a << b << std::endl;
}

底层实现：引用通过指针实现，定义一个引用类型的变量相当于定义一个指针类型的变量。

语法：引用是别名，不是指针，没有发生拷贝。

目前可以认为引用是指针的一层封装，更加简单化的指针

内联函数

inline int Add(int a, int b)

关键字 ：“inline”

内联函数：编译器编译时，会进行函数指令展开，没有栈帧的开销，提高代码效率

替代宏函数的使用

inline只是一个建议，编译器会根据实际情况进行判断，如果代码简单，直接展开，代码复杂，不会展开

inline不支持分离定义

auto

自动类型推导，不代表具体类型，编译时根据初始化表达式自动推导

auto a = 2;
auto b = 2.0;
auto c = 'a';
cout << typeid(a).name() << endl;
cout << typeid(b).name() << endl;
cout << typeid(c).name() << endl;

auto定义的变量必须初始化

auto可以定义多个变量，每一个表达式的类型要一致

auto定义指针时，加不加 * 没有区别，定义引用类型时，必须加 &

函数参数类型不能使用auto， 定义数组不能使用auto

基于范围的for循环

范围内用于迭代的变量 ： 被迭代的范围

int array[] = {1, 2, 3, 4, 5, 6};
for(int i - 0; i < sizeof(array) / sizeof(array[0]); i++)
for(auto e : array)

使用场景：数据范围确定

指针空值nullptr

1. 其作为关键字，不需要包含头文件
2. sizeof（nullptr） == sizeof ((void*) 0 )
3. 为了提高代码健壮性，尽量使用nullptr表示指针空值