【C++】C++入门

待我称王封你为后i 2024-03-27 04:16 65阅读 0赞

#### 文章目录 ####

*   *  1.C++关键字
     *  2.命名空间
     *  3.命名空间定义
     *  4.命名空间使用
     *  5.C++输入和输出
     *  6.缺省参数
     *   *  6.1 缺省参数概念
         *  6.2 缺省参数分类
     *  7.函数重载
     *   *  7.1 函数重载概念
         *  7.2 C++支持函数重载的原理--名字修饰
     *  8. 引用
     *   *  8.1 应用概念
         *  8.2 引用特性
         *  8.3 常引用
         *  8.4 使用场景
         *  8.5 传值、传引用效率比较
         *   *  8.5.1 值和引用作为参数的性能比较
             *  8.5.2 值和引用作为返回值类型的性能比较
     *  9.引用和指针的区别
     *  9.内联函数
     *   *  9.1 特性
     *  10.auto关键字
     *   *  10.1 类型别名思考
         *  10.2 auto简介
         *  10.3. auto的使用规则
         *  10.4 auto不能推导的场景
     *  11.基于范围的for循环（C++11）
     *   *  11.1 范围for的使用条件
     *  12.指针空值（nullptr）
     *   *  12.1 C++98当中的指针空值

### 1.C++关键字 ###

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

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lctFDv6s-1675584635739)(ipic\\image-1675523663309.png)\]][img-lctFDv6s-1675584635739_ipic_image-1675523663309.png]

### 2.命名空间 ###

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

#include <stdio.h>
    
    int rand = 10;
    
    int main()
    {
        
        printf("%d\n", rand);
        return 0;
    }

这样可以正常编译运行，但是如果加上一个头文件，就会报错。

#include <stdio.h>
    #include <stdlib.h>
    
    int rand = 10;
    
    int main()
    {
        
    	printf("%d\n", rand);
    	return 0;
    }

原因是：rand是一个包含在`stdlib.h`这个头文件里面的一个函数，如果加上这个头文件就会造成重定义。导致自己定义的名字和库里面的名字造成冲突。

### 3.命名空间定义 ###

定义命名空间需要使用到`namespace`关键字，后面跟**命名空间的名字**，然后接一对`{}`，大括号里面即为命名空间的成员。

注意：**一个命名空间就定义了一个新的作用域**，命名空间中的所有内容都局限于该命名空间当中。

### 4.命名空间使用 ###

命名空间内成员如何使用？

namespace N
    {
        
    	// 命名空间中可以定义变量/函数/类型
    	int a = 0;
    	int b = 1;
    	int Add(int left, int right)
    	{
        
    		return left + right;
    	}
    	struct Node
    	{
        
    		struct Node* next;
    		int val;
    	};
    }
    int main()
    {
        
    	// 编译报错：error C2065: “a”: 未声明的标识符
    	printf("%d\n", a);
    	return 0;
    }

命名空间使用的三种方法：

*  **加命名空间名称及作用域限定符**

int main()
    {
        
     printf("%d\n", N::a);
     return 0;    
    }

*  使用`using`将命名空间中某个成员引入

using N::b;
    int main()
    {
        
     printf("%d\n", N::a);
     printf("%d\n", b);
     return 0;    
    }

*  使用`using namespace`将命名空间名称引入

using namespce N;
    int main()
    {
        
     printf("%d\n", N::a);
     printf("%d\n", b);
     Add(10, 20);
     return 0;    
    }

### 5.C++输入和输出 ###

实例：

#include <iostream>
    // std 是 C++ 标准库的命名空间名，C++ 将标准库的定义实现都放在这个命名空间中
    using namespace std;
    
    int main()
    {
        
    	cout << "hello world!" << endl;
    	return 0;
    }

说明：

1.  使用`cout`**标准输出对象（控制台)和 `cin` 标准输入对象（键盘**是必须包含`<iostream>`头文件以及使用`C++`标准库的命名空间。
2.  `cout`和`cin`是全局的流对象，`endl`是特殊的C++符号，表示换行输出，它们都包含在头文件`<iostream>`当中
3.  `<<`是流插入符，`>>`是流提取符
4.  使用`C++`输入和输出更加方便，不需要像C语言那样控制格式。`C++`输入输出可以自动识别变量类型。
5.  实际上`cout`和`cin`分别是`ostream`和`istream`类型的对象，`<<`和`>>`也涉及运算符重载等知识，这些知识后续才会学习，这里我们知识了解简单的使用。

### 6.缺省参数 ###

#### 6.1 缺省参数概念 ####

