C++入门

开篇：

回顾C语言

你是否感觉到C某些东西感觉设计的很不合理，是否感觉到指针，数据结构很难，很繁杂。

是的，不止你一个人是这样的感觉。

C++祖师爷（本贾尼·斯特劳斯特卢普）也是这样的感觉，他觉得C有很多坑，而且不够完善，所以他开始了打“补丁”补丁一多，嘿!C++就出来了。（注：这里只是引气读者对C++兴趣，具体起源上网自查）

让我们在学习之前先膜拜一下祖师爷。

C++关键字：

C关键字：32个

C++关键字：63个

更多的关键字意味着更多的功能。

命名空间

目的：是对标识符的名称进行本地化，以避免命名冲突或名字 污染

关键字：namespace

作用理解：想象，有儿童类书、哲学类书、各国史书。如果都放在一个箱子里我们不容易快速找到并且偶尔可能会拿错或者放错。所以我们会将不同类型放在不同箱子里并标记好。

同理，对于程序，代码越多就不好整理，且可能会使用错误。所以我们也需要一个“箱子”将他们分开，由此我们产生了namespace

标准格式：

代码：

#include <iostream>

//A1  A2两个不同箱子
//普通命名空间
namespace A1
{
	int a = 1;
	int b = 2;
	int Add(int left, int right)
	{
		return left + right;
	}
}

namespace A2
{
	int a = 3;
	int b = 4;
	int Sub(int left, int right)
	{
		return left - right;
	}
}

//嵌套命名空间
namespace A3
{
	int a = 5;
	int b = 6;
	int Add(int left, int right)
	{
		return left + right;
	}

	namespace A4
	{
		int c = 7;
		int d = 8;
		int Sub(int left, int right)
		{
			return left - right;
		}
	}
}

//相同命名空间->最后会和在同一个命名空间中
//不小心又命名了一个A1
namespace A1
{
	int Double(int num)
	{
		return 2 * num;
	}
}

//常用命名空间内容引入
using A1::a;

//全部开放式，命名空间引入
using namespace A3;

int main()
{
	//命名空间的使用
	//printf("%d \n", a);
	//无法找到
	//有了通常作用域顺序：局部->全局 
	//通过::（作用域限定符）（精准）限定我们要找的类别A1  or A2
	printf("%d \n",A1::a);
	printf("%d \n", A2::a);
	//嵌套
	printf("%d \n", A3::A4::c);
	//同名命名空间
	printf("%d \n", A1::a);
	printf("%d \n", A1::b);
	printf("%d \n", A1::Add(A1::a,A1::b));
	printf("%d \n", A1::Double(A1::a));

	//测试常用命名空间内容引入
	printf("%d \n",a);
	printf("%d \n",A1::Add(a,A1::b));

	//测试全部开放式，命名空间引入
	printf("%d %d\n", a,b);
	printf("%d \n", Add(a,b));

	return 0;
}

//全部开放式，命名空间引入
using namespace A3;
using namespace A4;

int main()
{
	//测试全部开放式，命名空间引入
	printf("%d %d\n", a, b);
	printf("%d \n", Add(a, b));
	printf("%d %d\n", c, d);
	printf("%d \n", Sub(a, b));
	return 0;
}

测试结果：

常用命名空间内容引入：

嵌套+全部开放式

注意：自己练习时，可以使用全部开放式命名空间，项目中，应避免使用，防止全部展开后混乱

由此，全局开放式命名空间引入在嵌套命名空间中他只能解开单独一层，并不会全部解开

当全部解开后结果：

结构体的命名空间：

我们要注意的是为什么要有这个命名空间，是因为害怕有重名的。

所以重点在于重名，而struct是系统自带的他不算重名部分，只有你自己起的两个Data是重名部分

系统重名不用管，命名空间名字只指向自己写的重名部分

结果：

全局展开后出现指定不明确：

总结：

C++输入输出

不要产生太多疑问，刚开始接触我们就慢慢先听先看，慢慢接受。

学C一开始也是hello world 用printf打印也没有产生什么奇奇怪怪的问题吧！这个一样。

endl是换行的意思，等同于“ \n ”;

缺省参数：

缺省参数≈备胎

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

实质：

当没有实参传过来时，函数括号内的起作用

有实参传过来，实参替换掉括号内的备胎。

