初识C++ - 技术栈

🌈初识C++

一段C++版的hello world

C++是在C的基础之上，容纳进去了面向对象编程思想，增加了许多有用的库，也弥补了许多C语言的不足。

🌈命名空间

来解决C语言明明冲突的问题。

☀️C语言的命名冲突问题

当在C语言中定义一个名叫rand的变量，可能程序会出错，因为在stdlib.h库中，rand是一个函数，命名冲突了：

☀️C++命名空间与域作用限定符

🎈1.对命名空间内变量的访问

定义一个名叫bit的命名空间，该空间内部有一个叫rand的变量，当我想使用该变量时，就用"空间名+域作用限定符+变量名"的方式"，即"bit :: rand"，当rand前面什么都没有时，默认从全局变量中找rand，即rand函数。

🎈2.命名空间内可以放变量、函数、结构体等，都用 : : 符号来限定。

🎈3.命名空间的内部嵌套

如果同一个命名空间内部两名称冲突，那就在该空间内继续嵌套空间，隔开冲突的名称。

假设大空间bit内部包含了两个小空间bit1和bit2，此时对小空间的访问方式是"大空间+小空间+域作用限定符+变量名"，对bit1空间内访问是"bit : : bit1: : rand"。

🎈4.合并命名空间

同一个文件的多个位置出现同一个命名空间，或多个文件中出现同一个命名空间，编译器会将他们合并。

例如：Stack.h文件的bit空间内声明了两个函数，Stack.cpp文件中的bit空间内是这两个函数的定义，Test.cpp文件中用域作用限定符对函数进行访问。由于编译器的合并命名空间功能，从而也可以实现分文件操作。

🎈5.默认指定展开

（1）整体展开

即默认指定全部命名空间。

如果要用bit空间内的变量、函数等，还要每次都要指定bit空间，即写"bit : : (...)"太麻烦了，而如果设置默认访问bit空间，即默认使用的每一个函数或者变量都是bit空间中的，就不需要麻烦的写"bit : : (...)"了。

指定命名空间语法：using namespace （空间名）

例：展开指定C++标准库定义的命名空间std：

注：工程项目不要展开std，容易冲突，日常练习可以。最安全的方式是指定展开我们自己创建的命名空间，需要哪个展开哪个。

（2）部分展开

即默认指定命名空间内部分的变量、函数等。全部展开风险太大，部分展开可以规避风险。

cout是C++的输出流，cin是输入流，<<是流插入运算符，>>是流提取元运算符，都储存在空间std中。当我们不全部展开，只展开部分常用的，就可以在规避风险的同时实现便利。

例：部分展开前后对比：

当std不是默认指定空间时，用cout输出变量a和b:

太麻烦，指定cout为默认访问：

🌈C++输入&输出

cout是输出（流输出），cin是输入（流提取），cout、cin都是定义在头文件iostream中的。

☀️使用cout和cin打印与输入数据

将std库中的cout设为默认后，直接使用：

☀️C++可以兼容C

目前还不知道怎样用C++控制数据精度，可以借助C语言打印精度更高的数据：

🌈缺省参数

☀️缺省参数概念：

缺省参数是声明或定义函数时为函数的参数指定一个缺省值。调用时可传参也可不传参，不传参时，参数值就是指定的缺省值。缺省值必须是常量或者全局变量。

☀️缺省参数的声明与定义

当函数既有声明又有定义时，缺省参数不可以在声明和定义中都出现，防止两个参数值不一样。也不能只在定义中出现声明中不出现，这样包含头文件时会不知道声明中的参数是几。只能单独在声明中出现。

.h文件中的声明里需要出现缺省值：

.cpp文件中的定义里不可出现缺省值：

☀️缺省参数的分类

🎈1.全缺省参数

所有参数都是缺省参数，声明时需要指定默认值：

c 复制代码

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

🎈2.半缺省参数

只有后半部分参数是缺省参数：

c 复制代码

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

注：半缺省参数必须从右往左依次来给出，不能从左往右给，也不能间隔着给。（如果从前往后设置缺省参数或者间隔着设置，那么编译器会不知道哪个对应的是缺省参数）

☀️缺省参数应用

比如在栈初始化申请空间时，不论知不知道要多大的空间，都可以用同一个函数。具体方法是使用缺省参数设置缺省值，该值表示默认开辟的空间大小，知道需要多少空间就传参，不知道就不传参使用缺省值。

🌈函数重载

☀️函数重载概念：

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

注：返回值可同可不同，具体取决于返回的数据的类型。

类型不同：

个数不同：

☀️注：函数重载要避免歧义

Add有两个重载函数，第一个的两个参数都是int类型的，第二个的两个参数都是double类型的：

此时，如果一个函数调用为Add(1，2)，则会匹配到Add(int left，int right)；如果一个函数调用为Add(1.1，2.2)，则会匹配到Add(double left，double right)。但是当函数调用为Add(1，2.2)时，既可以匹配到Add(int left，int right)（此时会将第二个参数转换成int类型），也可以匹配到Add(double left，double right)（此时将第一个参数转换成double类型），有了歧义，这时编译器不知道匹配哪一个函数，会报错。

再比如，函数f有两个重载函数，第一个无参数，第二个有一个缺省参数：

c 复制代码

void f()
{
 cout << "f()" << endl;
}
void f(int a=1)
{
 cout << "f(int a)" << endl;
}

此时，如果不传参调用f函数，可以匹配到第一个无参数的f函数，也可以匹配到第二个不传值情况下的缺省函数，产生歧义，编译器报错。不传参时调用存在二义性：

🌈引用（🌟🌟🌟）

☀️一、引用概念：

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

比如：李逵，在家称为"铁牛"，江湖上人称"黑旋风"。那么电脑中的同一块空间就有了三个名字：李逵、铁牛、黑旋风，通过这三个名字都可以找到这块空间。

同一个变量可以有多个别名，即多次引用：

☀️二、C的指针&C++的引用

C的传址调用：调用时需要传地址，函数内部接收到后需要解引用

C++的引用：调用时直接用变量名，函数内部以取别名的方式接收变量

第一个Swap是C语言版本的传地址，第二个Swap是C++版本的引用。第二个Swap函数表示，left是a的别名，right是b的别名，left改变则a改变，right改变则b改变。

🎈1.引用是指针的便捷方式

（1）分析C语言传址调用的不便：

不便一：传值调用只改变形参不改变实参，无法达到对数据的修改。

不便二：传几级指针就需要几级的解引用，如果指针的级数和解引用的级数不匹配，则会出错，而多级指针很容易出现不匹配的错误。

以顺序表传头节点指针为例：

节点的内容存放在结构体SLTNode中 -> 通过结构体指针访问节点 -> 头节点指针是一个一级结构体指针 -> 传参时为了能进入指针内部，需要传一级指针的地址，即二级指针 -> 接收时用二级指针接收

错误的调用方式：

phead是plist的拷贝，形参的改变不影响实参，phead=newnode无法让plist也等于newnode。

正确调用方法：

只有通过取plist的地址，再对该地址解引用，才能让phead的值改变。

（2）用C++的引用解决不便

🌟插入新知识：typedef结构体指针名

当对结构体重命名时，如果名称前有*符号，则该名称代表指向该结构体变量的指针名称。比如：

PSLTNode是结构体指针名，PSLTNode = &SLTNode。

--- --- --- --- --- --- --- --- ---👻分割线👻 --- --- --- --- --- --- --- --- ---

使用引用方式，传参时传结构体指针名，接收参数时用一个别名接收，就可大大简化传地址的不便：

节点名称：STLNode

节点指针：STLNode* 。STLNode*=PSTLNode

（直接在节点的基础上对结点指针重命名）

在之前的基础上有两方面的改动：

1.将所有STLNode*替换成PSTLNode

2.用引用的方式将结点指针类型的变量起别名为phead，即用&PSTLNode phead的方式接收传来的参数。

🎈2.指针不可被引用替代的方面

（1）引用必须初始化，指针可以是NULL

引用必须初始化，就是说明起的是谁的别名。不能人还没有呢就先来个别名。

（2）引用不可以改变指向，指针可以

值变，地址不变，说明没有改变c的指向，只改变了c里面的值。只能给A增加或更换别名，不能把A的别名拿着说这是B的别名。

由于C++无法改变指向即地址，因此数据结构的某些部位如链表还是要用指针。比如在链表中插入一个节点，此时需要改变指针的指向，无法用引用的方式完成。