缺省参数是**声明和定义函数为函数的参数提供一个缺省值**，在调用函数的时候，如果没有指定实参，就是用该参数的缺省值，否则使用指定的实参。

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

#### 6.2 缺省参数分类 ####

*  **全缺省参数**

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

*  **半缺省参数**

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

注意：

1.  半缺省参数必须**从右往左依次**给出，不能间隔给出。
2.  缺省参数不能在函数的定义和声明当中同时出现
3.  缺省值必须是常量或者全局变量

### 7.函数重载 ###

自然语言当中，一个词可以有多重含义，人们可以通过上上下文来判断该词的真正含义。即该词重载了。

比如：从前有一个笑话国有两个体育项目大家根本不用担心。一个是乒乓球，一个是足球。前者是“谁也赢不了！”，后者是“谁也赢不了！”

#### 7.1 函数重载概念 ####

**函数重载**：是函数的一种特殊情况，`C++`允许在**同一个作用域当中**声明几个功能类似的**同名函数。这些同名函数的形参列表（参数个数或类型或类型顺序）不同**，常用来处理功能类似数据类型不同的问题。

#include<iostream>
    using namespace std;
    // 1、参数类型不同
    int Add(int left, int right)
    {
        
    	cout << "int Add(int left, int right)" << endl;
    	return left + right;
    }
    double Add(double left, double right)
    {
        
    	cout << "double Add(double left, double right)" << endl;
    	return left + right;
    }
    // 2、参数个数不同
    void f()
    {
        
    	cout << "f()" << endl;
    }
    void f(int a)
    	cout << "f(int a)" << endl;
    }
    // 3、参数类型顺序不同
    void f(int a, char b)
    {
        
    	cout << "f(int a,char b)" << endl;
    }
    void f(char b, int a)
    {
        
    	cout << "f(char b, int a)" << endl;
    }
    int main()
    {
        
    	Add(10, 20);
    	Add(10.1, 20.2);
    	f();
    	f(10);
    	f(10, 'a');
    	f('a', 10);
    	return 0;
    }

#### 7.2 C++支持函数重载的原理–名字修饰 ####

**为什么C++当中支持函数重载，而C语言当中不支持？**

在C/C++当中，一个程序要运行起来需要经历：**预处理、编译、汇编、链接**

![在这里插入图片描述][6390031ba00d40c6bbcb2af5d83704c3.png]

在`Linux`下，采用`g++`编译完成后，**函数名字的修饰发生改变，编译器将函数参数类型信息添加到修改后的名字当中。**

**通过这里我们知道C语言没办法支持重载，因为同名函数没办法区分，而C++是通过函数修饰规则来区分，只要参数不同，修饰出来的名字就不一样，这样就支持了重载。**

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

### 8. 引用 ###

#### 8.1 应用概念 ####

**引用**不是新定义一个变量，而是**给已知的变量起一个别名**，编译器不会为引用变量开辟内存空间，它和它引用的变量**共用一个内存空间**。  
比如：  
![在这里插入图片描述][0bd3507911884508be7391ef5211f553.png]

> 这里的a、b、c其实用是同一个内存空间。

使用方法：**类型& 引用变量名（对象名） = 引用实体；**

void TestRef()
    {
        
        int a = 10;
        int& ra = a;//<====定义引用类型
        printf("%p\n", &a);
        printf("%p\n", &ra);
    }

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

#### 8.2 引用特性 ####

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

#### 8.3 常引用 ####

void TestConstRef()
    {
        
        const int a = 10;
        //int& ra = a;   // 该语句编译时会出错，a为常量
        const int& ra = a;
        // int& b = 10; // 该语句编译时会出错，b为常量
        const int& b = 10;
        double d = 12.34;
        //int& rd = d; // 该语句编译时会出错，类型不同
        const int& rd = d;
    }

这里需要注意的是：`const`修饰的变量权限变小了，就只能读不能修改。**权限可以缩小，但是不可以放大**

#### 8.4 使用场景 ####

1.  做参数  
    我们以前学习的使用函数交换两个实参。这里可以通过引用实现。

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

1.  做返回值  
    ![在这里插入图片描述][0b4de4fcd80441e3906847903b07cee1.png]  
    当Count函数执行到最后的时候，空间收回。n变量随着消失，这里是怎么样访问到的那？是创建了一个临时变量放在寄存器当中。  
    ![在这里插入图片描述][7c896abf658349c592888b25bee6bfc6.png]  
    这里的n是放在静态区当中，但是仍然需要创建临时变量。这不应该，我们不需要创建临时变量就可以访问，但是这里要创建临时变量，我们怎么解决这个问题呢？  
    引用作为返回值。