void TestFunc(int a = 0)
{
 cout<<a<<endl;
}
int main()
{
 TestFunc(); // 没有传参时，使用参数的默认值
 TestFunc(10); // 传参时，使用指定的实参
}

缺省参数分类：

全缺省：

void TestFunc(int a = 10, int b = 20, int c = 30)
{
 cout<<"a = "<<a<<endl;
 cout<<"b = "<<b<<endl;
 cout<<"c = "<<c<<endl;
}

半缺省：

void TestFunc(int a, int b = 10, int c = 20)
{
 cout<<"a = "<<a<<endl;
 cout<<"b = "<<b<<endl;
 cout<<"c = "<<c<<endl;
}

注意：

1.半缺省参数必须从右往左依次来给出，不能间隔着给

2.缺省参数不能在函数声明（.h）和定义（.c）中同时出现

3.在声明（.h）文件中给缺省，另一个定义里（.c++）就不给缺省，优先.h文件给缺省

4,。 缺省值必须是常量或者全局变量

函数重载：

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

图解：

由此可见：主要重点在形参列表

为什么这里和C不一样？

底层上，C++作者将函数名字的修饰发生改变，使得编译器能够完成区分形参列表

引用

定义：

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

标准格式：类型& 引用变量名(对象名) = 引用实体；

理解：一个人有多重身份但是都是同一个人；

注意：引用类型必须和引用实体是同种类型的

代码：

//引用
int main()
{
	int a = 10;
	int& b = a;
	cout << "a = " << a << endl;//10
	cout << "b = " << b << endl;//10
	b = 100;
	cout << "改后：b = " << b << endl;//100
	return 0;
}

特性：

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

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

3. 引用一旦引用一个实体，再不能引用其他实体

常引用：

oid TestConstRef()
{
 //情况1
 const int a = 10;
 //int& ra = a; // 该语句编译时会出错，a为常量
 const int& ra = a;

 //情况2
 // int& b = 10; // 该语句编译时会出错，b为常量
 const int& b = 10;

 //情况3
 double d = 12.34;
 //int& rd = d; // 该语句编译时会出错，类型不同
 const int& rd = d;
}

情况1：const只读int&使得它从只读变成了读写，权限放大了，系统不允许

情况2：int& b,b这个“身份”都不知是谁的身份怎么能放进去10.（空间都没有）

情况3：引用类型必须和引用实体是同种类型的

注意：引用权限能平移和缩小，但不能放大（无法从const只读变成 可修改的）-->适用于指针和引用

static静态-->在静态去存储

const只读

使用场景：

1.做参数

核心：通过形参改变实参->引用

注意：引用不能改变指向，指针可以（如数据结构中指向下一个节点的next）

void Swap(int& left, int& right)
{
	int temp = left;
	left = right;
	right = temp;
}

int main()
{
	int a = 1;
	int b = 2;
	cout << "修改前：a = " << a << " b = " << b << endl;
	Swap(a, b);
	cout << "修改后：a = " << a << " b = " << b << endl;
	return 0;
}

结果：

图解：

2.做返回值

注意：如果函数返回时，出了函数作用域，如果返回对象还未还给系统，则可以使用引用返回，

如果已经还给系统了，则必须使用传值返回。

一般我们函数返回时都是将return 的值传给另一个零时变量，在传到主函数接受变量中去（无static和有都一样）

适合情况：出了作用域，返回变量还在（不影响）就能用传引用返回

此类情况有：

1.静态

2.全局

3.malloc

4.主要看出了作用域在不在

此时你会产生疑问可以传数组吗？

情况1：基本不用

#include <assert.h>
#define N 5


void Change(int(&p)[N])//指针标准格式：int 名称[]
{
	for (int i = 0; i < N; i++)
	{
		p[i] = i;
	}
	for (int j = 0; j < N; j++)
	{
		cout << p[j] << " ";
	}
	cout << endl;
}

int main()
{
	int arr[N] = {11,22,33,44,55};
	for (int j = 0; j < N; j++)
	{
		cout << arr[j] << " ";
	}
	cout << endl;
	Change(arr);

	return 0;
}

结果：

情况2：利用结构体将数组打包进一个变量

#include <assert.h>

#define N 10

typedef struct  AY
{
	int a[N];
	int size;
}AY;
int& ArrInit(AY& ay,int i)
{
	assert(i < N);//防止越界
	//出了作用域还在,因为AY下的结构体是在全局里的,所以能在返回上加&
	//传引用返回 取别名为ay.a[i];只要本体不消灭，别名也就不消灭
	return ay.a[i];
}

