C++入门知识

目录

0，前言：C++的产生

一，C++关键字

二，命名空间

 1.命名空间定义

2.命名空间使用

三，C++输入&输出

四，缺省参数

1.缺省参数概念

2.缺省参数分类

五，函数重载

1.函数重载概念

2.C++支持函数重载的原理

六，引用（重点）

0.引用前言

1.引用概念

2.引用的特性

3.常引用

4.使用场景

（1）做参数

（2）做返回值

5.传值和传引用的效率比较

6.指针和引用的区别

七，内联函数

1.概念

2.特性

八，auto关键字（C++11）

1.类型别名思考

2.auto简介

3.auto的使用细则

（1）auto和指针引用结合起来使用

​编辑

（2）在同一行定义多个变量

4.auto不能推导的场景 

（1）auto不能作为函数参数

（2）auto不能用来声明数组

九，基于范围的for循环（C++11）

1.范围for的语法

2.范围for的使用条件

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

（2）迭代的对象要实现++和==的操作。(这里涉及迭代器的知识)

十，指针空值nullptr（C++11）

1.C++98和C语言的指针空值NULL:

2.C++11的指针空值nullptr

---

0，前言：C++的产生

C语言是结构化和模块化的语言，适合处理较小规模的程序。
对于复杂的问题，规模较大的程序时，需要高度的抽象和建模时，C语言则不合适。为了解决软件危机，20世纪80年代，计算机界提出了OOP(object oriented programming:面向对象)思想，支持面向对象的程序设计语言应运而生。
1982年，Bjarne Stroustrup博士在C语言的基础上引入并扩充了面向对象的概念，发明了一种新的程序语言。为了表达该语言与C语言的渊源关系，命名为C++。因此:C++是基于C语言而产生的，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行面向对象的程序设计。

除了面向对象思想的引入，C++还针对C语言不足的地方进行了改进，同时引入了许多有用的库，以及编程范式等。

 本篇博客主体介绍C++针对C语言的不足所补充的语法知识，以此从C语言过渡到C++，为以后的类和对象学习打下基础。

C++针对C语言的哪些不足之处进行了优化呢？主要为以下几个部分：

作用域方面，IO方面，函数方面，指针方面，宏方面

一，C++关键字

C++共计63个关键字，C语言32个关键字

二，命名空间

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

 1.命名空间定义

定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{}中即为命名空间的成员。

namespace N1
{
	//变量
	int a = 0;
	int b = 1;

	//函数
	int Add(int left, int right)
	{
		return left + right;
	}

	//类型
	struct Node
	{
		struct Node* next;
		int val;
	};

	//嵌套
	namespace N2
	{
		int c = 0;
		int d = 0;
	}
}

注意几点：

• 命名空间的名字一般是开发中的项目名字作为命名空间的名字。
• 命名空间中可以定义变量，函数，类型，包括以后学的类。
• 命名空间可以嵌套。
• 同一个工程允许存在多个相同名字的命名空间，编译器最终会合成在一个命名空间中。

2.命名空间使用

针对上面所写的命名空间，我们发现直接使用命名空间的某个成员会报错：未声明的标识符

命名空间的使用有三种方式：

• 加命名空间以及作用域限定符：：         （指定命名空间）
•  使用using将命名空间中的某个成员引入（展开命名空间）
• 使用using namespace 命名空间名称 将整个命名空间引入（展开命名空间）

int main()
{
	printf("%d\n",N1::a);

	return 0;
}

using N1::a;
int main()
{
	printf("%d\n",a);

	return 0;
}

using namespace N1;
int main()
{
	printf("%d\n",a);

	return 0;
}

三，C++输入&输出

学习一门语言，怎么能少了hello world呢？

那么C++是如何hello world的呢？

#include 
using namespace std;
int main()
{
	cout << "hello world << endl";

	return 0;
}

短短的几行代码，其实有很多知识点在里面的。

说明：

 1.使用cout标准输出对象(控制台)和cin标准输入对象(键盘)时，必须包含头文件以及按命名空间使用方法使用std。
2.cout和cin是全局的流对象（关于类和对象，后面详细介绍），endl是特殊的C++符号，表示换行输出，他们都包含在包含头文件中。
3.<<是流插入运算符，>>是流提取运算符。
4.使用C++输入输出更方便，不需要像printf/scanf输入输出时那样，需要手动控制格式。C++的输入输出可以自动识别变量类型（这个就很方便）。
5.实际上cout和cin分别是ostream和istream类的对象，>>和<<也涉及运算符重载等知识，我们这里只是简单学习他们的使用。
6.早期标准库将所有功能在全局域中实现，声明在.h后缀的头文件中，使用时只需包含对应头文件即可，后来将其实现在std命名空间下，为了和C头文件区分，也为了正确使用命名空间，规定C++头文件不带.h;旧编译器(vc 6.0)中还支持格式，后续编译器已不支持，因此推荐使用+std的方式。

