前言

C++出现的本质就是解决C语言的一些不足和缺陷，由于新添加的内容过多，从而生成了一门独立的语言，下面我们来介绍一下C++和C原因呢基础语法的不同。

1.输入输出

在这里只是简单介绍其用法。
在C语言中，scanf和printf使用时需要%d %s等，比较麻烦，因此C++实现了cin和cout来使输入输出更加简单。

使用事项：
1.输入使用cin,输出使用cout，cin相当于C语言中的scanf，cout相当于C语言中的cout
2.包含头文件
3.使用命名空间std

#include<iostream>
using namespace std;
int main()
{int i = 0;cin >> i;cout << i << endl; //endl相当于C语言中的\n，表示换行
}

2.命名空间

在C语言中，函数和后面要学到的类都是大量存在的，这些变量、函数和类的名称将都存在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的。无论是变量命名还是函数命名都不能和C语言的关键字相同，比如用int类型来定义rand，在C语言中就会报错，因为其和库函数中的rand函数名重定义。

2.1命名空间的理解：

如何理解命名空间？命名空间就相当于给这一块地方确定主人。
比如有一个小区，在C语言中就相当于这个小区最开始是没有主人的，如果有人先来霸占了这个小区，那么别人就不能再来抢占这个房子，这个小区只归这一个财大气粗的老板拥有，这个小区里面的东西就全部归这个老板所有，这就和C语言中中的命名冲突问题相同。而在C++中，就好比如这个老板将小区中的房子进行出租（可以将所有的区域划分），那么如果有人买了这个房子，这个房子就归属于买家，而被购买房子中的物品就属于卖家。比如有相同的电视，就可以通过是户主的还是老板的来区分开来，这样就可以拥有相同的东西（即变量和方法）。

特点：
通过上述解释可以理解
1.可以定义同名的命名空间，最终编译器会进行合并
可以理解一个人可以购买多个房间，如果把所有房子都卖了，那么钱都会给到原户主
2.命名空间可以嵌套
可以理解为这个房子中其中一个是孩子的，一个是父母的。

编译器的搜索原则：
先局部再全局，如果指定直接去指定域内搜索

2.2命名空间的使用方式

方式一：
加命名空间以及域访问限定符
就相当于指定是哪一家的什么物品。

namespace A
{int a = 0;int add(int x, int y){return x + y;}
}int main()
{cout << A::add(1,3) << endl;
}

方式二：使用using将命名空间中需要使用的某个成员引入
引入后就可以不需要添加访问限定符,可以更加简洁

using  A::add;
namespace A
{int a = 0;int add(int x, int y){return x + y;}
}int main()
{//cout << A::a << endl; //由于未引入，会报错cout << add(1,3) << endl;
}

方式三：使用using namespace 命名空间名称将命名空间所有成员引用

using namespace A;
namespace A
{int a = 0;int add(int x, int y){return x + y;}
}
int main()
{//cout << A::a << endl;cout << a << endl;cout << add(1,3) << endl;
}

注意：using namespace std
std是C++中的库的命名空间，将其放开才可以使用C++中的库函数，如cin和cout。

3.缺省参数

3.1概念：

缺省参数是声明或定义函数时为函数的参数指定一个缺省值。在调用该函数时，如果没有指定实参则采用该形参的缺省值，否则使用指定的实参。
可以理解为你给我就要，你不给我也有。

3.2分类：

全缺省参数：所有的参数都给了缺省值

void print(int x = 5, int y = 10, int z = 20)
{cout << "x:" << x << endl;cout << "y:" << y << endl;cout << "z:" << z << endl;
}

半缺省参数：部分参数给出了缺省值

半缺省函数注意事项：

1.只能从右往左依次给缺省值，不能跳跃给

//会报错
void print(int x, int y = 10, int z)
{cout << "x:" << x << endl;cout << "y:" << y << endl;cout << "z:" << z << endl;
}//正确
void print(int x, int y = 10, int z = 20)
{cout << "x:" << x << endl;cout << "y:" << y << endl;cout << "z:" << z << endl;
}

2.缺省参数不能在函数声明和定义同时出现，应该给在函数定义处
为了防止两处的缺省值不同导致编译器不能分辨

3.3使用案例：顺序表的初始化

如果我们已经知道栈的大小的大致范围，我们可以在初始化时直接开辟足够多的空间，这样就能减少后面的扩容次数。