//调用者可以修改返回对象
int main()
{
	AY ay;
	for (int i = 0; i < N; i++)
	{
		ArrInit(ay, i) = i * 10;
	}
	for (int i = 0; i < N; i++)
	{
		cout << ArrInit(ay, i) << " ";
	}
	return 0;
}

作用：

1.减少返回时的拷贝

2.调用者可以修改返回对象

引用和指针不同点：

1. 引用在定义时必须初始化，指针没有要求

2. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型 实体

3. 没有NULL引用，但有NULL指针

4. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占 4个字节)

5. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小

6. 有多级指针，但是没有多级引用

7. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理

8. 引用比指针使用起来相对更安全

内联函数(宏的进阶)：

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

直接在.h（声明）里面写，原因：因为inline被展开，就没有函数地址了，链接就会 找不到。

特性：

1.inline是一种以空间换时间的做法，省去调用函数额开销。所以代码很长或者有循环/递归的函数不适宜使用作为内联函数。

2.inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归等 等，编译器优化时会忽略掉内联。

3.直接在.h（声明）里面写

4.常用在频繁使用，流程直接，规模较小上

宏的优缺点：

优点：

1.增强代码的复用性。

2.提高性能。

缺点：

1.不方便调试宏。（因为预编译阶段进行了替换）

2.导致代码可读性差，可维护性差，容易误用。

3.没有类型安全的检查 （与内联主要区别）。

auto关键字(C++11)

注意：

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

auto的使用细则：

1. auto与指针和引用结合起来使用

用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&

int main()
{
	int x = 10;
	auto a = &x;
	auto* b = &x;
	auto& c = x;
	//typeid(a).name() 类型
	cout << typeid(a).name() << endl;
	cout << typeid(b).name() << endl;
	cout << typeid(c).name() << endl;

	*a = 20;
	cout << *a << endl;
	*b = 30;
	cout << *b << endl;
	c = 40;
	cout << c << endl;
	return 0;
}

结果：

2.同一行定义多个变量

当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对 第一个类型进行推导，然后用推导出来的类型定义其他变量。

void TestAuto()
{
 auto a = 1, b = 2; 
 auto c = 3, d = 4.0; // 该行代码会编译失败，因为c和d的初始化表达式类型不同
}

auto不能推导的场景：

1..auto不能作为函数的参数

/ 此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导
void TestAuto(auto a)
{}

2. auto不能直接用来声明数组

void TestAuto()
{
 int a[] = {1,2,3};
 auto b[] = {4，5，6};
}

范围for--语法糖

1.范围for的使用条件：

只对数组有效，

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

范围for在函数中不能使用--原因：函数中传过去的是一个地址，而不是一个数组，再&引用也是对地址的引用

2.语法：

#include <iostream>

using namespace std;

int main()
{

	int array1[] = { 1, 2, 3, 4, 5 };
	for (int i = 0; i < sizeof(array1) / sizeof(array1[0]); ++i)
		array1[i] *= 2;

	for (int* p = array1; p < array1 + sizeof(array1) / sizeof(array1[0]); ++p)
		cout << *p << " ";
	cout << endl;


	int array2[] = { 1, 2, 3, 4, 5 };
	for (auto& e : array2)
		e *= 2;

	for (auto e : array2)
		cout << e << " ";
	cout << endl;
	return 0;
}

图解：

1.可以修改数组内容

2.无法修改数组内容

获取变量类型typeid（）.name（）

指针空值nullptr(C++11)

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

ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif

这里意味着NULL同时能够代表0和无类型指针（void*）的常量

那么就意味着我们在某些时刻去使用是会出错，

如：

void F(int a)
{
	cout << "F(int a) " << endl;
}

void F(int* a)
{
	cout << "F(int* a)" << endl;
}

int main()
{
	F(0);
	F(NULL);

	F((int*)NULL);

	return 0;
}

由结果不难看出，

程序本意是想通过f(NULL)调用指针版本的f(int*)函数，但是由于NULL被定义成0，因此与程序的初衷相悖。

所以我们对NULL进行了补充将两个内容分割开。就产生了nullptr

注意：

1.在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的。

2.sizeof（nullptr、void*、0）所占字节数相同

3. 为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr。