01C++基础语法

这些语法是对C语言一些不好用的地方的一些补充。
也是对学习C++类和对象做铺垫。

---

---

一、第一个C++程序

要用C++输出hello world ，代码：

#include<iostream>//头文件
using namespace std;

int main()//主函数
{
	cout << "hello world" << endl;//输出
	return 0;
}

相比于C语言，我们发现C++多了一句这样的代码：using namespace std;，那这句代码有什么用呢？另外C++的头文件相比于C语言少了后缀.h
这就要提到C++的命名空间了。

---

二、C++的头文件

早期标准库将所有功能在全局域中实现，声明在.h后缀的头文件中，使用时只需包含对应头文件即可，后来将其实现在std命名空间下，为了和C头文件区分，也为了正确使用命名空间，规定C++头文件不带.h；旧编译器(vc 6.0)中还支持<iostream.h>格式，后续编译器已不支持，因此推荐使用< iostream>+std的方式

---

三、命名空间

在C/C++中，变量、函数和后面要学到的类都是大量存在的，这些变量、函数和类的名称将都存在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的。

简单来讲，就是如果变量名和函数名相同，那就会造成命名冲突，编译器就分不清是函数还是变量了，比如在C语言中：

在调用scanf时，编译器会遵循就进原则，所以这里的scanf是一个局部变量，而不是头文件<stdio.h>里的函数。

C语言无法解决这种命名冲突，而C++中引入了命名空间，就很好的解决了这个问题。

3.1.命名空间的定义

命名空间定义的语法：

namespace N // N为命名空间的名称，可以换成任意名称
{
 // 命名空间中的内容，既可以定义变量，也可以定义函数
 int a;
 int Add(int a, int b)
 {
 return a+b;
 }
}

命名空间是可以嵌套的：

namespace N // N为命名空间的名称，可以换成任意名称
{
 // 命名空间中的内容，既可以定义变量，也可以定义函数
 int a;
 int Add(int a, int b)
 {
 return a+b;
 }
}
 
   namespace N1//N1嵌套进了N
   {
      int c;
      int d;
      int Sub(int left, int right)
      {
      return left - right;
       }
    }
}

同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。
但是不能在相同命名空间中定义同一个变量：

注意：一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中。
也就是说，从域的外面无法直接使用域里面的内容。

3.2.命名空间使用

要想使用命名空间中的内容，有以下三种方式：

1. 加命名空间名称及作用域限定符

这里命名空间名称为N，作用域限定符为两个英文的冒号::
这种方式非常麻烦，因为每个地方都要指定作用域名称和限定符，但是这种方式是最规范的。

2. 使用using将命名空间中成员引入（在项目中会经常使用）

这种方式可以将命名空间中部分常用的内容引入全局域。
这种方式相当于第一种和第三种方式的折中，使用起来更灵活，因此在项目中会经常使用。

3. 使用using namespace 命名空间名称引入（在规范的项目工程中不推荐使用）

使用这种方式以后，命名空间中所有的内容都可以使用（嵌套的命名空间除外）
这种方式相当于把N整个展开，相当于N作用域中的内容都到全局域中了。

但是这种方法有很大的弊端，因为把N整个展开以后，N中的内容到了全局域，那就会发生命名冲突。所以在规范的项目工程中不要使用，但在平时的练习中为了方便可以使用。

3.2.1.嵌套命名空间的使用

对于嵌套的命名空间中内容的使用与上面类似

但是对于上面的第三种方案，直接展开N并不会把M也展开：

而是应该展开N作用域下的M

从上面的内容就可以明白，using namespace std;这句话就是为了展开std作用域下的内容，而这个作用域的内容就是输出符号cout和换行符号endl

---

四、C++的输入和输出

C++的输入和输出是在头文件iostream（i（in）o（out）流（stream））下的std作用域中，分别为cout和cin。
它们并不是函数，而是ostream和istream类型的全局对象，对运算符>>和<<进行了重载。

相比于C语言中的printf和scanf，cout和cin可以自动识别类型，不需要加%p %d %s等数据格式控制符号。

---

五、缺省参数

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

比如：

5.1.缺省参数的分类

根据函数参数缺省的多少可以分为全缺省参数和半缺省参数两类。

1. 全缺省参数

void fun(int a = 10, int b = 20, int c = 30) 
{

}

2. 半缺省参数（部分参数缺省）

void fun(int a, int b = 20, int c = 30) 
{

}

注意：

1. 半缺省参数必须从右往左依次来给出，不能间隔着给。否则调用函数时传入的实参就会无法匹配对应的形参。
2. 缺省参数不能在函数声明和定义中同时出现。因为如果声明与定义同时给出缺省参数，编译器就无法确定到底该用哪个缺省值。

3. 缺省值必须是常量或者全局变量

缺省参数函数相比于普通的函数调用时更灵活，比如在栈的初始化时可以通过传入指定的参数开辟对应大小的内存空间，如果不指定参数则开辟默认大小。

---

六、函数重载

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

C语言不允许定义同名的函数，但是C++可以，不过这些函数参数的类型或者个数或者不同类型参数的顺序必须不相同。以下面的例子为例：

#include<iostream>
using namespace std;
int Add(int a, int b) 
{
	return a + b;
}
int Add(double a, double b) 
{
	return a + b;
}
int Add(int a)
{
	return a;
}
int Add(int a, double b)
{
	return a + b;
}
int Add(double a, int b)
{
	return a + b;
}
int main()
{
	Add(10, 20);
	Add(10.0, 20.0);
	Add(10);
	Add(10, 20.0);
	Add(10.0, 20);
	return 0;
}

但是有时候函数重载加上缺省参数可能会造成错误：

这种情况构成函数重载，但两个函数都匹配，编译器不知道调用哪个函数。

6.1.函数重载的原因

为什么C语言不支持函数重载，而C++是支持的呢？C++底层是如何支持函数重载的呢？

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

这几个运行阶段在 C语言预处理中有提到。

1. 实际我们的项目通常是由多个头文件和多个源文件构成，而通过我们C语言阶段学习的编译链接，我们可以知道，【当前a.cpp中调用了b.cpp中定义的Add函数时】，编译后链接前，a.o的目标文件中没有Add的函数地址，因为Add是在b.cpp中定义的，所以Add的地址在b.o中。
2. 链接阶段就是专门处理这种问题，链接器看到a.o调用Add，但是没有Add的地址，就会到b.o的符号表中找Add的地址，然后链接到一起。
3. 那么链接时，面对Add函数，连接器会使用哪个名字去找呢？这里每个编译器都有自己的函数名修饰规则。

在Linux下对俩重载函数进行编译然后查看符号表

C++重载函数的符号表

为了区分这两个函数，对函数名进行了修饰，函数的参数类型不同，所以两个函数名不同。

在C语言中查看一个函数符号表，可以看到直接使用函数的名称：

我们可以看出C语言的函数修饰后名字不变。而C++的函数修饰后变成【_Z+函数长度+函数名+类型首字母】

通过这里就理解了为什么C语言没办法支持重载，因为同名函数没办法区分。而C++是通过函数修饰规则来区分，只要参数不同，修饰出来的名字就不一样，就支持了重载。 另外也理解了，为什么函数重载要求参数不同，而跟返回值没关系，因为返回值不影响修饰出来的名字。

6.2.extern “C”

由于C语言和C++对函数的命名规则不相同，所以C语言无法使用C++编译的函数，这时候只需要按照C语言规则来编译即可。
有时候在C++工程中可能需要将某些函数按照C的风格来编译，在函数前加extern "C"，意思是告诉编译器，将该函数按照C语言规则来编译。相应的该函数将无法进行重载。

---

七、引用

语法：

类型& 引用变量名(对象名) = 引用实体（变量）；

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。但是在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。

可以对同一块空间进行多次引用，这也就意味着这块空间有多个别名。

7.1.引用的特性以及引用和指针的区别

引用和指针的不同点:

1. 引用在定义时必须初始化，指针没有要求可以不初始化。
2. 引用在初始化引用一个变量后，就不能再引用其他变量。而指针可以在任何时候指向任何一个同类型的变量。
3. 没有NULL引用，但有NULL指针
4. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)
5. 引用自加即引用的变量增加1，指针自加是指针向后偏移一个类型的大小
6. 指针可以有多级，但是引用没有多级。
7. 访问变量的方式不同，指针需要显式解引用，引用则是直接使用别名即可。
8. 引用比指针使用起来相对更安全。
9. 一个变量可以有多个引用，也可以有多个指针指向它。

7.2.常引用

对于被const修饰的变量如果使用非const引用则会报错：

这里类型虽然相同，但是a只有读的权限没有写的权限，ra读写权限都有，所以ra引用a属于权限放大，这是不可以的。

但是反过来非const修饰的变量使用const引用则没问题：

因为这属于权限缩小，是可以的。

引用不能引用常量，如果要引用常量必须要加const，因为常量的权限是只读，引用的权限是读和写，必须用const使引用权限缩小：

对于类型不同的变量进行引用要加const：

因为类型不同的变量赋值会产生临时变量，这个临时变量是不能修改的，所以要用const修饰

7.3.引用的使用场景