std命名空间的使用方法：

std是C++标准库的命名空间，这个std如何使用更合理呢？

• 在日常练习中，建议直接using namespace std即可，这样很方便。
• using namespace std展开，标准库就全部暴露出来了，如果我们定义跟库重名的类型/对象/函数，就存在冲突问题。该问题在日常练习中很少出现，但是项目开发中代码较多、规模大，就很容易出现。所以建议在项目开发中使用，像std::cout这样使用时指定命名空间或者using std::cout展开常用的库对象/类型等方式。

四，缺省参数

1.缺省参数概念

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

没有传参时，使用参数的默认值。

传参时，使用指定的实参。

我们可以认为参数的默认值就是一个备胎。

2.缺省参数分类

• 全缺省参数（这个在后面的类和对象经常使用，非常方便）

• 半缺省参数（部分缺省，必须要给实参）

 半缺省参数的注意：

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

就比如void Func（int a = 10, int b, int c）

这种写法会报错

 缺省参数的使用注意点：

• 缺省参数不能在声明和定义中同时出现（如果同时出现，恰巧两个位置提供的值不同，编译器无法确认使用哪个缺省值）。我们一般习惯声明中给缺省值，定义中不给缺省值。

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

 

五，函数重载

1.函数重载概念

C++允许在同一个作用域中声明几个功能类似的同名函数，这些函数的形参列表（参数个数或参数类型或类型顺序）不同

函数重载前提：作用域相同，函数名相同。

三个构成重载的条件：

• 参数个数不同
• 参数类型不同
• 参数类型的顺序不同

#include 
using namespace std;

//参数个数不同构成重载
void f1(int a, int b)
{
	cout << "void f1(int a, int b)" << endl;
}

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

//参数类型不同构成重载
void f2(int a)
{
	cout << "void f2(int a)" << endl;
}

void f2(double a)
{
	cout << "void f2(double a)" << endl;
}

//参数类型顺序不同构成重载
void f3(int a, double b)
{
	cout << "void f3(int a, double b)" << endl;
}

void f3(double a, int b)
{
	cout << "void f3(double a, int b)" << endl;
}

int main()
{
	f1(1, 2);
	f1(1);
	cout << endl;
	f2(1);
	f2(1.0);
	cout << endl;
	f3(1, 1.0);
	f3(1.0, 1);


	return 0;
}

注意：返回值不同不构成重载。在后面函数重载的原理做解释。

2.C++支持函数重载的原理

为什么C++支持函数重载，而C语言不支持函数重载呢?
在C/C++中，一个程序要运行起来，需要经历以下几个阶段:预处理、编译、汇编、链接

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

因此可以得出：C++编译完成后，函数名字的修饰发生改变，编译器将函数参数类型信息添加到修改后的名字。而C语言的函数名字没有添加。所有本质就是：函数名的修饰规则不同。

这里也解释了为什么返回值不同不能构成重载，因为函数名修饰时只添加了参数类型的信息，返回值没有。

六，引用（重点）

0.引用前言

许多人在初学C语言时，都会感觉指针比较难，C语言的指针在某些应用场景中的确非常复杂，设计C++的大佬们针对指针的复杂性，就设计了一种新语法进行了优化：引用。

1.引用概念

我们知道，我们每次创建一个变量，就会在内存空间中开辟一块空间。但是引用不同。

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

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

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

2.引用的特性

• 引用在定义时必须要初始化

• 一个变量可以有多个引用

• 引用一旦引用一个实体，就不能引用其他实体

其实这里c = b是有一个歧义，他的意思是c是b的别名，还是把b的值赋给c呢？

答案是后者。

3.常引用

看一下下面几段代码的区别

代码一

int a = 10;

int& ra = a;

代码二 

 const int b = 10;

int& rb = b;

代码三 

int c = 10;

const int& rc = c; 

这些代码有什么区别呢？ 是否正确呢？

 这里我们发现第二个代码有问题，看编译器的报错信息就很容易发现：无法从const int 转化成int&，这里const int转化成int就涉及了权限放大的问题。因为他们都指定同一个变量，所以这个不被允许。

 代码一是权限平移，代码三是权限缩小（int转换成const int），这些都是允许的。