//seqList.h
typedef struct seqList
{int* a;int size;int capacity;
}SL;//原始版本，申请的空间定死
//void Init(SL* psl) 
//{
//	psl->a = (int*)malloc(sizeof(int) * 4);
//	psl->size = 0;
//	psl->capacity = 4;
//}void Init(SL* psl, int n = 4);//seqList.cpp
void Init(SL* psl, int n)
{psl->a = (int*)malloc(sizeof(int) * n);psl->size = 0;psl->capacity = n;cout << n << endl;
}int main()
{SL s;Init(&s); //不指定参数，n默认取4Init(&s, 100); //指定参数 ，n取100return 0;
}

4.函数重载

在C++中支持实现函数名相同的函数

4.1参数重载类型类型：

1.参数类型不同
2.参数个数不同
3.参数类型顺序不同
如果参数个数相同时，但是参数类型不同，那么参数顺序不同也会构成函数重载
4.注意：函数参数相同，但是返回类型不同不构成函数重载

//原函数
int add(int x, int y)
{return x + y;
}
//参数类型不同
double add(double x, double y)
{return x + y;
}
//参数个数相同，类型相同，参数顺序不同
int add(double x, int y)
{return x + y;
}
int add(int x, double y)
{return x + y;
}
//参数个数不同
int add(int x, int y,int z)
{return x + y + z;
}
//不构成重载
double add(int x, int y)
{return x + y;
}

5.引用

5.1概念

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。
比如：李逵，江湖上人称"黑旋风"。"黑旋风"和李逵指的是同一个人，只是两种不同的叫法。
语法：类型& 引用变量名(对象名) = 引用实体；

int i = 0;
int& b = a; //b是a的引用

5.2特性

1.引用在定义时必须初始化
2.一个变量可以有多个引用
3.引用不能被修改

	//int& d; 引用必须初始化，否则报错 int a = 0;int& b = a;  //b是a的引用int& d = a;cout << b << endl;int c = 3;b = c; //把c赋值给b，而不是让b成为c的别名cout << b << endl;

5.3常引用

void func(const int& x)
{
}int main()
{int a = 0;//int& b = a; //权限平移//int& b = 10; //权限放大,会报错 10具有常性const int& b = 10;//int& c = 10 + a; //表达式的返回值为临时变量，临时变量具有常性const int& c = 10 + a;//类型转换会产生临时变量，临时变量具有常性double d = 1.12;int e = d; //产生int类型的临时变量，来接收d的整型部分，再赋值给e//int& f = d; //报错，权限放大，而不是因为类型不同const int& f = d;func(10); //如果函数参数不加const修饰，权限放大，会报错return 0;
}

总结：
1.const修饰的变量只能实现权限缩小和平移，不能实现权限放大
2.临时变量具有常性，在类型转换时会有类型提升和截断。

5.4使用场景

1.做参数
在C语言中，如果要修改当前变量则会传入指针做参数，现在可以直接使用引用作为参数修改变量。
2.做返回值
不能返回局部变量的引用，可以返回静态，全局变量的引用，因为这两个出了该函数作用域后不会销毁。
优点：
1.可以修改返回的对象
2.可以减少拷贝，提高效率

int& Count()
{static int n = 0;n++;// ...return n;
}int& Add(int a, int b)
{int c = a + b;//c是临时变量，出了作用域就会销毁，返回它的引用则会产生野引用return c;
}
int main()
{int& ret = Add(1, 2);Add(3, 4);cout << "Add(1, 2) is :" << ret << endl; //输出值是随机值return 0;
}//顺序表获取pos位置元素
int& getElement(SL& psl, int pos)
{//传入的是引用，数组是malloc出来的，不会销毁，所以可以实现可读可写return psl.a[pos];
}

5.5效率比较

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

5.6使用实例

void Init(SL& sl, int n)
{sl.a = (int*)malloc(sizeof(int) * n);sl.size = 0;sl.capacity = n;cout << n << endl;
}int& add(int x, int y)
{//返回局部变量的地址,会出现野引用int sum = x + y;return sum;
}void push(SL& psl, int x)
{//扩容...psl.a[psl.size++] = x;
}
int& getElement(SL& psl, int pos)
{//传入的是引用，数组是malloc出来的，不会销毁，所以可以实现可读可写return psl.a[pos];
}
int main()
{SL s;Init(s, 100);push(s, 1);push(s, 2);push(s, 3);push(s, 4);for (int i = 0; i < 4; i++){cout << s.a[i] << " ";}cout << endl;for (int i = 0; i < 4; i++){getElement(s, i) *= 2;cout << s.a[i] << " ";}return 0;
}

5.7引用和指针的比较

语法：

1.引用不会再开辟空间，没有独立空间，和其引用实体共用同一块空间。指针会开辟空间，来存储变量的地址
2.引用不可以修改指向，指针可以
3.引用必须初始化，但是指针可以不初始化
4.没有NULL引用，但有NULL指针
5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数
6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
7. 有多级指针，但是没有多级引用
8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理
9. 引用比指针使用起来相对更安全

底层：

在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。
观察以下代码的汇编语言：

int main()
{int a = 0;int& b = a;b = 20;int* p = &a;*p = 20;return 0;
}

汇编语句：

可以观察到引用的底层是使用指针实现的。

6.内联函数

6.1概念语法：

语法：在函数前面加上inline即可
概念：以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数调用建立栈帧的开销，内联函数提升程序运行的效率。

inline int add(int x,int y)
{return x + y;
}

//inline int add(int x, int y)
//{
//	return x + y;
//}int add(int x, int y)
{return x + y;
}int main()
{int ret = add(1, 3);return 0;
}

6.2特性

1.如果编译器将函数当成内联函数处理，在编译阶段，会
用函数体替换函数调用。减少了函数栈帧的创建和销毁。
2.内联函数是一种以时间换空间的行为，如果代码比较大使用内联可能会使目标文件变大。
3.内联函数不能定义和声明分开。
会产生链接错误，内联函数被展开，就没有函数的地址，在链接过程中找不到。
4. inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。

使用前后对比：
没有使用内联函数：

使用内联函数：

从上面我们可以看出，并没有调用函数，而是将函数转化成指令，避免了建立函数栈帧。

6.3宏和内联的区别

宏：宏是在预处理阶段进行文本的替换，这样会有一些问题
优点：
1.在预处理阶段直接替换，提高性能
2.增强代码可读性
缺点：
1.不方便调试宏。（因为预编译阶段进行了替换）
2.导致代码可读性差，可维护性差，容易误用。
3.没有类型安全的检查
4.宏不能

#define mul(x,y) x * y
//#define mul(x,y) (x) * (y)
#define square(x) x * x
int main()
{//宏不能按值传递int x = mul(1, 3);//输出结果为3int y = mul(2 + 3, 4);//如果不加括号，输出结果为14，与我们预期的结果不同//替换后结果：2 + 3 * 4 = 14//期望结果：(2 + 3) * 4 = 20//需要加括号int a = 2;int z = square(a++);//期望的结果：a只自增一次 z = 2 * 2 = 4 , a =3//替换后的结果: a自增了两次 (a++) * (a++) = 4 , a = 4cout << a << endl; //输出4cout << x << " " << y << " " << z << endl;return 0;
}

在C++中我们可以使用以下来替代宏：
1.对于常量定义：const，enum
2.对于短小函数定义：inline

7.auto关键字（C++11）

auto可以用来实现类型的自动辨识。我们可以在类型比较复杂时使用，比如函数指针或者以后更复杂的情况使用。

void func(int x, int y)
{
}
int main()
{auto x = 1;void (*p) (int, int) = func;auto m = func; //可以自动识别类型return 0;
}

8.基于范围的for循环（C++11）

基于范围的for循环可以帮我们实现判断结束和自增，相比于以前的for循环可以更加方便，尤其在后期学习了容器等内容后，通过基于范围的for循环可以方便许多。

8.1语法：

for (数据类型 e : array)
{
}

array就是需要打印的数组，e就相当于一个中间变量，用来存储数组中的值。如果我们需要修改，则可以使用引用。

8.2实例：

int main()
{int a[] = { 1,4,3,6,8,3,7 };//原始方法打印for (int i = 0; i < sizeof(a) / sizeof(int); i++){cout << a[i] << " ";}//1 4 3 6 8 3 7cout << endl;//基于范围的for循环for (auto e : a){cout << e << " ";}//1 4 3 6 8 3 7cout << endl;for (auto e : a){e *= 2;cout << e << " ";}//2 8 6 12 16 6 14cout << endl;for (int i = 0; i < sizeof(a) / sizeof(int); i++){cout << a[i] << " ";}//1 4 3 6 8 3 7cout << endl;//加上引用就可以修改数组的值for (auto& e : a){e *= 2;cout << e << " ";}//2 8 6 12 16 6 14cout << endl;for (int i = 0; i < sizeof(a) / sizeof(int); i++){cout << a[i] << " ";}//2 8 6 12 16 6 14return 0;
}

9.指针控制nullptr（C++11）

在C++中，对于NULL的定义为0，而不是指针，通过以下打印结果可以得出。

void func(int x)
{cout << "func(int x)" << endl;
}
void func(int* p)
{cout << "func(int* p)" << endl;
}
int main()
{func(1);func(0);func(NULL);func(nullptr);return 0;
}

输出结果如下：

func(int x)  
func(int x)  
func(int x)  
func(int* p)

以上就是本次所有内容，谢谢观看。