int& Count()
    {
        
    	static int n = 0;
    	n++;
    	return n;
    }
    
    int main()
    {
        
    	int ret = Count();
    	return 0;
    }

这里返回的就是n的别名，不需要创建临时变量。

注意：**如果函数返回时，出了函数作用域，如果返回对象还在（还没给系统），则可以使用引用返回，如果已经给了系统。就必须使用传值返回**

#### 8.5 传值、传引用效率比较 ####

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

##### 8.5.1 值和引用作为参数的性能比较 #####

#include <time.h>
    struct A {
         int a[10000]; };
    void TestFunc1(A a) {
        }
    void TestFunc2(A& a) {
        }
    void TestRefAndValue()
    {
        
    	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;
    }

##### 8.5.2 值和引用作为返回值类型的性能比较 #####

#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;
    }

### 9.引用和指针的区别 ###

在**语法概念**上引用就是一个别名，没有独立空间，和其引用实体共用一块空间。  
在**底层实现**上实际是有空间的，因为**引用是按照指针方式实现的**

引用和指针的不同点：

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

### 9.内联函数 ###

概念：用`inline` 修饰的函数叫做内联函数，编译时C++编译器会在**调用内联函数的地方**展开。没有函数调用建立栈帧的开销，内联函数提高程序运行的效率。  
![在这里插入图片描述][6e7ac729d7154cceaea33e739d3cadaa.png]  
如果在上述函数前增加`inline`关键字将其改成内联函数，编译期间编译器会用函数体替换函数的调用。  
查看方式：

1.  release版本，查看是否存在上述图片所圈内容
2.  在debug版本下，需要设置，否则不对代码进行优化。  
    ![在这里插入图片描述][a7c3d31400e14519ae03d3ba1dbc73ca.png]  
    ![在这里插入图片描述][9141b62682184f4686a5215235e3a1d5.png]

#### 9.1 特性 ####

1.  `inline`是一种以**空间换时间**的做法，如果编译器将函数当成内联函数来处理，在**编译阶段，会用函数体替换函数调用**。缺陷：可能使目标文件变大。优势：少了调用开销，提高程序运行效率

> 这里的空间指的是：编译出来的可执行程序

1.  `inline`对于编译器来说只是一个提议，不同编译器的机制可能不同，一般建议：将**函数规模小，不同递归，且频繁调用**的函数用`inline`来修饰。否则编译器可能会忽略`inline`特性。
2.  `inline`不建议将声明和定义分离，分离会导致链接错误。因为`inline`被展开就没有函数地址了，链接就找不到。

【面试题】  
**宏的优缺点？**  
优点：

1.  增强代码的复用性
2.  提高性能

缺点：

1.  不方便调试宏（因为预编译阶段进行了替换）
2.  导致代码可读性差，可维护性差，容易误用
3.  没有类型安全的检查  
    比如我们写一个用宏实现加法的函数，我们会用很多种答案：

//#define ADD(int x, int y) return x + y
    //#define ADD(x, y) return x + y;
    //#define ADD(x, y) return (x + y);
    #define ADD(x, y) return ((x) + (y));

只有最后一种是正确的。

**C++哪些技术替代宏**

1.  常量定义 用`const enum`
2.  短小函数定义，换用内联函数。

### 10.auto关键字 ###

#### 10.1 类型别名思考 ####

随着程序越来越复杂，程序中用到的类型也越来越复杂，经常体现在：

*  类型难于拼写
 *  含义不明确导致出错

#include <string>
    #include <map>
    int main()
    {
        
    	std::map<std::string, std::string> m{
         {
         "apple", "苹果" }, {
         "orange","橙子" },
    	  {
        "pear","梨"} };
    	std::map<std::string, std::string>::iterator it = m.begin();
    	while (it != m.end())
    	{
        
    		//....
    	}
    	return 0;
    }

`std::map<std::string, std::string>::iterator`是一个类型但是这个类型太长了，很容易写错。我们可以想到可以用`typedef`关键字给这个类型起别名。  
使用`typedef`关键字，确实可以简化代码。但是还会遇到新的问题：

typedef char* pstring;
    int main()
    {
        
    	const pstring p1;    // 编译成功还是失败？
    	const pstring* p2;   // 编译成功还是失败？
    	return 0;
    }

在编程的时候，常常需要把表达式的值赋值给变量，这就需要在声明变量的时候清楚的知道表达式的类型。但是有时候做到这些并不同意。

#### 10.2 auto简介 ####