下面三段代码就都涉及了权限放大的问题：

 const int a = 10;

(const) int& ra = a;

 (const) int& b = 10;

 double d = 3.14;

(const) int& rd = d;

补充： 代码三的错误并不是因为类型不同，如果没有引用也是对的。

 这里其实本质还是涉及了权限放大的问题，强制类型转换在底层上会产生一个临时变量，这个临时变量具有常量的属性。类型转换是并不会真的改变原来变量的类型的。

4.使用场景

（1）做参数

引用做函数参数有两个场景：1.输出型参数 2.大对象传参，用于提高效率

输出型参数和输入型参数的区别：输出型参数和输入型参数

#include 
using namespace std;

void Swap1(int& left, int& right)//引用做函数参数
{
	int temp = left;
	left = right;
	right = temp;
}

void Swap2(int* left, int* right)
{
	int temp = *left;
	*left = *right;
	*right = temp;
}

int main()
{
	int a = 1, b = 2;
	Swap1(a, b);
	cout << a << " " << b << endl;
	int c = 1, d = 2;
	Swap2(&c, &d);
	cout << c << " " << d << endl;

	return 0;
}

 我们发现，引用用做函数参数和传地址的效果是一样的，都能够交换。

传指针-->传引用

传二级指针-->传指针的引用

（2）做返回值

引用做函数参数有两个场景：1.修改返回对象（返回值做左值）  2.大对象返回提高效率

在此之前。我们先深入了解一下普通的返回，也就是传值返回。

• 传值返回，其实返回的是返回对象的一份拷贝，（这里和传值传参是一个道理）。
• 不管返回对象是在栈上还是在静态区，传值返回都是生成一个返回对象的拷贝作为函数调用的返回值。
• 为什么要传值返回呢？这是因为函数调用结束后，原来的返回对象在栈区中被销毁了。栈帧结束时，系统会清理栈帧置成随机值。

 接下来介绍一下传引用返回：

传引用返回，返回的是返回对象的别名，和原来的返回对象共用一块空间。

了解了传引用返回，再加上上面传值返回的原因，可以很明显的发现，上面的传引用返回有很大的问题。 

• 在上面的代码中，我们返回的是返回对象c的别名，和c共用一块空间。
• 但是前面说了，函数调用结束后，原来的返回对象（c）在栈中被销毁了，c的这块空间也被收回，此时再返回c的引用，就会再次访问c这块空间，这是非法的。
•  如果函数返回时，出了函数作用域，返回对象已经还给系统了（函数内局部变量），则必须使用传值返回。如果返回对象还在（函数外局部变量，全局变量，静态变量，堆上的），则可以使用传引用返回。
• 总结：不能返回函数内的局部变量的引用

5.传值和传引用的效率比较

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

传引用作为参数或者返回值相比传值，效率就很高。

6.指针和引用的区别

说明他们两个的区别之前，先说一下引用在底层其实就是用指针（指针常量）实现的。

• 引用的本质是一个指针常量。因此引用初始化后就不能改变。int* const ref=&a;
• 内部一旦发现ref是引用，自动执行指针解引用*ref

指针和引用的不同点：

1. 引用在概念上是定义一个变量的别名，指针存储一个变量的地址。
2. 引用在定义时必须初始化，指针没有要求。
3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体。
4. 没有NULL引用，但有NULL指针。
5. 在sizeof中含义不同：引用结果为引用实体的大小，但是指针始终是地址空间所占字节个数（4或8）。
6. 引用自加是引用的实体增加1，指针自加是指针向后偏移一个类型的大小。
7. 有多级指针，但是没有多级引用。
8. 访问实体的方式不同，指针需要解引用，引用编译器自己处理。
9. 引用比指针使用起来更加安全。

七，内联函数

1.概念

我们通过C语言的学习，都知道函数调用都会建立栈帧。

C++引入了一个关键字inline，以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数调用建立栈帧的开销，内联函数提升程序运行的效率。

我们可以通过汇编代码验证一下：

在C语言中也有一种函数在调用时没有栈帧的开销，那就是宏函数。

其实宏函数在使用时是有缺陷的，C++的设计大佬们也就是针对宏函数的缺陷来设计的内联函数。

补充：

宏的缺点：代码可读性差，可维护性差（针对宏函数），复杂；没有类型的安全检查；不方便调试

宏的优点：代码的可维护性高，增强复用性（针对宏常量）；提高效率，减少栈帧建立（针对宏函数） 

