初识cpp【C++】

前言：

C++ 入门 hello world!

#include<iostream>
using namespace std;

int main() 
{
	cout << "Hello World!" << endl;
	return 0;
}

一、 命名空间

1. 命名空间的定义

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

命名空间解决了 C语言中的命名冲突问题

例如：

出现命名冲突的原因：

当然，在引入在第三方库时，C语言也容易出现重定义现象；

解决方法：将命名冲突的变量放到命名空间域中

上图中 namespace lisi 中的 lisi 是 命名空间的名字

• 命名空间中可以定义变量/函数/类型
• 命名空间可以嵌套
• 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中

关于域： 有全局域、局部域、命名空间域、类域。全局和局部域 会影响 生命周期和访问，命名空间域影响访问。

不同的域可以出现相同的变量名，相同域不可以出现相同的变量名

编译器的搜索原则：

在未指定域的情况下，先在当前局部搜索，再去全局域搜索。如果指定域，直接去指定域搜做。

当只有 ::变量 时 默认去全局域搜素该变量

2. 命名空间的使用

(1) 加命名空间名称和作用域限定符

int main()
{
	int z = 10;
	printf("rand = %d\n", lisi::rand);
	return 0;
}

lisi是 命名空间名称 ，:: 是作用域限定符

(2) 使用using将命名空间中某个成员引入

#include<stdio.h>
namespace N 
{
	int a = 10;
	int b = 20;
}
using N::a;
int main() 
{
	int x = 10;
	printf("a = %d\n",a);	
	printf("b = %d\n",N::b);
	return 0;
}

例如： 当我们只想使用 cout 和 cin，只需将这两个进行展开即可

#include<iostream>
using std::cout;
using std::cin;
using std::endl;
int main() 
{
	int a;
	cin >>a;
	cout <<a<< endl;
	return 0;
}

(3) 使用using namespace 命名空间名称 引入

也就是展开命名空间

#include<stdio.h>
namespace N 
{
	int a = 10;
	int b = 20;
}
using namespace N;	//将命名空间展开

int main() 
{
	int x = 10;
	printf("a = %d\n",a);	
	printf("b = %d\n",b);
	return 0;
}

注意：在定义结构体的时候

xx::struct Node head; 这种是不对的。应是 struct xx::Node head;

当我们使用

#include<iostream>
using namespace std;

std 是所有C++库命名空间

当只有#include 时,我们需要指定命名空间

#include<iostream>
int main() 
{
	std::cout << "Hello World!" << std::endl;
	std::cout << "Hello World!" << std::endl;
	std::cout << "Hello World!" << std::endl;
	std::cout << "Hello World!" << std::endl;
	std::cout << "Hello World!" << std::endl;
	return 0;
}

上述一直指定命名空间，感觉有些冗余

这里介绍比较方便的写法 是，将命名空间进行展开 (方便练习C++)

#include<iostream>
using namespace std;
int main() 
{
	cout << "Hello World!" << endl;
	cout << "Hello World!" << endl;
	cout << "Hello World!" << endl;
	cout << "Hello World!" << endl;
	cout << "Hello World!" << endl;
	return 0;
}

二、 C++的输入和输出

cin 和 cout 标准的C++的输入和输出

#include<iostream>
using namespace std; //std是C++标准库的命名空间名，C++将标准库的定义实现都放到这个命名空间中
int main() 
{
	int n = 0;
	cin >> n;	//输入
	cout << n << endl; //输出并换行
	return 0;
}

注意事项：

• <<是流插入运算符，>>是流提取运算符 (这里使用了运算符的复用，当之前的左移右移仍然保留)
• cout(console out)标准输出对象(控制台) 和 cin标准输入对象(键盘) 必须包含 < iostream >头文件以及按命名空间使用方法使用std 。
• cout和cin是全局的流对象，endl(end line)是特殊的C++符号，表示换行输出，他们都包含在包含头文件中
• C++的输入输出可以自动识别变量类型,不需要再去控制格式了
• 实际上cout和cin分别是ostream和istream类型的对象，>>和<<也涉及运算符重载等知识(后面的IO流会介绍)。

注意：关于cout和cin还有很多更复杂的用法，比如控制浮点数输出精度，控制整形输出进制格式等
等。因为C++兼容C语言的用法，所以如果不强制使用C++，可以使用C语言中的printf和scanf。

三、 缺省参数 (默认参数)

1. 缺省参数概念

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

2. 缺省参数的分类

(1) 全缺省参数

函数实参一个没有传，采用形参的缺省值

(2) 半缺省参数

半缺省必须 从右往左连续给

注意：

• 缺省参数不能间隔着给
• 缺省参数不能在函数声明和定义中同时出现(有缺省参数时，要放在函数声明处)
• 缺省值必须是常量或者全局变量

四、 函数重载

在C语言中是不允许同名函数存在的，然而在C++中允许同名函数，要求：函数名相同，参数不同，构成函数重载

函数重载：是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数 或 类型 或 类型顺序)不同。

函数重载常见情况

(1) 参数类型不同

#include<iostream>
using namespace std;
int Add(int x,int y)
{
	return x + y;
}
double Add(double x,double y)
{
	return x + y;
}
int main() 
{
	//参数类型不同
	int int_ret = Add(1,2);
	double double_ret = Add(1.1,2.1);
	cout << int_ret <<  endl;
	cout << double_ret <<  endl;
	return 0;
}

(2) 参数个数不同

#include<iostream>
using namespace std;
int Add(int x, int y, int z)
{
	return x + y+z;
}
int Add(int x, int y)
{
	return x + y;
}
int main()
{
	//参数个数不同
	int ret_3 = Add(1, 2,3);
	int ret_2 = Add(1,2);
	cout << ret_3 << endl;
	cout << ret_2 << endl;
	return 0;
}

(3)参数的顺序不同

#include<iostream>
using namespace std;

void Print(int left,char right) 
{
	cout << "int char" << endl;
	cout << "left:" << left << endl;
	cout << "right:" << right << endl;
}

void Print(char right, int left)
{
	cout << "char int" << endl;
	cout << "right:" << right << endl;
	cout << "left1:" <<left<< endl;
}
int main()
{
	//参数顺序不同
	Print(5,'a');
	Print('a', 5);
	return 0;
}

注意： 如果两个函数函数名和参数是一样的，返回值不同是不构成重载的，因为调用时编译器无法区分。

我们知道C语言不支持函数重载，在链接时，直接用函数名去寻找地址，当有同名函数的时候，是区分不开的。

C++是采用了名字修饰规则，函数名字引入参数类型(在不同平台上的名字修饰规则是不同的)

在linux环境下，采用gcc编译完成后，函数名字的修饰没有发生改变 (编译C语言)

采用C++编译器编译后结果 ( 编译C++ )

g++ -o testcpp test.cc

objdump -S testcpp

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

在vs下的命名规则

windows下vs编译器对函数名字修饰规则相对复杂难懂。

五、 引用

1. 引用的概念

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

例如：张三，小名叫：小张 。张三和小张都是只一个人。

类型& 引用变量名 = 引用实体；//这里引用变量名就是该变量的别名

例:

//引用
#include<iostream>
using namespace std;
int main() 
{
	int a = 10;
	int& b = a;	//引用，b是a的别名
	cout << b << endl;
	return 0;
}

输出结果: 10

我们通过打印a,b这两个地址进行打印，查看地址是否一致

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

2. 引用的特性

1. 引用在定义时必须初始化
2. 一个变量可以有多个引用
3. 引用一旦引用一个实体，再不能引用其他实体

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

  	int& b; //这种写法是错误的
  	int& b = a;	//引用在定义时必须初始化
  

• 一个变量可以有多个引用(就像一个人的外号可以有多个，但是都是指的是同一个人)

  	int a = 10;
  	int& b = a;	//引用，b是a的别名
  	int& c = a; //引用，c也是a的别名
  

  

• 引用一旦引用一个实体，再不能引用其他实体
  也就是当引用一个变量时，该引用不能再去引用其他变量

  	int a = 10;
  	int x = 20;
  	int& b = a;	//引用，b是a的别名
  	int& b = x; //error ,这样会导致重定义，多次初始化
  

关于常量引用

	//int& z = 10;	//error 常量不能引用
	const int a = 100;
	//int& b = a;	  //error,编译时出错，a为常量
	const int& b = a; //正确写法

	int ra = 10;
	//double& b = ra;	//error, 引用类型不同

3. 引用的使用

(1) 引用作参数

例如: 交换两个数

在C语言中，

void swap(int* x ,int* y) 
{
	int tmp = *x;
	*x = *y;
	*y = tmp;
}
int main() 
{
	int a = 10;
	int b = 20;
	swap(&a,&b);	//把地址传过去
	return 0;
}

交换两个数要把地址传过去，形参是实参的临时拷贝，只有把地址传过去，参数才可以改变。

在C++中，使用引用，引用和原值是共用一块内存空间

void swap(int& x,int &y) 	//引用做参数
{
	int tmp = x;
	x = y;
	y = tmp;
}
int main() 
{
	int a = 10;
	int b = 20;
	swap(a,b);
	return 0;
}

这里的x和y分别是a和b的别名

上述是给整型取别名，也可以给指针取别名

	//void PushBack(struct Node** pphead,int x){}	//C语言使用二级指针
	void PushBack(struct Node*& phead,int x)	//C++,使用引用给指针取别名
    {
        //phead = newnode;
        //...
    }