在早期的C/C++中auto的含义是：**用auto修饰的变量，是具有自动存储器的局部变量**，但遗憾的是没有人去使用它，这是为什么？  
在C++11当中，auto赋予了全新的含义：**auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量，必须由编译器在编译时期推导而得。**

int TestAuto()
    {
        
    	return 10;
    }
    int main()
    {
        
    	int a = 10;
    	auto b = a;
    	auto c = 'a';
    	auto d = TestAuto();
    	cout << typeid(b).name() << endl;
    	cout << typeid(c).name() << endl;
    	cout << typeid(d).name() << endl;// 这是一个获取变量类型的函数，记住就可以了
    	//auto e; 无法通过编译，使用auto定义变量时必须对其进行初始化
    	return 0;
    }

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

#### 10.3. auto的使用规则 ####

1.  auto和指针和引用结合起来使用  
    **用auto声明指针类型的时候，用auto和auto\*没有任何区别，但是auto声明引用类型必须加&**

int main()
    {
        
        int x = 10;
        auto a = &x;
        auto* b = &x;
        auto& c = x;
        cout << typeid(a).name() << endl;
        cout << typeid(b).name() << endl;
        cout << typeid(c).name() << endl;
        *a = 20;
        *b = 30;
         c = 40;
        return 0;
    }

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

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

#### 10.4 auto不能推导的场景 ####

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

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

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

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

1.  为了避免与C++98中auto发生混淆，C++11只保留了auto作为类型指示符的用法
2.  auto在实际中最常用的优势就是跟C++11提供的新式for循环，还有lambda表达式进行配合使用

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

在C++98中，如果要遍历一个数组，可以按照如下方法：  
`sizeof(arr)/sizeof(arr[0])`，来获取数组的长度  
对于一个**有范围的集合**，由程序员来说明范围是多余的，有时候还容易犯错，因此C++11当中引入了基于范围的for循环。使用方式如下；

void TestFor()
    {
        
        int array[] = {
         1, 2, 3, 4, 5 };
        for (auto& e : array)
            e *= 2;
        for (auto e : array)
            cout << e << " ";
        return 0;
    }

**注意**：与普通的循环相比，可以用`continue`来结束本次循环，也可以用`break`来结束整个循环。

#### 11.1 范围for的使用条件 ####

1.  for循环迭代的范围必须是确定的  
    **对于数组而言，就是数组当中第一个元素和最后一个元素的范围**， 对于类而言应该提供begin和end的方法，begin和end就是for循环迭代的范围  
    以下代码就有问题，因为for的范围不确定

void TestFor(int array[])
    {
        
        for(auto& e : array)
            cout<< e <<endl;
    }

1.  迭代的对象要实现++和==的操作

### 12.指针空值（nullptr） ###

#### 12.1 C++98当中的指针空值 ####

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

void TestPtr()
    {
        
    int* p1 = NULL;
    int* p2 = 0;
    // ……
    }

NULL实际上是一个宏，可以在传统的C头文件（stddef.h）当中

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

可以看到，\**NULL可能被定义为字面常量0， 或者被定义为无类型指针（void*）的常量，不论采取何种定义，在使用空值指针时都会有不可避免的麻烦。比如：

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

> 程序本意是想通过f(NULL)调用指针版本的f(int\*)函数，但是由于NULL被定义成0，因此与程序的初衷相悖。在C++98中，字面常量0既可以是一个整形数字，也可以是无类型的指针(void\*)常量，但是编译器默认情况下将其看成是一个整形常量，如果要将其按照指针方式来使用，必须对其进行强转(void\*)0。

**注意**：

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

[img-lctFDv6s-1675584635739_ipic_image-1675523663309.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/e11508b0fe5149ef83551a9b1f467f09.png
[6390031ba00d40c6bbcb2af5d83704c3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/0ad3a8e6079f49b8b5b105cddbcdf46f.png
[0bd3507911884508be7391ef5211f553.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/95d80153e3464ec98b667ed59d905ec5.png
[0b4de4fcd80441e3906847903b07cee1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/5044e82c94de4f868ff9423fd04ffa73.png
[7c896abf658349c592888b25bee6bfc6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/10ad61f7c87e4b7f99237a4e5c0f02d3.png
[6e7ac729d7154cceaea33e739d3cadaa.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/1bc163853d78493caf0d793ed3a2fd24.png
[a7c3d31400e14519ae03d3ba1dbc73ca.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/bbd7ea3629ee4ae49d6338f2960cbd66.png
[9141b62682184f4686a5215235e3a1d5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/c49f5bdee2064ce29a48f631c27f1e11.png