其实在C++中，有很多设计都可以替代宏：const，enum，inline

inline几乎解决了宏函数的缺点，也具备宏函数的优点。

2.特性

1.inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用。缺陷:可能会使目标文件变大；优势:少了调用开销，提高程序运行效率。
2. inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建议:将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。
3. inline不可以声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。

补充：在后面类和对象的学习中，我们会学到类中的一个默认的成员函数——默认构造函数，他就是典型的频繁调用并且短小的函数，我们一般直接声明和定义写在一起（在类中定义），此时编译器会把他当做内联函数（不加inline也会当做内联函数）。

八，auto关键字（C++11）

在此之前，先介绍一下C++11

在2003年C++标准委员会曾经提交了一份技术勘误表(简称TC1),使得C++03这个名字已经取代了C++98称为C++11之前的最新C++标准名称。不过由于C++03(TC1)主要是对C++98标准中的漏洞进行修复，语言的核心部分则没有改动，因此人们习惯性的把两个标准合并称为C++98/03标准。

从C++0x到C++11，C++标准10年磨一剑，第二个真正意义上的标准珊珊来迟。相比于
C++98/03，C++11则带来了数量可观的变化，其中包含了约140个新特性，以及对C++03标准中约600个缺陷的修正，这使得C++11更像是从C++98/03中孕育出的一种新语言。相比较而言，C++11能更好地用于系统开发和库开发、语法更加泛华和简单化、更加稳定和安全，不仅功能更强大，而且能提升程序员的开发效率，公司实际项目开发中也用得比较多。

C++11增加的语法特性非常篇幅非常多，比如：列表初始化，变量类型推导，范围for循环，final与override，智能指针，新增加容器---静态数组array，forward_list以及unordered系列，默认成员函数控制，右值引用，lambda表达式，包装器，线程库。
 

1.类型别名思考

在C++中，有些类型名极其变态，比如：

std::map::iterator it=m.begin();

这里的std::map::iterator是一个类型，很显然我们不会写这么长的类型名。

学过C语言很自然能想到用typedef给类型区别名。 但是C++中的某些场合typedef也会出问题。

C++的const修饰的变量必须要初始化：

C++和C语言中const的区别：C语言和C++中const的区别

 此时auto就有用场了。

2.auto简介

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

 注意几点：

• typeid(b).name() 可以得出变量的类型。
• 其实上面场景用auto不合适，一般类型较长时可以用auto自动类型推导。
• auto有两种使用场景：自动推导（类型较长）；范围for循环
• 使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto的实际类型。因此auto并非是一种"类型"的声明，而是一个类型声明时的"占位符"，编译器在编译期会将auto替换为变量实际的类型。

3.auto的使用细则

（1）auto和指针引用结合起来使用

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

（2）在同一行定义多个变量

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

4.auto不能推导的场景 

（1）auto不能作为函数参数

（2）auto不能用来声明数组

九，基于范围的for循环（C++11）

1.范围for的语法

C++98中如果要遍历一个数组，可以按照以下方式进行：

#include 
using namespace std;

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

	for (int* p = array; p < array + sizeof(array) / sizeof(array[0]); p++)
	{
		cout << *p << " ";
	}

	return 0;
}

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

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

	for (auto e : array)
	{
		cout << e << " ";
	}

	return 0;
}

范围for：

自动依次取 array中的数据（不是指针），赋值给e

自动迭代，自动判断结束。

    for (auto* e : array)这种写法是错误的

2.范围for的使用条件

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

对于数组而言，就是数组中第一个元素和最后一个元素的范围;

对于类而言，应该提供begin和end的方法，begin和end就是for循环迭代的范围。

（2）迭代的对象要实现++和==的操作。(这里涉及迭代器的知识)

十，指针空值nullptr（C++11）

1.C++98和C语言的指针空值NULL:

在良好的C/C++编程习惯中，声明一个变量时最好给该变量一个合适的初始值，否则可能会出现不可预料的错误，比如未初始化的指针。如果一个指针没有合法的指向，我们基本都是按照如下方式对其进行初始化:

 

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

可以看到，NULL可能被定义为字面常量0，或者被定义为无类型指针(void*)的常量。
在C++98中，字面常量0既可以是一个整形数字，也可以是无类型的指针(void*)常量，但是编译器默认情况下将其看成是一个整形常量，如果要将其按照指针方式来使用，必须对其进行强转(void*)0。

2.C++11的指针空值nullptr

• 在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的。
• 在C++11中，sizeof(nullptr)与sizeof((void*)0)所占的字节数相同。
• 为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr。