挑战一个月基本掌握C++（第七天）了解指针，引用，时间，输入输出，结构体，vector容器，数据结构 - 通用完结
一 指针
每一个变量都有一个内存位置，每一个内存位置都定义了可使用连字号（&）运算符访问的地址，它表示了在内存中的一个地址。
下面的实例，它将输出定义的变量地址：
#include <iostream>using namespace std;int main ()
{int var1;char var2[10];cout << "var1 变量的地址： ";cout << &var1 << endl;cout << "var2 变量的地址： ";cout << &var2 << endl;return 0;
}输出：
var1 变量的地址： 0xbfebd5c0
var2 变量的地址： 0xbfebd5b6
1.1 什么是指针？
指针是一个变量，其值为另一个变量的地址，即，内存位置的直接地址。就像其他变量或常量一样，您必须在使用指针存储其他变量地址之前，对其进行声明。指针变量声明的一般形式为：
type *var-name;
在这里，type 是指针的基类型，它必须是一个有效的 C++ 数据类型，var-name 是指针变量的名称。用来声明指针的星号 * 与乘法中使用的星号是相同的。但是，在这个语句中，星号是用来指定一个变量是指针。以下是有效的指针声明：
int *ip; /* 一个整型的指针 */
double *dp; /* 一个 double 型的指针 */
float *fp; /* 一个浮点型的指针 */
char *ch; /* 一个字符型的指针 */
所有指针的值的实际数据类型，不管是整型、浮点型、字符型，还是其他的数据类型，都是一样的，都是一个代表内存地址的长的十六进制数。不同数据类型的指针之间唯一的不同是，指针所指向的变量或常量的数据类型不同。
1.2 C++中使用指针
使用指针时会频繁进行以下几个操作：定义一个指针变量、把变量地址赋值给指针、访问指针变量中可用地址的值。这些是通过使用一元运算符 * 来返回位于操作数所指定地址的变量的值。下面的实例涉及到了这些操作：
#include <iostream>using namespace std;int main ()
{int var = 20; // 实际变量的声明int *ip; // 指针变量的声明ip = &var; // 在指针变量中存储 var 的地址cout << "Value of var variable: ";cout << var << endl;// 输出在指针变量中存储的地址cout << "Address stored in ip variable: ";cout << ip << endl;// 访问指针中地址的值cout << "Value of *ip variable: ";cout << *ip << endl;return 0;
}输出：
Value of var variable: 20
Address stored in ip variable: 0xbfc601ac
Value of *ip variable: 20
1.3 C++指针详解
在 C++ 中，有很多指针相关的概念，这些概念都很简单，但是都很重要。下面列出了 C++ 程序员必须清楚的一些与指针相关的重要概念：
| 概念 | 描述 |
|---|---|
| C++ Null 指针 | C++ 支持空指针。NULL 指针是一个定义在标准库中的值为零的常量。 |
| C++ 指针的算术运算 | 可以对指针进行四种算术运算：++、--、+、- |
| C++ 指针 vs 数组 | 指针和数组之间有着密切的关系。 |
| C++ 指针数组 | 可以定义用来存储指针的数组。 |
| C++ 指向指针的指针 | C++ 允许指向指针的指针。 |
| C++ 传递指针给函数 | 通过引用或地址传递参数，使传递的参数在调用函数中被改变。 |
| C++ 从函数返回指针 | C++ 允许函数返回指针到局部变量、静态变量和动态内存分配。 |
二 引用
引用变量是一个别名，也就是说，它是某个已存在变量的另一个名字。一旦把引用初始化为某个变量，就可以使用该引用名称或变量名称来指向变量。
2.1 引用和指针
引用很容易与指针混淆，它们之间有三个主要的不同：
- 不存在空引用。引用必须连接到一块合法的内存。
- 一旦引用被初始化为一个对象，就不能被指向到另一个对象。指针可以在任何时候指向到另一个对象。
- 引用必须在创建时被初始化。指针可以在任何时间被初始化。
2.2 C++中创建引用
试想变量名称是变量附属在内存位置中的标签，您可以把引用当成是变量附属在内存位置中的第二个标签。因此，您可以通过原始变量名称或引用来访问变量的内容。例如：
int i = 17;
我们可以为 i 声明引用变量，如下所示：
int& r = i;
double& s = d;
在这些声明中，& 读作引用。因此，第一个声明可以读作 "r 是一个初始化为 i 的整型引用"，第二个声明可以读作 "s 是一个初始化为 d 的 double 型引用"。下面的实例使用了 int 和 double 引用：
#include <iostream>using namespace std;int main ()
{// 声明简单的变量int i;double d;// 声明引用变量int& r = i;double& s = d;i = 5;cout << "Value of i : " << i << endl;cout << "Value of i reference : " << r << endl;d = 11.7;cout << "Value of d : " << d << endl;cout << "Value of d reference : " << s << endl;return 0;
}输出：
Value of i : 5
Value of i reference : 5
Value of d : 11.7
Value of d reference : 11.7
引用通常用于函数参数列表和函数返回值。下面列出了 C++ 程序员必须清楚的两个与 C++ 引用相关的重要概念：
| 概念 | 描述 |
|---|---|
| 把引用作为参数 | C++ 支持把引用作为参数传给函数，这比传一般的参数更安全。 |
| 把引用作为返回值 | 可以从 C++ 函数中返回引用，就像返回其他数据类型一样。 |
三 日期和时间
C++ 标准库没有提供所谓的日期类型。C++ 继承了 C 语言用于日期和时间操作的结构和函数。为了使用日期和时间相关的函数和结构，需要在 C++ 程序中引用 <ctime> 头文件。
有四个与时间相关的类型：clock_t、time_t、size_t 和 tm。类型 clock_t、size_t 和 time_t 能够把系统时间和日期表示为某种整数。
结构类型 tm 把日期和时间以 C 结构的形式保存，tm 结构的定义如下：
struct tm {int tm_sec; // 秒，正常范围从 0 到 59，但允许至 61int tm_min; // 分，范围从 0 到 59int tm_hour; // 小时，范围从 0 到 23int tm_mday; // 一月中的第几天，范围从 1 到 31int tm_mon; // 月，范围从 0 到 11int tm_year; // 自 1900 年起的年数int tm_wday; // 一周中的第几天，范围从 0 到 6，从星期日算起int tm_yday; // 一年中的第几天，范围从 0 到 365，从 1 月 1 日算起int tm_isdst; // 夏令时
};下面是 C/C++ 中关于日期和时间的重要函数。所有这些函数都是 C/C++ 标准库的组成部分，可以在 C++ 标准库中查看一下各个函数的细节。
| 序号 | 函数 & 描述 |
|---|---|
| 1 | time_t time(time_t *time); 该函数返回系统的当前日历时间，自 1970 年 1 月 1 日以来经过的秒数。如果系统没有时间，则返回 -1。 |
| 2 | char *ctime(const time_t *time); 该返回一个表示当地时间的字符串指针，字符串形式 day month year hours:minutes:seconds year\n\0。 |
| 3 | struct tm *localtime(const time_t *time); 该函数返回一个指向表示本地时间的 tm 结构的指针。 |
| 4 | clock_t clock(void); 该函数返回程序执行起（一般为程序的开头），处理器时钟所使用的时间。如果时间不可用，则返回 -1。 |
| 5 | char * asctime ( const struct tm * time ); 该函数返回一个指向字符串的指针，字符串包含了 time 所指向结构中存储的信息，返回形式为：day month date hours:minutes:seconds year\n\0。 |
| 6 | struct tm *gmtime(const time_t *time); 该函数返回一个指向 time 的指针，time 为 tm 结构，用协调世界时（UTC）也被称为格林尼治标准时间（GMT）表示。 |
| 7 | time_t mktime(struct tm *time); 该函数返回日历时间，相当于 time 所指向结构中存储的时间。 |
| 8 | double difftime ( time_t time2, time_t time1 ); 该函数返回 time1 和 time2 之间相差的秒数。 |
| 9 | size_t strftime(); 该函数可用于格式化日期和时间为指定的格式。 |
3.1 当前日期和时间
下面的实例获取当前系统的日期和时间，包括本地时间和协调世界时（UTC）。
#include <iostream>
#include <ctime>using namespace std;int main( )
{// 基于当前系统的当前日期/时间time_t now = time(0);// 把 now 转换为字符串形式char* dt = ctime(&now);cout << "本地日期和时间：" << dt << endl;// 把 now 转换为 tm 结构tm *gmtm = gmtime(&now);dt = asctime(gmtm);cout << "UTC 日期和时间："<< dt << endl;
}当上面的代码被编译和执行时，它会产生下列结果：
本地日期和时间：Sat Jan 8 20:07:41 2011UTC 日期和时间：Sun Jan 9 03:07:41 2011
3.2 使用结构 tm 格式化时间
tm 结构在 C/C++ 中处理日期和时间相关的操作时，显得尤为重要。tm 结构以 C 结构的形式保存日期和时间。大多数与时间相关的函数都使用了 tm 结构。下面的实例使用了 tm 结构和各种与日期和时间相关的函数。
在练习使用结构之前，需要对 C 结构有基本的了解，并懂得如何使用箭头 -> 运算符来访问结构成员。
#include <iostream>
#include <ctime>using namespace std;int main( )
{// 基于当前系统的当前日期/时间time_t now = time(0);cout << "1970 到目前经过秒数:" << now << endl;tm *ltm = localtime(&now);// 输出 tm 结构的各个组成部分cout << "年: "<< 1900 + ltm->tm_year << endl;cout << "月: "<< 1 + ltm->tm_mon<< endl;cout << "日: "<< ltm->tm_mday << endl;cout << "时间: "<< ltm->tm_hour << ":";cout << ltm->tm_min << ":";cout << ltm->tm_sec << endl;
}当上面的代码被编译和执行时，它会产生下列结果：
1970 到目前时间:1503564157
年: 2017
月: 8
日: 24
时间: 16:42:37
四 基本的输入输出
C++ 的 I/O 发生在流中，流是字节序列。如果字节流是从设备（如键盘、磁盘驱动器、网络连接等）流向内存，这叫做输入操作。如果字节流是从内存流向设备（如显示屏、打印机、磁盘驱动器、网络连接等），这叫做输出操作。
4.1 I/O 库头文件
| 头文件 | 函数和描述 |
|---|---|
| <iostream> | 该文件定义了 cin、cout、cerr 和 clog 对象，分别对应于标准输入流、标准输出流、非缓冲标准错误流和缓冲标准错误流。 |
| <iomanip> | 该文件通过所谓的参数化的流操纵器（比如 setw 和 setprecision），来声明对执行标准化 I/O 有用的服务。 |
| <fstream> | 该文件为用户控制的文件处理声明服务。我们将在文件和流的相关章节讨论它的细节。 |
4.2 标准输出流（cout）
预定义的对象 cout 是 iostream 类的一个实例。cout 对象"连接"到标准输出设备，通常是显示屏。cout 是与流插入运算符 << 结合使用的，如下所示：
#include <iostream>using namespace std;int main( )
{char str[] = "Hello C++";cout << "Value of str is : " << str << endl;
}输出：
Value of str is : Hello C++
C++ 编译器根据要输出变量的数据类型，选择合适的流插入运算符来显示值。<< 运算符被重载来输出内置类型（整型、浮点型、double 型、字符串和指针）的数据项。
流插入运算符 << 在一个语句中可以多次使用，如上面实例中所示，endl 用于在行末添加一个换行符。
4.3 标准输入流（cin）
预定义的对象 cin 是 iostream 类的一个实例。cin 对象附属到标准输入设备，通常是键盘。cin 是与流提取运算符 >> 结合使用的，如下所示：
#include <iostream>using namespace std;int main( )
{char name[50];cout << "请输入您的名称： ";cin >> name;cout << "您的名称是： " << name << endl;}输出：
请输入您的名称： cplusplus
您的名称是： cplusplus
C++ 编译器根据要输入值的数据类型，选择合适的流提取运算符来提取值，并把它存储在给定的变量中。
流提取运算符 >> 在一个语句中可以多次使用，如果要求输入多个数据，可以使用如下语句：
cin >> name >> age;
//相当于下面两个语句
cin >> name;
cin >> age;
4.4 标准错误流（cerr）
预定义的对象 cerr 是 iostream 类的一个实例。cerr 对象附属到标准输出设备，通常也是显示屏，但是 cerr 对象是非缓冲的，且每个流插入到 cerr 都会立即输出。
cerr 也是与流插入运算符 << 结合使用的，如下所示：
#include <iostream>using namespace std;int main( )
{char str[] = "Unable to read....";cerr << "Error message : " << str << endl;
}输出：
Error message : Unable to read....
4.5 标准日志流（clog）
预定义的对象 clog 是 iostream 类的一个实例。clog 对象附属到标准输出设备，通常也是显示屏，但是 clog 对象是缓冲的。这意味着每个流插入到 clog 都会先存储在缓冲区，直到缓冲填满或者缓冲区刷新时才会输出。
clog 也是与流插入运算符 << 结合使用的，如下所示：
#include <iostream>using namespace std;int main( )
{char str[] = "Unable to read....";clog << "Error message : " << str << endl;
}输出：
Error message : Unable to read....
通过这些小实例，我们无法区分 cout、cerr 和 clog 的差异，但在编写和执行大型程序时，它们之间的差异就变得非常明显。所以良好的编程实践告诉我们，使用 cerr 流来显示错误消息，而其他的日志消息则使用 clog 流来输出。
五 结构体（struct）
C/C++ 数组允许定义可存储相同类型数据项的变量，但是结构是 C++ 中另一种用户自定义的可用的数据类型，它允许您存储不同类型的数据项。
结构用于表示一条记录，假设您想要跟踪图书馆中书本的动态，您可能需要跟踪每本书的下列属性：
- Title ：标题
- Author ：作者
- Subject ：类目
- Book ID ：书的 ID
5.1 定义结构
在 C++ 中，struct 语句用于定义结构体（structure）。
结构体是一种用户自定义的数据类型，用于将不同类型的数据组合在一起。与类（class）类似，结构体允许你定义成员变量和成员函数。
为了定义结构，您必须使用 struct 语句。struct 语句定义了一个包含多个成员的新的数据类型，struct 语句的格式如下：
struct type_name {
member_type1 member_name1;
member_type2 member_name2;
member_type3 member_name3;
.
.
} object_names;type_name 是结构体类型的名称，member_type1 member_name1 是标准的变量定义，比如 int i; 或者 float f; 或者其他有效的变量定义。在结构定义的末尾，最后一个分号之前，您可以指定一个或多个结构变量，这是可选的。下面是声明一个结构体类型 Books，变量为 book：
struct Books
{char title[50];char author[50];char subject[100];int book_id;
} book;结构体优点：
- 简单数据封装：适合封装多种类型的简单数据，通常用于数据的存储。
- 轻量级：相比
class，结构体语法更简洁，适合小型数据对象。 - 面向对象支持：支持构造函数、成员函数和访问权限控制，可以实现面向对象的设计。
5.2 访问结构成员
为了访问结构的成员，我们使用成员访问运算符（.）。成员访问运算符是结构变量名称和我们要访问的结构成员之间的一个句号。
下面的实例演示了结构的用法：
#include <iostream>
#include <cstring>using namespace std;// 声明一个结构体类型 Books
struct Books
{char title[50];char author[50];char subject[100];int book_id;
};int main( )
{Books Book1; // 定义结构体类型 Books 的变量 Book1Books Book2; // 定义结构体类型 Books 的变量 Book2// Book1 详述strcpy( Book1.title, "C++ 教程");strcpy( Book1.author, "Runoob"); strcpy( Book1.subject, "编程语言");Book1.book_id = 12345;// Book2 详述strcpy( Book2.title, "CSS 教程");strcpy( Book2.author, "Runoob");strcpy( Book2.subject, "前端技术");Book2.book_id = 12346;// 输出 Book1 信息cout << "第一本书标题 : " << Book1.title <<endl;cout << "第一本书作者 : " << Book1.author <<endl;cout << "第一本书类目 : " << Book1.subject <<endl;cout << "第一本书 ID : " << Book1.book_id <<endl;// 输出 Book2 信息cout << "第二本书标题 : " << Book2.title <<endl;cout << "第二本书作者 : " << Book2.author <<endl;cout << "第二本书类目 : " << Book2.subject <<endl;cout << "第二本书 ID : " << Book2.book_id <<endl;return 0;
}实例中定义了结构体类型 Books 及其两个变量 Book1 和 Book2。当上面的代码被编译和执行时，它会产生下列结果：
第一本书标题 : C++ 教程
第一本书作者 : Runoob
第一本书类目 : 编程语言
第一本书 ID : 12345
第二本书标题 : CSS 教程
第二本书作者 : Runoob
第二本书类目 : 前端技术
第二本书 ID : 12346
5.3 结构作为函数参数
您可以把结构作为函数参数，传参方式与其他类型的变量或指针类似。您可以使用上面实例中的方式来访问结构变量：
#include <iostream>
#include <cstring>using namespace std;
void printBook( struct Books book );// 声明一个结构体类型 Books
struct Books
{char title[50];char author[50];char subject[100];int book_id;
};int main( )
{Books Book1; // 定义结构体类型 Books 的变量 Book1Books Book2; // 定义结构体类型 Books 的变量 Book2// Book1 详述strcpy( Book1.title, "C++ 教程");strcpy( Book1.author, "Runoob"); strcpy( Book1.subject, "编程语言");Book1.book_id = 12345;// Book2 详述strcpy( Book2.title, "CSS 教程");strcpy( Book2.author, "Runoob");strcpy( Book2.subject, "前端技术");Book2.book_id = 12346;// 输出 Book1 信息printBook( Book1 );// 输出 Book2 信息printBook( Book2 );return 0;
}
void printBook( struct Books book )
{cout << "书标题 : " << book.title <<endl;cout << "书作者 : " << book.author <<endl;cout << "书类目 : " << book.subject <<endl;cout << "书 ID : " << book.book_id <<endl;
}当上面的代码被编译和执行时，它会产生下列结果：
书标题 : C++ 教程
书作者 : Runoob
书类目 : 编程语言
书 ID : 12345
书标题 : CSS 教程
书作者 : Runoob
书类目 : 前端技术
书 ID : 12346
5.4 结构体的各个部分详细介绍
-
struct 关键字：用于定义结构体，它告诉编译器后面要定义的是一个自定义类型。
-
成员变量：成员变量是结构体中定义的数据项，它们可以是任何基本类型或其他自定义类型。在 struct 中，这些成员默认是 public，可以直接访问。
-
成员函数：结构体中也可以包含成员函数，这使得结构体在功能上类似于类。成员函数可以操作结构体的成员变量，提供对数据的封装和操作。
-
访问权限：与 class 类似，你可以在 struct 中使用 public、private 和 protected 来定义成员的访问权限。在 struct 中，默认所有成员都是 public，而 class 中默认是 private。
5.5 指向结构的指针
您可以定义指向结构的指针，方式与定义指向其他类型变量的指针相似，如下所示：
struct Books *struct_pointer;
现在，您可以在上述定义的指针变量中存储结构变量的地址。为了查找结构变量的地址，请把 & 运算符放在结构名称的前面，如下所示：
struct_pointer = &Book1;
为了使用指向该结构的指针访问结构的成员，您必须使用 -> 运算符，如下所示：
struct_pointer->title;
让我们使用结构指针来重写上面的实例，这将有助于您理解结构指针的概念：
#include <iostream>
#include <string>using namespace std;// 声明一个结构体类型 Books
struct Books
{string title;string author;string subject;int book_id;// 构造函数Books(string t, string a, string s, int id): title(t), author(a), subject(s), book_id(id) {}
};// 打印书籍信息的函数
void printBookInfo(const Books& book) {cout << "书籍标题: " << book.title << endl;cout << "书籍作者: " << book.author << endl;cout << "书籍类目: " << book.subject << endl;cout << "书籍 ID: " << book.book_id << endl;
}int main()
{// 创建两本书的对象Books Book1("C++ 教程", "csdn", "编程语言", 12345);Books Book2("CSS 教程", "csdn", "前端技术", 12346);// 输出书籍信息printBookInfo(Book1);printBookInfo(Book2);return 0;
}输出：
书标题 : C++ 教程
书作者 : csdn
书类目 : 编程语言
书 ID : 12345
书标题 : CSS 教程
书作者 : csdn
书类目 : 前端技术
书 ID : 12346
5.6 typedef 关键字
下面是一种更简单的定义结构的方式，您可以为创建的类型取一个"别名"。例如：
typedef struct Books
{char title[50];char author[50];char subject[100];int book_id;
}Books;
可以直接使用 Books 来定义 Books 类型的变量，而不需要使用 struct 关键字。下面是实例：
Books Book1, Book2;
可以使用 typedef 关键字来定义非结构类型，如下所示：
typedef long int *pint32;pint32 x, y, z;
x, y 和 z 都是指向长整型 long int 的指针。
5.7 结构体与类的区别
在 C++ 中，struct 和 class 本质上非常相似，唯一的区别在于默认的访问权限：
struct默认的成员和继承是public。class默认的成员和继承是private。
可以将 struct 当作一种简化形式的 class，适合用于没有太多复杂功能的简单数据封装。
5.7.1 结构体与函数的结合
可以通过构造函数初始化结构体，还可以通过引用传递结构体来避免不必要的拷贝。
struct Books {string title;string author;string subject;int book_id;// 构造函数Books(string t, string a, string s, int id): title(t), author(a), subject(s), book_id(id) {}void printInfo() const {cout << "书籍标题: " << title << endl;cout << "书籍作者: " << author << endl;cout << "书籍类目: " << subject << endl;cout << "书籍 ID: " << book_id << endl;}
};void printBookByRef(const Books& book) {book.printInfo();
}六 C++ vector 容器
C++ 中的 vector 是一种序列容器，它允许你在运行时动态地插入和删除元素。
vector 是基于数组的数据结构，但它可以自动管理内存，这意味着你不需要手动分配和释放内存。
与 C++ 数组相比，vector 具有更多的灵活性和功能，使其成为 C++ 中常用的数据结构之一。
vector 是 C++ 标准模板库（STL）的一部分，提供了灵活的接口和高效的操作。
基本特性:
- 动态大小：
vector的大小可以根据需要自动增长和缩小。 - 连续存储：
vector中的元素在内存中是连续存储的，这使得访问元素非常快速。 - 可迭代：
vector可以被迭代，你可以使用循环（如for循环）来访问它的元素。 - 元素类型：
vector可以存储任何类型的元素，包括内置类型、对象、指针等。
使用场景：
- 当你需要一个可以动态增长和缩小的数组时。
- 当你需要频繁地在序列的末尾添加或移除元素时。
- 当你需要一个可以高效随机访问元素的容器时。
要使用 vector，首先需要包含 <vector> 头文件：
#include <vector>6.1 创建 Vector
创建一个 vector 可以像创建其他变量一样简单：
std::vector<int> myVector; // 创建一个存储整数的空 vector这将创建一个空的整数向量,也可以在创建时指定初始大小和初始值：
std::vector<int> myVector(5); // 创建一个包含 5 个整数的 vector，每个值都为默认值（0）
std::vector<int> myVector(5, 10); // 创建一个包含 5 个整数的 vector，每个值都为 10or:
std::vector<int> vec; // 默认初始化一个空的 vector
std::vector<int> vec2 = {1, 2, 3, 4}; // 初始化一个包含元素的 vector6.2 添加元素
可以使用 push_back 方法向 vector 中添加元素：
myVector.push_back(7); // 将整数 7 添加到 vector 的末尾6.3 访问元素
可以使用下标操作符 [] 或 at() 方法访问 vector 中的元素：
int x = myVector[0]; // 获取第一个元素
int y = myVector.at(1); // 获取第二个元素6.4 获取大小
可以使用 size() 方法获取 vector 中元素的数量：
int size = myVector.size(); // 获取 vector 中的元素数量6.5 迭代访问
可以使用迭代器遍历 vector 中的元素：
for (auto it = myVector.begin(); it != myVector.end(); ++it) {std::cout << *it << " ";
}or 使用范围循环：
for (int element : myVector) {std::cout << element << " ";
}6.6 删除元素
可以使用 erase() 方法删除 vector 中的元素：
myVector.erase(myVector.begin() + 2); // 删除第三个元素6.7 清空 Vector
可以使用 clear() 方法清空 vector 中的所有元素：
myVector.clear(); // 清空 vector实例：以下是一个完整的使用实例，包括创建 vector、添加元素、访问元素以及输出结果的代码：
#include <iostream>
#include <vector>int main() {// 创建一个空的整数向量std::vector<int> myVector;// 添加元素到向量中myVector.push_back(3);myVector.push_back(7);myVector.push_back(11);myVector.push_back(5);// 访问向量中的元素并输出std::cout << "Elements in the vector: ";for (int element : myVector) {std::cout << element << " ";}std::cout << std::endl;// 访问向量中的第一个元素并输出std::cout << "First element: " << myVector[0] << std::endl;// 访问向量中的第二个元素并输出std::cout << "Second element: " << myVector.at(1) << std::endl;// 获取向量的大小并输出std::cout << "Size of the vector: " << myVector.size() << std::endl;// 删除向量中的第三个元素myVector.erase(myVector.begin() + 2);// 输出删除元素后的向量std::cout << "Elements in the vector after erasing: ";for (int element : myVector) {std::cout << element << " ";}std::cout << std::endl;// 清空向量并输出myVector.clear();std::cout << "Size of the vector after clearing: " << myVector.size() << std::endl;return 0;
}以上代码创建了一个整数向量，向其中添加了几个元素，然后输出了向量的内容、元素的访问、向量的大小等信息，接着删除了向量中的第三个元素，并输出删除元素后的向量。最后清空了向量，并输出清空后的向量大小。
输出结果为：
Elements in the vector: 3 7 11 5
First element: 3
Second element: 7
Size of the vector: 4
Elements in the vector after erasing: 3 7 5
Size of the vector after clearing: 0七 数据结构
C++ 提供了多种数据结构，既有基础的如数组、结构体、类等，也有高级的 STL 容器如 vector、map 和 unordered_map 等。
下面详细介绍 C++ 中常用的数据结构及其特点和用法。
7.1 数组（Array）
数组是最基础的数据结构，用于存储一组相同类型的数据。
特点：
- 固定大小，一旦声明，大小不能改变。
- 直接访问元素，时间复杂度为 O(1)。
- 适合处理大小已知、元素类型相同的集合。
int arr[5] = {1, 2, 3, 4, 5};
cout << arr[0]; // 输出第一个元素优缺点：
- 优点：访问速度快，内存紧凑。
- 缺点：大小固定，无法动态扩展，不适合处理大小不确定的数据集。
7.2 结构体（Struct）
结构体允许将不同类型的数据组合在一起，形成一种自定义的数据类型。
特点：
- 可以包含不同类型的成员变量。
- 提供了对数据的基本封装，但功能有限。
示例：
struct Person {string name;int age;
};
Person p = {"Alice", 25};
cout << p.name << endl; // 输出 Alice7.3 类（Class）
类是 C++ 中用于面向对象编程的核心结构，允许定义成员变量和成员函数。与 struct 类似，但功能更强大，支持继承、封装、多态等特性。
特点：
- 可以包含成员变量、成员函数、构造函数、析构函数。
- 支持面向对象特性，如封装、继承、多态。
class Person {
private:string name;int age;
public:Person(string n, int a) : name(n), age(a) {}void printInfo() {cout << "Name: " << name << ", Age: " << age << endl;}
};
Person p("Bob", 30);
p.printInfo(); // 输出: Name: Bob, Age: 307.4 链表（Linked List）
链表是一种动态数据结构，由一系列节点组成，每个节点包含数据和指向下一个节点的指针。
特点：
- 动态调整大小，不需要提前定义容量。
- 插入和删除操作效率高，时间复杂度为 O(1)（在链表头部或尾部操作）。
- 线性查找，时间复杂度为 O(n)。
struct Node {int data;Node* next;
};
Node* head = nullptr;
Node* newNode = new Node{10, nullptr};
head = newNode; // 插入新节点优缺点：
- 优点：动态大小，适合频繁插入和删除的场景。
- 缺点：随机访问效率低，不如数组直接访问快。
7.5 栈 （Stack）
栈是一种后进先出（LIFO, Last In First Out）的数据结构，常用于递归、深度优先搜索等场景。
特点：
- 只允许在栈顶进行插入和删除操作。
- 时间复杂度为 O(1)。
stack<int> s;
s.push(1);
s.push(2);
cout << s.top(); // 输出 2
s.pop();优缺点：
- 优点：操作简单，效率高。
- 缺点：只能在栈顶操作，访问其他元素需要弹出栈顶元素。
7.6 队列（Queue）
队列是一种先进先出（FIFO, First In First Out）的数据结构，常用于广度优先搜索、任务调度等场景。
特点：
- 插入操作在队尾进行，删除操作在队头进行。
- 时间复杂度为 O(1)。
queue<int> q;
q.push(1);
q.push(2);
cout << q.front(); // 输出 1
q.pop();优缺点：
- 优点：适合按顺序处理数据的场景，如任务调度。
- 缺点：无法随机访问元素。
7.7 双端队列（Deque）
双端队列允许在两端进行插入和删除操作，是栈和队列的结合体。
特点：
- 允许在两端进行插入和删除。
- 时间复杂度为 O(1)。
deque<int> dq;
dq.push_back(1);
dq.push_front(2);
cout << dq.front(); // 输出 2
dq.pop_front();优缺点：
- 优点：灵活的双向操作。
- 缺点：空间占用较大，适合需要在两端频繁操作的场景。
7.8 哈希表（Hash Table）
哈希表是一种通过键值对存储数据的数据结构，支持快速查找、插入和删除操作。C++ 中的 unordered_map 是哈希表的实现。
特点：
- 使用哈希函数快速定位元素，时间复杂度为 O(1)。
- 不保证元素的顺序。
unordered_map<string, int> hashTable;
hashTable["apple"] = 10;
cout << hashTable["apple"]; // 输出 10优缺点：
- 优点：查找、插入、删除操作效率高。
- 缺点：无法保证元素顺序，哈希冲突时性能会下降。
7.9 映射（Map）
map 是一种有序的键值对容器，底层实现是红黑树。与 unordered_map 不同，它保证键的顺序，查找、插入和删除的时间复杂度为 O(log n)。
特点：
- 保证元素按键的顺序排列。
- 使用二叉搜索树实现。
map<string, int> myMap;
myMap["apple"] = 10;
cout << myMap["apple"]; // 输出 10优缺点：
- 优点：元素有序，适合需要按顺序处理数据的场景。
- 缺点：操作效率比
unordered_map略低。
7.10 集合（Set）
set 是一种用于存储唯一元素的有序集合，底层同样使用红黑树实现。它保证元素不重复且有序。
特点：
- 保证元素的唯一性。
- 元素自动按升序排列。
- 时间复杂度为 O(log n)
set<int> s;
s.insert(1);
s.insert(2);
cout << *s.begin(); // 输出 1优缺点：
- 优点：自动排序和唯一性保证。
- 缺点：插入和删除的效率不如无序集合。
7.11 动态数组（Vector）
vector 是 C++ 标准库提供的动态数组实现，可以动态扩展容量，支持随机访问。
特点：
- 动态调整大小。
- 支持随机访问，时间复杂度为 O(1)。
- 当容量不足时，动态扩展，时间复杂度为摊销 O(1)。
vector<int> v;
v.push_back(1);
v.push_back(2);
cout << v[0]; // 输出 1优缺点：
- 优点：支持随机访问，动态扩展。
- 缺点：插入和删除中间元素的效率较低。
内容摘录学习自：C++ 数据结构 | 菜鸟教程