小总结：引用做参数，a.做输出型参数 b.对象比较大时，减少拷贝，提高效率。

(2) 引用作返回值

int& func()		//返回值类型 int& ，传引用返回
{
	int a = 1000;
	return a;
}
int main()
{
	int ret = func();
	cout << ret << endl;
	return 0;
}

int func 传值返回时(返回的是拷贝)，函数栈帧的销毁，会导致a的值可能是随机值。

int& func 传引用返回，返回a的别名，但是指向的内存空间没有改变，函数栈帧的销毁，内存返回给操作系统，引用的值也变成了随机值。(出现了野引用)

什么情况下可以使用引用返回？

全局变量/静态变量/堆上的空间等可以作引用返回

小总结：

传值返回，传的是返回值的拷贝；传引用返回，传的是返回值的别名。

返回变量出了函数作用域，生命周期就到了要销毁 (局部变量)，不能用引用返回。

引用作返回值 a.修改返回对象 b.减少拷贝调高效率

4. 引用和指针的区别

int main()
{
	//引用 
	int a = 10;
	int& ra = a;  //语法层面不开空间
	ra = 20;
	//指针
	int* pa = &a; //语法层面开空间
	*pa = 20;
	return 0;
}

语法上(规定用法) :

(1) 引用是别名, 不开空间，指针是地址, 需要开辟内存空间

(2) 引用必须初始化，指针可以初始化也可以不初始化

(3) 引用不能改变指向，指针可以改变指向

(4) 引用相对更安全，没有空引用，但是有空指针，容易出现野指针，但不容易出现野引用

(5) 在sizeof中含义不同，引用结果引用类型的大小，但指针始终是地址空间所占字节个数

(6) 引用++，引用的实体增加1，指针++即指针向后偏移一个类型的大小

(7) 有多级指针，但是没有多级引用

底层上(汇编) :

引用的底层使用指针实现的

汇编层面上，没有引用，都是指针，引用编译后也转换成指针了。

引用和指针的共能类似，但是引用不能完全替代指针，因为引用定义后不能改变指向。例如：在单链表中，删除链表中的某一个结点，需要让指针指向要删除结点的下一个结点(改变指针的指向)。但是引用是无法进行改变指向的。

然而在java和python中实现链表是通过引用，java和python中的引用时允许改变指向的。

六、 内联函数

内联函数概念

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

在C语言中，如果进行多次调用函数，那么会多次建立函数栈帧，C语言是通过宏函数来解决这个问题。因为宏会在预处理阶段进行宏的替换，这样就不会建立函数栈帧了。

宏的优点：

没有函数栈帧的创建，提供效率

但是宏也是有一些缺点

宏的缺点：
语法复杂，坑很多，不容易控制；不能调试；没有 类型安全的检查

C++替代宏的技术：可以使用常量定义 (const enum) ; 短小函数定义 换用内联函数

为了减少使用宏，C++给出了内联函数

在C++中，在调用内联函数的地方展开，没有函数调用建立栈帧的开销

为什么内联函数适合短小函数呢？

假设 func函数有100行，项目中有1w个调用该函数的位置

内联展开了 100*1w = 100w行

不使用内联展开 100+1w = 1.01w行

大的函数就影响很大，所以 短小函数可以换用内联函数

在内联函数在长一点的函数和递归函数是不会展开的

内联函数特性

• 内联函数(inline)是一种以空间换时间的做法，在编译阶段，会把函数展开。优点：减少了函数栈帧的开销，提高效率；缺点：目标文件可能会增大。

• 内联函数适合较小代码量的函数

• inline不建议声明和定义分离，分离会导致链接错误，因为inline被展开，就没有函数地址，链接时的符号表就找不到了。
  例如：

  //test.cpp
  #include "test.h"
  
  int main() 
  {
  	func();
  	return 0;
  }
  
  //test.h
  #pragma once	//避免头文件被重复包含，可以提高运行效率
  #include<iostream>
  using namespace std;
  inline void func();	//error
  
  //func.cpp
  #include "test.h"
  
  void func() 
  {
  	cout << "func()" << endl;
  }
  

  因为inline函数展开，汇编call调用时没有函数地址

如果要在test.h文件写函数，代码量较小的可以用内联(声明和定义不分离)，大的就使用static (链接属性，只在当前文件可见)

七、auto关键字

在C++中，auto有许多作用，但是最常用的是用于类型推导。

	int i = 0;
	auto k = i;	//auto 在这里的作用就是自动(识别)推导类型

	void(*pf1)(int, int) = func;	//函数指针
	auto pf2 = func;				//自动识别函数指针
	//打印类型进行验证一下、
	cout << typeid(pf1).name() << endl;//void (__cdecl*)(int,int)
	cout << typeid(pf2).name() << endl;//void (__cdecl*)(int,int)
	
	//std::map<std::string, std::s>::iterator it = dict.begin();
	//auto it = dict.begin();	

当然上述也可以使用C语言中的typedef 类型重命名，但是当计算出表达式的值的时候，进行赋值( 就需要知道数据类型 )，在一些项目中使用typedef没有那么容易，但是 auto关键字可以进行自动推导。

auto从C++11标准及更高标准下可以作返回类型

auto func(int a,int b) {}	

注意：

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

auto的缺点：

(1) auto不能作为函数的参数

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

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

int a[] = {1,2,3};
auto b[] = {4,5,6};	//error

八、 基于范围的for循环(C++11)

范围for的语法

C++11中引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。

	int a[] = {1,2,3,4,5,6};
	int b[] = {1,2,3,4,5,6};
	//普通的for循环
	for (int i = 0; i < sizeof(a) / sizeof(a[0]);i++)
	{
		a[i] *= 2;
	}
	for (int i = 0;i< sizeof(a) / sizeof(a[0]);i++)
	{
		cout << *(a + i) <<' ';	//打印结果：2 4 6 8 10 12
	}

	//范围for的使用 （C++11）
	for (int e:b)	//依次取数组中赋值给e,自动迭代，自动判断结束
		e *= 2;
	for (int e : b)
		cout << e << ' ';	//打印结果：1 2 3 4 5 6

上述范围for的使用C++11也进行了数值乘2，但是打印结果没有发生变化。原因是: 因为是从数组中取出赋值给e，并没有改变数组中的数据，所以打印还是原值。

要想修改原数组的值，则需要使用引用

	for (int& e : b)	//依次取数组中赋值给e,自动迭代，自动判断结束
		e *= 2;
	for (int e : b)
		cout << e << ' ';	//打印结果2 4 6 8 10 12

	//当然也可以换成auto
	for (auto& e : b)	//依次取数组中赋值给e,自动迭代，自动判断结束
		e *= 2;
	for (auto e : b)
		cout << e << ' ';	//打印结果2 4 6 8 10 12

范围for循环可以用continue来结束本次循环，也可以用break来跳出整个循环。

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

九、 指针空值

声明一个变量及时初始化是一个C/C++的一个好的编程习惯，否则可能会出现不可预料的错误，例如未初始化指针。

//初始化指针

	int *p1 = NULL;
	int* p2 = 0;

然而在C++98标准中出现了关于指针的bug

void f(int i) 
{
	cout << "f(int)" << endl;
}
void f(int* i) 
{
	cout << "f(int*)" << endl;
}
int main() 
{
	f(0);
	f(NULL);
	return 0;
}

打印结果:

f(int)

f(int)

发现都调用了第一个函数

分析：

	f((int *)NULL);	  //打印 f(int*)

随后在C++11标准中出现了 nullptr

    f(nullptr);    //打印 f(int*)
	int* p = nullptr;

nullptr 的主要优势 在于它提供了更好的类型安全性。它只能被赋值给指针类型，而不能被赋值给整数类型，这有助于减少因错误地将NULL或0用于非指针类型而引起的问题。此外，使用 nullptr 可以避免与某些平台上的空指针值冲突。

在C++11标准中，sizeof(nullptr) 和sizeof((void*)0)所占字节数相同，后续表示指针空值时，建议使用nullptr

12

范围for循环可以用continue来结束本次循环，也可以用break来跳出整个循环。

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

# 九、 指针空值

声明一个变量及时初始化是一个C/C++的一个好的编程习惯，否则可能会出现不可预料的错误，例如未初始化指针。

```cpp
//初始化指针

	int *p1 = NULL;
	int* p2 = 0;

然而在C++98标准中出现了关于指针的bug

void f(int i) 
{
	cout << "f(int)" << endl;
}
void f(int* i) 
{
	cout << "f(int*)" << endl;
}
int main() 
{
	f(0);
	f(NULL);
	return 0;
}

打印结果:

f(int)

f(int)

发现都调用了第一个函数

分析：

[外链图片转存中…(img-tjxJy0Wa-1706927812224)]

	f((int *)NULL);	  //打印 f(int*)

随后在C++11标准中出现了 nullptr

    f(nullptr);    //打印 f(int*)
	int* p = nullptr;

nullptr 的主要优势 在于它提供了更好的类型安全性。它只能被赋值给指针类型，而不能被赋值给整数类型，这有助于减少因错误地将NULL或0用于非指针类型而引起的问题。此外，使用 nullptr 可以避免与某些平台上的空指针值冲突。

在C++11标准中，sizeof(nullptr) 和sizeof((void*)0)所占字节数相同，后续表示指针空值时，建议使用nullptr