🎈3.总结引用和指针的异同点

（1）相同点

引用和指针的底层都开辟空间了。

（2）不同点

1.引用概念上定义一个变量的别名，指针存储一个变量地址。

引用在定义时必须初始化，指针没有要求。
引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体。即引用不可以改变指向，指针可以。
没有NULL引用，但有NULL指针。
在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)。
引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小。
有多级指针，但是没有多级引用。
访问实体方式不同，指针需要显式解引用，引用编译器自己处理。
引用比指针使用起来相对更安全。

☀️三、引用作参数、引用作返回值

🎈1.做参数，方便好理解

🎈2.做返回值

（1）引用返回的风险

引用返回的本质是野指针：

返回值原本在函数的栈帧中有一席之地，但函数运行完被销毁了，返回值所在的空间也被销毁了（被销毁不是说空间消失了或不能用了，意思是这片空间不受管辖，可以随意被分配给其他地方装载其他值）。引用返回，返回的是变量n的别名，通过该返回值的别名找到这块不受管辖的空间，就如同野指针。

对比传值返回：函数调用结束，返回的变量也跟着销毁，所以实际返回的不是变量本身，而是变量的拷贝。

说明在vs下，销毁栈帧不会换成随机值，在被其他值覆盖前保持之前函数在此处放的值。其他编译器下不一定。

（2）引用返回的正确用法

在被返回的值前加static，被static修饰的局部变量只会被初始化一次。

①此时的ret已经和Add(1，2)的返回值绑定：

c 复制代码

#include <iostream>
using std::cout;
using std::endl;
int& Add(int a, int b) {
	static int c = a + b;
	return c;
}
int main() {
	int& ret = Add(1, 2);
	cout << "Add(1,2) is " << ret << endl;
	Add(3, 4);
	cout << "Add(3,4) is " << ret << endl;
}

②在（1）的基础上实现返回值的变动，此时ret和c这块空间内放的任何数据都绑定：

c 复制代码

#include <iostream>
using std::cout;
using std::endl;
int& Add(int a, int b) {
	static int c ;
	c = a + b;
	return c;
}
int main() {
	int& ret = Add(1, 2);
	cout << "Add(1,2) is " << ret << endl;
	Add(3, 4);
	cout << "Add(3,4) is " << ret << endl;
}

☀️四、传值、传引用效率比较

🎈 1.传值调用&传引用调用

测试对比传值调用和传引用调用的时间差异：

c 复制代码

#include <iostream>
using std::cout;
using std::endl;
#include <time.h>
struct A { int a[10000]; };
void TestFunc1(struct A a) {}
void TestFunc2(struct A& a) {}
//也可以不加struct写成:void TestFunc1(A a) {}
//                    void TestFunc2(A& a) {}
void TestRefAndValue()
{
	struct A a;
	// 以值作为函数参数
	size_t begin1 = clock();
	for (size_t i = 0; i < 10000; ++i)
		TestFunc1(a);
	size_t end1 = clock();
	// 以引用作为函数参数
	size_t begin2 = clock();
	for (size_t i = 0; i < 10000; ++i)
		TestFunc2(a);
	size_t end2 = clock();
	// 分别计算两个函数运行结束后的时间
	cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
	cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
}
int main() {
	TestRefAndValue();
	return 0;
}

结论：传引用调用效率高。

🎈2.传值返回&传引用返回

c 复制代码

#include <iostream>
using std::cout;
using std::endl;
#include <time.h>
struct A { int a[10000]; };
A a;
// 值返回
A TestFunc1() { return a; }
// 引用返回
A& TestFunc2() { return a; }
void TestReturnByRefOrValue()
{
	// 以值作为函数的返回值类型
	size_t begin1 = clock();
	for (size_t i = 0; i < 100000; ++i)
		TestFunc1();
	size_t end1 = clock();
	// 以引用作为函数的返回值类型
	size_t begin2 = clock();
	for (size_t i = 0; i < 100000; ++i)
		TestFunc2();
	size_t end2 = clock();
	// 计算两个函数运算完成之后的时间
	cout << "TestFunc1 time:" << end1 - begin1 << endl;
	cout << "TestFunc2 time:" << end2 - begin2 << endl;
}
int main() {
	TestReturnByRefOrValue();
	return 0;
}