2026《数据结构》考研复习笔记一（C++基础知识）

一、数据类型

1.1基本类型

基本类型	描述	字节（位数）	范围
char	字符类型，存储ASCLL字符	1（8位）	-128 到 127 或 0 到 255（依赖编辑器）
signed char	有符号字符	1（8位）	-128 到 127
unsigned char	无符号字符	1（8位）	0到255
int	整型	4（32位）	-2,147,483,648 到 2,147,483,647
unsigned int	无符号整型	4（32位）	0 到 4,294,967,295
float	单精度浮点数	4（32位）	约 ±3.4e±38（6-7 位有效数字）
double	双精度浮点数	8（64位）	约 ±1.7e±308（15 位有效数字）

笔记：复习基本数据类型的取值范围和计算方法
【跳转复习总结】

1.2C++新增类型

C++11新增类型	描述	示例
auto	让编辑器自动推断类型 简化迭代器：auto it=vec.begin(); Lambda表达式：auto add=[](int a,int b){return a+b;};	auto x=10;
decltype	获取表达式的类型 模板编程：auto add(T,a,U b)->decltype(a+b){return a+b;} Lambda返回类型：auto func=[](int a,double b)->decltype(a+b){return a+b;}; 依赖表达式类型的变量声明：decltype(vec.size())len=vec.size();	decltype(x) y=20;
initializer_list	初始化列表类型 初始化容器：vectorv={1,2,3} 初始化自定义类型：MyClass(initializer)listargs){}MyClass obj={10,20,30}; 作为函数参数：void print(initializer_list< int>vals){}print({1,2,3});	initializer_list list = {1, 2, 3};
tuple	元组类型，存储多个不同类型的值	tuple

笔记：复习迭代器和Lambda表达式
【跳转复习总结】

1.3派生类型

派生类型	描述	示例
数组	相同类型元素的集合	int arr[5]={1,2,3};
指针	存储变量内存地址的类型	int* p=&x;
引用	ref和x指向同一块地址	int & ref=x;
函数	函数类型，表示函数名	int func(int a,int b);
结构体	用户自定义数据类型，可包含不同的类型成员	struct Piont{int x;int y;);
类	用户定义的数据类型，支持封装、继承和多态	class MyClass{};
联合体	多个成员共享同一块内存	union Data{int x;float f;};
枚举	用户定义的整数常量集合	enum Color{RED,GREEN;};

笔记：复习函数指针、结构体赋值和类
【跳转复习总结】

1.4别名

别名	描述	示例
#define	文本替换（预处理器处理），不进行类型检查	#define Myint int
typedef	类型别名（编辑器处理）	typedef int Myint;
using	类型别名（编辑器处理）	using Myint=int;

1.5标准库类型

标准库类型	描述	示例
string	字符串类型	string s="hello";
vector	动态数组	vector< int >v={1,2,3};
pair	存储两个值的容器	pair< int,float>p(1,2.0);
map	键值对容器	map< int,string>m;
set	唯一值集合	set< int>s={1,2,3};

笔记：复习map和set的区别，理解红黑树的原理
【跳转复习总结】

1.6枚举类型
enum 枚举名{
标识符[=整型常数],
标识符[=整型常数],
……
标识符[=整型常数],
}枚举变量;

例如enum color{red,green,blue}c;
c=blue;

默认情况下，第一个名称为0，第二个为1，以此类推。还可以赋值enum color{red,green=5,blue};

1.7类型转换

常量转换	用于将const类型的对象转换为非const类型的对象。 const int i=10; int &r=const_cast< int&>(i);
重新解释转换	将一个数据类型的二进制内存表示按另一个数据类型解释，属于强制按位转化 int i=10; float f=reinterpret_cast< float&>(i);//f=1.4013e-44
静态转换	将一种数据类型的值强制转换为另一种数据类型的值，通常用于类型相似的对象之间的转换，如int转换为float int i=10; float f=static_cast< float>(i);
动态转换	用于在继承层次结构中进行向下转换（downcasting）的一种机制，通常用于将一个基类指针或引用转换为派生类指针或引用

二、修饰符和运算符

2.1修饰符

const	const定义常量，表示该变量的值不能被修改
static	static定义静态变量，表示该变量的作用域仅限于当前文件或当前函数内，不会被其他文件函数访问

2.2运算符

.（点）和->（箭头）	成员运算符用于引用类、结构和共同体的成员
&	指针运算符&返回变量的地址，例如&a给出变量的实际地址
*	指针运算符*表示解引用。指针var的值是内存地址，*var访问该内存地址的存放内容

