每天必备复习小知识（待更）

学习小知识

1. Linux 命令

cd 切换工作目录
ls 查看目标文件夹中的文件内容
	-a 所有内容，包括隐藏文件和文件夹
	-l 列表形式展示，可以看到文件或者文件夹的权限内容，最后修改时间，所属权.. 
    -al 
    	权限内容	rwxrwxr-x
    			   拥有者 可读可写可执行
    			   同组人 可读可写可执行
    			   访客 可读不可写可执行
mkdir 创建文件夹
touch 创建普通文件
cp 拷贝复制文件或者文件夹
	如果是文件夹需要使用命令行参数 -r 
mv 移动/重命名目标文件过着文件夹
	文件夹操作
		mv a c ---> c 文件夹不存在，是将 a 文件夹重命名为 c 
		mv a b ---> b 文件夹存在，是将 a 文件夹移动到 b 文件夹中
rm 删除文件/或者文件夹操作
	删除操作【慎用】
	如果是文件夹，rm 操作需要使用 -rf 命令行参数
pwd 展示当前工作目录绝对路径
ifconfig 查看当前设备网络情况
cat 查看文件内容
tac 倒叙查看文件内容
nl 带有行号查看文件内容
tar -cvf 压缩
		tar -cvf test.tar 1.txt 2.txt
	-xvf 解压缩
		tar -xvf test.tar
		tar -xvf test.tar -c 指定路径
ping 测试目前网络到达其他主机的数据情况
sudo 开启超级权限，需要使用密码
chmod 
	修改文件或者文件夹权限
	r = 4
    w = 2 
    x = 1
    sudo chmod 775 1.txt ==> rwxrwxr-x
    sudo chmod 775 1.txt ==> rwxr-xr-x

2. Vim

三种模式
	编辑模式，插入模式，命令模式
	
	编辑模式 == i or o ==> 转换到插入模式
	编辑模式 == shift + : ==> 命令模式
	任意模式回到编辑模式都是 ESC
	
	编辑模式对应的常用命令
		yy yny dd dnd ngg gg p u
	命令模式常用的命令组合
		w ==> 保存
		wq ==> 保存退出
		q! ==> 不考虑保存情况，强制退出
		q ==> 退出
		wa ==> 保存 vim 打开的所有文件
		wqa ==> 保存退出 vim 打开的所有文件
		vsplit 文件名 ==> 在vim 中并列打开多个文件	

3. 基本数据类型有哪些，占用内存空间大小是多少？

整型：
	short 2 字节
	int 4 字节（32 位机及其以上）
	long 8 字节（64 位机及其以上）
浮点型：
	float 4 字节
	double 8 字节
字符型：
	char 1 字节
布尔型：
	bool 1 字节（C 语言中没有）

4. 变量定义的格式和要求

数据类型 变量名 = 初始化数据;

要求：
	1. 一行有且只能定义一个变量，并且在必要的情况下提供对应的注释
	2. 变量在没有进行赋值的情况下，不得参与除赋值之前的其他操作
	3. 建议变量定义之后直接进行必要的合理的初始化操作
	4. 变量先定义后使用，未定义不得使用
	5. 变量定义在一定范围内不得重复
	6. 【数据类型一致化】

5. 变量定义的常见错误

1. 未定义直接使用
	a. 变量确实未定义
	b. 拼写错误
2. 变量野值问题
	变量在没有进行赋值操作之前，不可以参与除赋值之外的其他操作，避免野值问题
3. 变量重复定义
	在用一个区域内不允许出现同名变量
4. 使用建议
	a. 给予 float 类型变量赋值，使用的常量建议末尾加上大写 F 明确告知编译器当前常量为 float 类型
	b. 给予 long 类型变量赋值，使用的常量建议末尾加上大写 L 明确告知编译器当前常量为 long 类型
	【严格遵守类型一致化要求】

6. 分支结构有哪些

1. if () 
   {}
   
2. if () 
   {} 
   else 
   {}
   
3. if () 
   {} 
   else if () 
   {} 
   else 
   {}

4. switch () 
{
    case 1:
        break;
    case 2:
        break;
        ......
    default
        break;    
}

7. 循环结构有哪些？

1. while ()
   {}

2. do
   {}
   while ();

3. for (循环条件初始化; 循环条件判断; 循环条件修改)
   { 循环体 }

break: 可以用于跳出一层循环结构或者 switch case 分支结构
continue: 结束当前次循环，直接进入下一次循环，推荐和 for 循环配合使用

for 循环结构图里分析流程

8. 数组定义的格式

1. 静态类型定义

数据类型 数组名[容量] = {初始化数据};

数据类型:
	明确当前数组存储的数据类型是哪一个，有且只允许存储对应数据类型，严格遵守数据类型一致化原则。
	
数组名:
	1. 操作数组使用的必要名称
	2. 数组名存储当前数组数据在内存中的【首地址】，是一个指针变量

[容量]:
	确定当前数组的容量关系，允许最多存储多少个元素，并且一旦容量确定无法修改
	
{初始化数据}:
	针对当前数组数据类型要求，提供满足数据类型限制的初始化数据内容。

2. 动态类型定义

数据类型 数组名 = new 数据类型[容量];

9. 数组有效下表范围

数组有效下标是 0 ~ 数组容量 - 1

int arr[10]
	例如以上数组有效下表范围是 0 ~ 9

10. 尾插法添加数据方式概述

在有效元素末尾添加下一个元素
定义一个 int 类型变量 count/size，初始化为 0
	1. 添加数据元素 首先放入到下标为 count/size 对应的位置
	2. count / size += 1 操作
	
	count/size
		记录当前添加的有效元素个数
		每一次存储数据的下标位置

11. 数组作为函数参数有哪些要求

C/C++ 语言要求，数组作为函数的参数必须提供两个数据
	1. 数组本身，实际上是数组的空间首地址
	2. 数组对应容量，限制函数中操作数组范围

12. 自增自减运算符语法要求

++
--
	自增自减运算符有且只允许操作变量，不可以操作常量
	自增自减运算符在变量之前，首先执行自增自减操作，之后提供数据参与当前代码执行
	自增自减运算符在变量之后，首先取值变量数据参与当前代码行执行，之后执行变量自增自减操作

13. 运算符有哪些？

算术运算符	
	+ - * / % () =
增强版算术运算符
	+= -= *= /= %=
自增自减运算符
	++ -- 推荐使用 += 1 和 -= 1 替代
关系运算符
	> < >= <= != ==
	if (true == single) 
	{
	
	}
逻辑运算符
	&& 同真为真，有假【即】假 
	|| 有真【即】真，同假为假
	! 取反
位运算符
	计算:
		& 同 1 为 1，有 0 则 0 
		| 有 1 则 1，同 0 为 0
		~ 1 ==> 0 , 0 ==> 1
		^ 相同为 0，不同为 1
	移动:
		<< 目标数据 * 2 的 N 次方
		>> 目标数据 / 2 的 N 次方

14.CPU区域可以划分为哪些区域，分别有什么特征

• 栈区
  • 主要存储局部变量（函数内定义的变量，函数参数变量，循环分支结构变量）
  • 系统分配，系统管理，系统释放
  • 可读可写不可执行
• 堆区
  • 主要存储一些需要占用内存空间较大的变量数据，也可以认为是程序员自行申请空间用于存储部分变量数据
  • 程序员自行分配，自行管理，自行释放，如果仅申请内存不进行释放，会导致内存泄漏
  • 可读可写不可执行
  • 申请内存方式
    • C 语言
      • 需要使用 stdlib.h 中的函数 malloc realloc calloc 申请空间
      • 释放需要通过 free 函数
    • C++
      • 申请可以采用 C 语言方式，也可以使用 new 关键字
      • 释放操作如果是通过 C 语言方式创建，需要通过 free ，如果是 new 申请，需要使用 delete
• 数据区/常量池/常量区
  • 主要存储常量数据（字符串常量，后续 const static 修饰的数据）
  • 系统分配，系统管理，系统释放
  • 可读部分可写不可以执行
• 函数区/方法区
  • 主要存储可执行的二进制程序内容，重点是函数
  • 系统分配，系统管理，系统释放
  • 可读不可写可执行

15. 内存地址是什么？

	内存地址是操作系统基于内存中最小存储数据单元字节进行的【编号】，从 0 开始到内存空间的最大值，
	以 4GB 为例，内存地址范围是 0 ~ 4 * 1024 * 1024 * 1024，通常内存地址都会采用十六进制方式来处理，4GB 是0x0 ~ 0xFFFF FFFF
	内存编号，每一个字节都是一个编号

14. NULL 是内存中的哪一个字节的地址，有什么特征？

	NULL 是内存中编号为 0 的字节，对应地址为 0x0
	收到系统保护，任何程序不得读取数据，写入数据到 NULL ，如果操作系统直接 “杀死” 程序

	计算机按照最小数据存储单位【字节】，对内存中的每一个字节进行编号，编号唯一，就是【内存地址】，为了方便管理，内存通常采用 16 进制方式展示，以 4G 内存为例，地址范围是 0x0 ~ 0xFFFF FFFF

15. & 和 * 运算符有什么功能

& 取地址运算符
	可以获取变量在内存中的首地址
* 取值运算符
	可以通过当前指针变量存储的数据内容（地址），获取地址对应指向的内存空间中的数据内容。

14. C 语言申请内存的函数有哪些

void * malloc(size_t size);
		 // 根据用户提供的字节数量在内存【堆区】申请内存空间，成功返回申请内存空间的首地址，失败返回 NULL
void * calloc(int num, size_t size);
		// 根据用户要求的元素个数 count 和 每一个元素占用内存字节数 size，在内存【堆区】申请内存空间，成功返回申请内存空间的首地址，失败返回 NULL
		// 特殊功能说明 calloc 具备申请内存空间擦除数据能力
void * realloc(void * ptr, size_t size);
		// 根据用户指定的 malloc calloc realloc 申请空间首地址，和当前目标新空间字节数，调整目标内存空间，如果原地址空间足够使用，返回原地址空间，如果原地址空间后续内存无法满足当前需求，CPU 会分配新的空间，同时拷贝原数据内容，返回的是新地址。如果申请失败，返回 NULL
		// 【使用要求】返回到主函数时必须使用指针变量，存储新空间首地址

15. C 语言释放空间的函数有哪些

free(void * ptr);
		// 可以释放通过 malloc calloc realloc 申请的内容空间，要求提供对应空间首地址，当前函数所需参数为 void * 万能指针，可以提供任意类型的指针地址。
		// 释放之后建议将指针变量赋值为 NULL

16. 一个 int 类型数组，解释一下操作分别对应什么

• 回顾:
  1. 数组名是什么???
  数组名是一个指针常量，存储当前数组在内存中的首地址
  2. 数组名存储的地址
  1. 整个数组的首地址
  2. 同时也是数组中下标为 0 的元素首地址。

• *arr = arr[0];
  *arr 取值操作，根据当前内存地址，以及指针数据类型，获取对应内存数据存储情况
  相当于获取数组中下标为 0 的元素

• *arr + 5 = arr[0] + 5;

• *(arr + 5) = arr[5]
  arr + 5 已当前 arr 地址 + 5 * 对应数据类型空间字节数
  相当于获取数组中下标为 5 的元素首地址
  *(arr + 5) ==> arr[5];

• arr + 5 = &arr[5];
  arr + 5 已当前 arr 地址 + 5 * 对应数据类型空间字节数
  相当于获取数组中下标为 5 的元素首地址

17. 结构体定义

struct 结构体名称
{
	成员变量 【数据类型 变量名】;
	成员变量 【数据类型 变量名】;
	成员变量 【数据类型 变量名】;
}

typedef struct student
{
	int id;
	char name[32];
	int age;
}Student;

18. 结构体变量定义

Student stu;

19. 申请内存堆区空间存储结构体类型数据的方式

Student *stu = (Student *)calloc(1, sizeof(Student));

20. -> 和 . 运算符的区别

-> 结构体指针操作对应结构体中的数据内容
	Student *stu ...
	stu->id
. 结构体变量操作其中的成员变量数据内容
	Student stu
	stu.id

21.数组定义格式

1. 数组类型，数组名[容量] = 初始化数据;
2. 数据类型 * 数组名 = malloc/calloc 申请连续内存空间存储目标数据内容。

22.有头双向链表，链表头结构体和结点结构体代码实现，以及组成内容注释

// 结点类型
typedef struct node 
{
	// 当前结点的上一个节点
	struct node * prev;
	// 当前结点的下一个结点
	struct node * next;
	//void *万能指针，结点中存储的数据内容
	void *data;
}Node;
typedef struct node
{
	// 整个链表中的第一结点
	NOde *first;
	// 整个链表中的最后一个结点
	Node *last；
	// 当前链表中的有效结点/元素个数
	int size;
}LinkedHead;

23.添加数据到数组中指定下标位置，流程概述

1.合法性判断
		判断用户提供的下标数据是否合法
		判断数组数据是否合法
2.从原本最后一个有效元素开始，到用户指定插入数据位置结束，数组中的元素整体向后移动
3.在指定下标位置进行数据添加操作
【注意】如果容量不足，需要进行扩容操作，扩容操作仅针对于通过 malloc caloc realloc申请的动态数组内存空间。

24.添加数据到链表中指定下标位置，流程概述

1.合法性判断
	a.用户指定的下标位置是否合法性，链表中采用的下标也是从 0 开始。
	b,判断链表头和结点数据是否为 NULL
2.判断用户提供的下标情况
	2.1 用户指定下标为 0 【add_first】;
	2.2 用户指定下标为 head->size;【add_last】
	2.3 需要根据用户指定的下标位置进行遍历链表操作，找到目标添加位置的原本结点
		index > head->size / 2 从末尾开始搜索数据 否则从链表头开始
		// new_node->next = targrt;
		new_node->prev = target-<prev;
		new_node->prev->next = new_node;
		target->prev = new_node;
		head->size += 1;

25.案例说明二级指针

26.举例函数指针案例

函数名是一个指针常量
int (*pf)(int,int)
函数指针名称为 pf
	要求
		1.当前函数指针可以存储的函数返回值类型要求为 int 类型
		2，参数类型要求为 (int,int)两个 int 类型
		3.给予函数指针赋值的是函数名
	int add(int n1,int n2);
	pf = add;
	pf(10,20);

27.函数指针作为函数参数的案例

int operation(int n1,int n2,int (*pf)(int,int));
int add(int n1,int n2);
int sub(int n1,int n2);
int mul(int n1,int n2);
int div(int n1,int n2);

// 插件式编程
operation(10,20,add);
operation(10,20,sub);
operation(10,20,mul);
opwration(10,20,div);

28.举例说明结构体嵌套，和动态内存申请之后的操作赋值

typetef struct date
{
	char year[8];
	char month[4];
	char day[4];
}Date;

typetef struct person
{
	int id;
	char name[32];
	Date hiredate;// 入职时间；
}Person;

Person *p = (Person *)malloc(sizeof(Person));
memset(p,0,sizeof(Person));

strcpy(p->hiredate.year,"2024");
strcpy(p->hiredate.month,"1");
strcpy(p->hiredate.day,"11");

29.举例说明有参宏和无参宏

#define COUNT 10
#define ADD（a,b）(a + b)
printf("count : %d\n",COUNT);==> printf("count : %d\n",10);
printf("add : %d\n",ADD(10,20)); ==> printf("add : %d\n",(10 + 20));

30.<> 和 “” 方式引入头文件的区别

<> 直接去系统指定路径搜索目标头文件
“” 在当前目录下搜索目标头文件，如果未找到前往系统指定路径搜索目标头文件

31.字符串常用函数

size_t strlen(char *str);
size_t strlen(char * str);
	int strcmp(char * s1, char * s2);
	int strncmp(char * s1, char * s2, size_t n);
    strcpy(char * s, const char * s2);    
    strncpy(char * s, const char * s2, size_t n);
    char * strstr(char * s, char * s1)    
    char * strnstr(char * s, char * s1, size_t n);
    char * strtok(char * s, char * filter);
    strcat(char * s, char * s2);
    strncat(char * s, char * s2, size_t n);
    char * strchr(const char *str, int c)
    char * strrchr(const char *str, int c)
    
    memset(void * ptr, int ch, size_t n);
    memcmp(void * p1, void * p2);    
    memncmp(void * p1, void * p2, size_t n);
    memcpy(void * dest, void * src);  
    memmove(void * dest, void * src);

C++复习

1.C++ 基本数据类型

1.整型
short 2
int 4（32位机及其以上）
long 8（64位机及其以上）
2.浮点型
float 4
long 8
3.字符型
char 1
4.布尔类型
bool 1 C++补充两个关键字 true （1） false （0）

2.C++和C语言结构体有什么不同

1.C++ 结构体的数据类型名称直接就是 struct 关键字之后的名称
C语言结构体的名称是 struct 加 结构体名
C++ struct Student 数据类型名称为 Student
C语言 struct student 数据类型名称为 struct student
2.C++ 结构体允许定义函数/声明函数，C语言不允许

3.命名空间中可以定义哪些内容，如何引入命名空间

命名空间中可以定义 变量，函数，数据类型，用于限制作用范围，避免名称冲突
例如 ：
	using namespace std;
	使用命名空间 std  ，可以直接在代码中使用 cin cout endl 等相关内容。

4.作用域运算符的作用

格式：
::
可以用于限制函数，变量的归属
命名空间 A 中的变量 n1
A::n1
命名空间 A 中的函数 test();
void A::test(){…}

5.有头单向链表添加元素到最后一个结点的代码实现

typedef struct node 
{
	struct node *next;
	void * data;
}Node;
typedef struct head
{
	Node * first;
	int size;
}LinkedHead;
int add_last(LinkedHead * head,Node * new_node)
{
	if(NULL == head || NULL == new_node)
	{
		printf("提供的链表头或者结点为 NULL\n");
		return EXIT_FAILURE;
	}
	if(0 == head->size)
	{
		// 当前链表中没有有效结点
		head->first = new_node;
	}
	else
	{
		// 当前链表中有其他结点，利用循环，遍历整个链表，找到最后一个元素位置
		// 【标记】next ==> NULL
		Node * temp = head->first;
		while(temp->next != NULL)
		{
			temp = temp->next;
		}
		temp->next = new_node;
	}
	head->size += 1;
	return EXIT_SUCCESS;
}

6.const 关键字修饰变量特征，举例说明

// num 可以认为是带有名称的常量，后续数据无法修改
const int num = 10;
// p 指针存储的地址可以修改，但是指向的数据空间内容无法修改
const int * p = #
// p 指针存储的地址无法修改，但是指向的数据空间内容可以修改
int  * const p = &num1;
// p 存储地址无法修改，同时指向的数据空间内容无法修改
const int * const p = &num1;

7.函数的重载

要求
1.在同一个区域内，可以是命名空间，类，结构体，同一个文件
2.要求函数名一致
3.要求函数的形式参数列表必须不一致
4.返回值类型不作为重载函数的判断条件。

8.C++ 结构体相当于 C语言结构体的优点

1.命名简单，可以直接使用 struct 关键字之后的名称作为结构体数据类型名称
2.C++ 结构允许存在函数，C++ j结构体是类的一个雏形

9.C/C++动态申请内存空间和销毁分别采用的形式

C
void * malloc(size_t size);
void * calloc(int num, size_t size);
void * realloc(void * ptr, size_t size);
free(void * ptr);

C++
new
delete

10.函数默认参数的形式

void test(int n1,int n2 = 10);
main()
{
	test(10);// n1 = 10,n2 = 10;
	test(10,200);// n1 = 10,n2 = 200
}

void test(int n1,int n2)
{
	cout << "n1 = " << n1 << "n2 = " << n2 << endl;
}

11.案例说明引用作为函数参数交换数据

void swap(int & r1,int & r2);
main()
{
	int n1 = 10;
	int n2 = 200;
	swap(n1,n2);
	// n1 = 200,n2 = 10
}
void swap(int & r1,int & r2)
{
	int temp = r1;
	r1 = r2;
	r2 = temp;
}

12.C++ 中权限修饰符有哪些，分别有什么作用

public
修饰的内容类内，类外，子类都可以使用。
proteed
修饰的内容类内，子类可以使用，类外不可以使用。
private
修饰的内容类内可以使用，子类，类外不可以使用。

13.C++ 析构函数的格式和作用

例如类名为 Person
无参构造函数
Person(){…};
有参构造函数
Person(int id,string name,int age){…}
拷贝构造函数
Person(const Person & person);

14.C++ 析构函数的格式和作用