1. 做函数的参数

void Swap(int& a, int& b) 
{
 int temp = a;
 a = b;
 b = temp; 
 }
 int main()
{
   int a=10,b=20;
   Swap(a,b);
   return 0;
}

2. 做函数的返回值

int& Add(int a, int b) 
{
 int c = a + b;
 return c; }
int main()
{
 int& ret = Add(1, 2);
 Add(3, 4);
 cout << "Add(1, 2) is :"<< ret <<endl;
 return 0; }

如果函数返回时，出了函数作用域，如果返回对象还未还给系统，则可以使用引用返回，如果已
经还给系统了，则必须使用传值返回。
这里c的空间已经还给系统了，但是c对应的空间还没有被修改，ret就是c空间的别名，第二次调用Add，c空间被修改为了7。

7.4.传值、传引用的效率问题

以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低。
而引用由于没有发生临时拷贝，所以效率很高。

所以当参数和返回值是比较大的变量时，传引用传参和传引用做返回值可以提高效率。当然传引用做返回值的前提是返回值对应的空间没有被释放。

7.5. 引用的底层实现原理以及引用类型参数的函数重载

引用本身是一个指针常量，具体实现可以参考下面这篇文章C++ 引用的本质。
引用的本质是指针常量，但是引用却可以和指针实现函数重载（按理来讲既然都是指针，参数类型相同将无法实现重载）。这是因为编译器在编译的时候将指针和引用当成了两种不同的参数，因此它们最终的符号表不相同。实际上，指针类型和非指针类型的也会被编译器当成不同的类型：

---

八、内联函数

以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数压栈的开销，内联函数提升程序运行的效率。

使用inline修饰：

不使用，调用Add函数：

8.1.内联函数的特性

1. inline是一种以空间换时间的做法，省去调用函数额开销。所以代码很长或者有循环/递归的函数不适宜使用作为内联函数，因为代码变多了会导致可执行程序变大，执行程序内存消耗变多。
2. inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归等，编译器优化时会忽略掉内联。
3. inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。

8.2.宏的优缺点

优点：

1. 增强代码的复用性。
2. 提高性能。

缺点：

1. 不方便调试宏。（因为预编译阶段进行了替换）
2. 导致代码可读性差，可维护性差，容易误用。
3. 没有类型安全的检查 。

C++使用了下面两种方式替换宏：

1. 常量定义换用const
2. 函数定义换用内联函数

8.3宏和内联函数的区别

1. 内联函数在编译时展开，宏在预处理时进行替换；
2. 内联函数直接嵌入到目标代码中，宏是简单的做文本替换；
3. 内联函数有类型检测、语法判断等功能，而宏没有；
4. inline函数是函数，宏不是；
5. 宏定义时要注意书写（参数要括起来）否则容易出现歧义，内联函数不会产生歧义；

8.4. 内联函数分文件编译报错的原因

如果使用函数内联，则必须在包括的头文件中实现内联函数。如果分文件编译则会报错，具体原因可以查看下面这篇博客：
内联函数inline分文件编译报错的原因

---

九、C++中auto关键字

在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量，但遗憾的是一直没有人去使用它。
C++11中，标准委员会赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。

也就是说类型声明成auto，编译器会根据赋值的类型自动推到被auto声明变量的类型：

使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto的实际类型。因此auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译期会将auto替换为变量实际的类型。

9.1.auto使用规则

1. 用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&
2. 当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。
3. auto不能作为函数的参数，因为声明的时候编译器不知道参数是什么类型
4. .auto不能直接用来声明数组，因为推导不出数组是什么类型

9.2.auto基于范围的for循环

对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此C++11中引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。

for (auto e : arr)的意思是将数组arr中的内容依次取来赋值给变量e，这样在for循环中就可以输出e的内容也就是数组中的内容了。
另外如果想要改变数组中的内容，就得加&，因为无法直接通过e改变数组的内容。

另外for循环迭代的范围必须是确定的。

所以arr必须是一个数组，如果将它传入函数中，那arr会降为成指针，这个指针的范围是不确定性的：

---

十、nullptr表示空指针

NULL实际是一个宏，在传统的C头文件(stddef.h)中，可以看到如下代码：

#ifndef NULL
#ifdef __cplusplus//条件编译
#define NULL 0//在C++中NULL是0
#else
#define NULL ((void *)0)//在C语言中NULL是一个指针
#endif
#endif

所以在C++中，编译器默认情况下将NULL看成是一个整形常量，如果要将其按照指针方式来使用，必须对其进行强转(void *)0。

为了方便，后续可以用用nullptr代替NULL，nullptr就是空指针(void *)0