注：

• 成员运算符.使用对象是对象实例，如p.name。成员运算符->使用对象是指针指向的对象（相当于先解引用再使用.），即p->name≡(*p).name
• int *x=&y;int z=*x;其中&y表示获取y的内存地址，指针x的值是y的内存地址；*x表示获取x指向的内存地址的存放内容，z的值是x指向的内存地址的存放内容

三、Lambda函数和表达式

一般形式：[capture] (parameters)->return-type{body}	[] (int x,int y)->int{int z=x+y;return z+x;}
特殊情况：[capture] (parameters){body}。“没有返回值”或者“Lambda仅包含一个return语句”	[]{global_x++;} [] (int x,int y){return x

在Lambda表达式内可以访问当前作用域的变量，可以通过前面的[]指定

[]	没有定义任何变量。使用未定义变量会引发错误
[x,&y]	x以传值方式传入（默认），y以引用方式传入
[&]	任何被使用到的外部变量都隐式地以引用方式加以引用
[=]	任何被使用到的外部变量都隐式地以传值方式加以引用
[&,x]	x显示地以传值方式加以引用，其余变量以引用方式加以引用
[=,&z]	z显示地以引用方式加以引用，

四、数学函数

double sqrt(double);	sqrt(x)返回√x
double pow(double,double);	pow(x,y)返回xy
double floor(double);	向下取整（小于或等于参数的最大整数）
double ceil(double);	向上取整（大于或等于参数的最小函数）
int rand();	随机数函数，通常与srand()time()函数搭配 srand((unsigned)time(NULL));//void srand(unsigned int seed); int r=rand();

五、字符串

5.1C字符串

strcpy(s1,s2);	复制字符串s2到字符串s1
strcat(s1,s2);	连接字符串s2到字符串s1的末尾
strlen(s1);	返回字符串s1的长度
strcmp(s1,s2);	if(s1==s2)return 0; else if(s1 < s2)return -1; else return 1;
strchr(s1,ch);	返回一个指针，指向字符串s1中字符ch第一次出现的位置
strstr(s1,s2);	返回一个指针，指向字符串s1中字符串s2第一次出现的位置

5.2C++的string类

str1=str2;	复制字符串s2到字符串s1
str3=str1+str2;	连接字符串s2到字符串s1的末尾
str1.size();	返回字符串s1的长度

六、结构体

6.1定义处命名
struct type_name{
member_type1 member_name1;
member_type2 member_name2;
member_type3 member_name3;
}object_names;

注释：type_name是结构体类型名，object_names是结构体变量名。结构体成员访问运算符（.），如a.name

6.2typedef关键字
typedef struct Books{
char title[50];
char author[50];
char subject[100];
int book_id;
}Books;
为Book{…}结构体取别名Books，可以用Books来定义Book类型的变量而不需要struct关键字，如Books book1;

复习总结

1. 复习基本数据类型的取值范围和计算方法(计算机组成原理）
2. 复习迭代器和Lambda表达式（leetcode）
3. 复习函数指针、结构体和类
4. 复习map和set的区别，理解红黑树的原理

后记：关于C++的高级教程和重点知识点代码以后可能会继续出，目前只总结基础知识点，前面内容总结自【菜鸟教程】，笔记只摘录了本人的疑难杂症，若有更多问题可以访问该网站，同时欢迎大家指正和批判文章中的内容，如果有格式上的优化建议也欢迎评论

---

2025.4.18：

记：复习到前置递增和后置递增的时候意识到返回值不同（有兴趣可以查看我的第二篇笔记——2026《数据结构》考研复习笔记二（C++面向对象）中关于运算符重载部分的递增运算符++重载），想起来老师曾经强调过这是个重点，因此特别讨论一下。在此只给出前置递增和后置递增的成员函数代码：

前置++x与后置x++的区别

//前置递增（成员函数）
class Counter {
private:int count;
public:Counter(int c = 0) :count(c) {}Counter& operator++() {++count;return *this;}int getCount()const { return count; }
};//后置递增（成员函数）
class Counter {
private:int count;
public:Counter(int c = 0) :count(c) {}Counter operator++(int) {Counter temp = *this;count++;return temp;}int getCount()const { return count; }
};

在C++中，内置类型的前缀递增操作返回的是引用（即变量本身）。例如：

int x=0;
++(++x);//合法，因为++x返回的是x的引用
(++x)++//合法，同上

然而，后缀递增操作返回的是值（临时变量）

int x=0;
++(x++);//不合法，相当于++(0)
(x++)++//不合法，同上

---

2025.4.19

记：整理类的运算符重载时对const和static修饰符的使用概念模模糊糊，特地整理一下相关知识点，部分内容与计算机组成原理有关，等回头专门仔细介绍一下存储器的知识点

const修饰符

• 基本用法：

    /*修饰变量*/const int a = 10;//a的值不可修改//a=20;//不合法/*修饰指针*///1.指向常量的指针const int b = 10;const int* p = &b;//指针可以指向其它地址，但不能通过p修改指向的值//*p=20;//不合法——首先b为常量不能修改，其次不能通过p修改指向的值int c = 10;p = &c;//可以指向非const变量，也可以修改指针的值//*p = 20;//不能通过p修改指向的值//2.常量指针int d = 10;int* const q = &d;//指针不能指向其他地址，但可以通过p修改指向的值*q = 20;//可以通过p修改指向的值//q = &c;//不合法，不能修改指针的值//int* const q1 = &b;//不合法，int* const指针不能指向const int常量//3.指向常量的常量指针const int e = 10;const int* const p = &e;//即不能修改指针，也不能通过指针修改值/*修饰引用*/const int f = 10;const int& ref = f;//不能通过ref修改f的值//ref = 20;//不合法

• 类的const成员函数

    /*类的const成员函数*///在类中，const可以修饰成员函数，表示该函数不会修改类的成员变量class Myclass {public:void nonConstFunc();//普通成员函数void constFunc()const;//const成员函数};/*const成员函数的访问与调用*///1.不能修改成员变量，但可以访问成员变量class MyClass {int val;public:void tryModify()const {//val=10;//不合法，const成员函数不能修改成员变量}};//2.可以调用其他const成员函数class MyClass {int val;public:int getValue()const {return val;}void ConstFunc()const {getValue();//允许调用其他的const成员函数}};//3.不能调用非const成员函数class MyClass {int val;public:void set(int v) {val = v;}void ConstFunc()const {//set(10);//const成员函数不可以调用非const成员函数}};/*const成员函数对参数的要求*///1.接受const和非const参数class MyClass {public:void process(const string& str)const {//可以处理const引用参数}};//2.不能修改非const引用或指针的内容class MyClass {public:void process(int& num)const {//num=10;//不合法，即使参数是非const，也不能修改其内容}};

static修饰符

static成员函数的特点：

1. 不依赖于类实例：可以直接通过类名调用，不需要对象实例
2. 没有this指针，因为他不与任何特定对象关联
3. 存储方式：在程序的生命周期只有一份存在

• static成员函数可以调用的内容

    //1.其他static成员函数class Myclass {public:static void func1() {func2();}static void func2() {}};//2.static成员变量class Myclass {static int count;public:static void increment() {count++;//可以访问和修改static成员变量}};//3.类外部的普通函数和全局变量int globalVar = 0;class Myclass {public:static void func() {globalVar = 10;::printf("Hello");}};

• static成员函数不能调用的内容

    //1.非static成员函数class Myclass {int val;public:static void staticFunc() {//val=10;//不合法，不能访问非static成员变量}};//2.非static成员函数class Myclass {public:void nonStaticFunc() {}static void staticFunc() {//nonStaticFunc();//不合法，不能直接调用非static成员函数}};//3.this指针class Myclass {public:void nonStaticFunc() {//this->something;//不合法，static没有this指针}};

特殊情况：
间接访问非static成员——传递对象实例

class MyClass {int value;
public:static void staticFunc(MyClass& obj) {obj.value = 10;  // 通过对象参数访问obj.nonStaticFunc();  // 通过对象参数调用}void nonStaticFunc() {}
};

---

2025.4.20

mallo()函数
void* malloc(size_t size);

• 返回值：成功时返回指向分配内存的指针（类型为void*，通常需要类型转换），失败时返回NULL
• 参数：size要分配的字节数，通常为sizeof(type)*num
• 释放空间：free§;//p是要释放的指针

结构体-C和C++类型定义的区别

• C结构体：带struct关键字。如struct Node node;或者定义时使用typedef关键字typedef struct Node{…}Node,*ListNode
• C++结构体：直接使用结构体名。如Node node;或者Node*node

注意：上述C结构体typedef struct Node{…}Node,* ListNode中Node等效于struct Node,ListNode等效于struct Node*,同时等效于Node*(因为Node等效于struct Node)