例如类名为 Person
析构函数格式：
~Person(){…}
析构函数实在当前对象被 delete 关键字销毁是默认调用的函数，可以在当前析构函数中对当前对象成员内容使用的内存空间释放函数，或者对使用相关资源进行关闭操作，例如文件，网络，链接。

15.C++ 继承格式，以及各种权限继承的结果

class 派生类：权限修饰符 父类
{
}
public ：
public ==>public
protected ==> protected
private ==> 无法继承
protected:
public ==>protected
protected ==> protected
private ==> 无法继承
private:
public ==> private
protected ==> private
private ⇒ 无法继承

16.重写和重载的区别

重载【relaod】
1.在同一个范围以内，包括同一个文件，同一个命名空间，同一个类或者结构体中
2,要求函数名称必须一致
3.要求函数对应的形式参数列表必须不一致
4.函数返回值数据类型不作为重载判断要求
重写【Override】
1.必须存在继承关系
2.要求父类子类函数声明必须完全一致
3.函数体内容不一致

17.C++引用和指针的区别

引用表示当前变量的别名，可以认为是当前变量本身，再编译阶段不占用内存空间，执行时会存在临时空间
指针是存储一块内存空间首地址

18.const 关键字修饰变量的形式有什么特征

const int num = 10；
num 存储的数据无法修改，可以认为是一个带有名称的常量
const int * p = &num；
p 指针存储的地址可以改变
num 存储的数据无法修改【指向可以变，指向空间不可以变】
int * const p = &num；
p 指针存储的地址不可以改变
num 存储的数据可以修改【指向不可以变，执行空间可以变】
const int * const p = &num；
p 指针存储的地址不可以改变
num 存储的数据不可以修改【指向不可变，指向空间不可以变】

19.条件编译有哪些

#if #else #endif
#ifdef #else #endif
#ifndef #else #endif
#define
#undef

20.构造函数和析构函数的作用

构造函数
1.构造函数的名称是类名，在和 new 关键字配合使用，提供数据类型名称，告知 new 关键字
申请的内存空间字节数。
2.构造函数用于初始化申请空间的内存，无参数构造函数，有参数构造函数，拷贝构造函数
析构函数
1.delete 关键字释放 new 申请内存空间，如果对应的数据为一个类，自动触发析构函数执行。
2.析构函数中可以将当前对象成员申请的内存或者打开的资源进行关闭操作。
3.析构函数 ~类名(){…}

21.一个函数所需参数为父类类型，可以传入的实际参数有哪些

函数所需参数为父类类型，可以提供给函数的实际参数可以是父类本身或者其子类【多态】

22.纯虚函数有什么要求，纯虚函数所在类是什么类

要求:
1.纯虚函数 有且只有声明
2，要求必须使用 = 0 结尾
virtual void test() = 0;
所在类为抽象类，无法进行实例化操作。

23.模板函数的定义格式和对应具体数据类型的约束方式

定义模板函数
template <typename T>
void test(T t){…}
当前模板函数中模板对应的具体数据类型需要通过实际参数来约束
test(10); ==> void test<int>(int t);
test("10"); ==> void test<string>(string t);
test(‘A’); ==> void test<char>(char t);

24.模板类定义和模板类型具体数据的约束方式

定义模板类
template

25.一个类继承模板类，模板对应的具体数据类型有哪些约束方式

1.自由模式
template <typename T>
class Handler{…};
…
template <typename T>
calss Myhandler : public Handler<T>{...}
MyHandler 中模板类型尚未明确并且和父类中的一致。需要在实例化对象过程中约束模板对应具体数据类型
2.妻管严模式/严格模式
template <typename T>
class Handler{…}
…
class IntHandler : public Handler<int>{...}
IntHandler 类中没有模板，继承父类中模板已经明确为 int 类型，对应的函数，变量使用到模板数据类型的位置都是 int 类型

26.举例说明友元函数和友元类

class Men; // 前置声明
class Person
{
public:
friend void showPerson(Person & p);
friend class Men;
private:
int id;
string name;
int age;
}
class Men
{
// 可以在 Men 类内操作 Person 私有化数据
}
void showPerson(Person & p)
{
cout << "ID: " << p.id
<< ",Name : " << p.name
<< ",Age : " << p.age << endl;
}