【C语言备课课件】(下)指针pointer

目录

  • 定义type *var_name;
  • 初始化int *p = &a; // p指向变量a的地址
    • 空指针NULL,野指针,指针悬挂
  • 解引用
  • 指针的算术运算
  • 指针与数组
    • 数组名—首指针
    • 二维数组指针
      • 行指针
      • 列指针
    • 多级指针(进阶)
    • 数组指针,指针数组(进阶)
    • 指针实现动态数组(进阶)
  • 指针与函数
    • 传递指针给函数
    • 传递数组给函数
    • 冒泡排序
    • 函数返回值为指针(进阶)
    • 函数指针和回调函数(进阶)
      • 函数签名(进阶)
  • 指针与常量
    • 常量指针和指针常量
  • 指针和结构体
    • 结构体指针
    • typedef简化结构体指针定义
    • 结构体指针和函数
    • 结构体内嵌指针(进阶)
    • 结构体内嵌结构体指针(进阶)
      • 内嵌其他结构体(进阶)
      • 内嵌自身(进阶)
    • 结构体内嵌函数指针(进阶)
  • 指针与字符和字符串
    • 字符指针
    • 字符数组(字符串)
    • 字符指针数组
    • 字符指针与字符串函数
    • 动态分配字符串(进阶)
  • 指针与文件I/O(进阶)
    ---------------------------------((进阶))---------------------------------------------
  • 指针与动态内存分配(进阶)
    • 程序四大区(进阶)
    • void*的特性(进阶)
    • mallocfree``(进阶)
  • C语言编译冷知识(进阶)
    • 预处理(进阶)
    • 编译(进阶)
    • 汇编(进阶)
    • 链接。(进阶)
    • 编译器(进阶)
  • Cmake和CmakeList和Makefile(进阶)
    -------------------------------学无止境,越学越远-------------------------------------

1 引入

1-1 内存地址基础概念

请添加图片描述

  • 计算机内存地址是计算机内存中的每一个字节都有一个唯一的编号。在程序中,每个变量都存储在内存的某个地址上。计算机通过内存地址来访问和管理内存中的数据。
  • 内存地址通常以十六进制表示,例如0x1000请添加图片描述
1-1-1 说人话环节
  • 在计算机中,内存地址就像是一个大型仓库中的货架编号,每个货架都有一个唯一的编号。而指针就像是一张卡片,这张卡片上写着某个货架的编号,这样我们就可以通过这张卡片找到存放物品的具体位置。通过使用指针,我们可以轻松地在内存中导航,访问和修改数据。
  • 指针(卡片)->内存地址(货架编号),内存地址(货架编号)对应的数据(货物)

1-2 指针的定义
  • 指针是一个变量,它存储了另一个变量的内存地址。
  • 在C语言中,使用*符号来定义指针。
typename*    pointer;
  • 下面代码我创建了一个类型为int* 的指针,并给他取名为p。这时候我们创建了一个新的卡片。用货架举例子就是我创建了一个新的卡片。
int *    p;

1-3 指针的初始化
  • 这时候,卡片还没有设置对应的货架编号,通过这个空的卡片(空指针),还无法找到货架编号(内存地址),更无法找到对应的货物(数据)
  • 可以通过&运算符获取变量的地址来初始化指针。
int a = 10;
int *p = &a;
  • 变量名 a 是一个标识符,它代表了内存中的某个地址。当你给 a 初始化时,例如 a = 10;,你实际上是在将值 10 存储在 a 所代表的内存地址中。
    • 如果你不初始化a的时候,a对应的数据就是不确定的
  • &运算符:取地址运算符:当你对一个变量使用&运算符时,它会返回该变量的内存地址。例如,如果你有一个整型变量int a = 10;,那么&a将返回变量a的内存地址。
    • 回顾一下我们之前玩过无数次的scanf
    int a;
    scanf("%d", &a); // 使用&运算符来传递变量a的地址
    
  • 说人话:用货架的例子就是,我现在有一个货物a,它的货架编号是&a,我创建了一张新的卡片p在上面写上a的货架编号,这样我就可以通过卡片访问到a了
  • 同理我们创建多张卡片指向同一个内存地址
int b = 10; // 创建另一个货物b,并给它一个初始值10
int *p1;    // 创建一张新的卡片p1
int *p2;    // 创建另一张新的卡片p2

p1 = &b;    // 在卡片p1上写下货物b的货架编号
p2 = &b;    // 在卡片p2上也写下货物b的货架编号


1-3-1 NULL指针
  • 正如我们创建了一个新的卡片,如果你没有在卡片上写上新的地址信息以初始化,这个指针就是个空指针
  • C语言提供了NULL指针的概念。NULL是一个宏,它在标准库中定义,通常在<stddef.h>头文件中声明。NULL的值通常被定义为0,或者在某些平台上是一个特殊的地址,这个地址被设计为不可能是一个有效的内存地址。
int *ptr = NULL; // 将ptr初始化为NULL

if (ptr != NULL) {
    // 使用ptr
} else {
    // ptr是NULL,不能使用
}
  • 如果你尝试访问一个空指针,程序可能会崩溃,因为它试图访问一个无效的内存地址。这是因为内存中的每个地址都有可能被操作系统或程序使用,访问一个未分配或未初始化的地址可能会导致程序出错或系统不稳定。请添加图片描述

  • 说人话:有个只有酒店门牌号只有300-400,而你却收到了一张404的房卡请添加图片描述


1-4 指针的解引用
  • 解引用操作使用*符号,用于获取指针指向的变量的值。
int a = 10;
int *p = &a;

int b = *p;
  • 解引用操作符*用于获取指针所指向的变量的值。
  • 说人话就是拿着卡片p,找到对应的货物a,拿出a的值(货物),给b
  • 需要特别注意区分:
    • int* aint* 是一个类型。
    • int b = *p;* 是取地址符号
  • 我们来看一个移情别恋(不是)的例子:
int a=10;
int* p=&a;
int b=20;
int* p=&b;

printf("p的值是:%d",*p);
  • 弹幕里回复一下p的值请添加图片描述








  • 答案是20

2 指针与数组

  • 上述说了这么多,是不是感觉很迷惑,为什么要引入指针?
2-1 数组首指针
  • 在C语言中,数组名本身就是一个指向数组第一个元素的指针。这意味着你可以使用数组名作为指针,并在需要时对数组进行操作,例如排序。
  • 下述例子,array就是数组第一个元素的地址。下述操作将输出数组的第一个元素
int array[]={1,2,3};
printf("%d",*array);
2-1-1 arrarr[0]
  • arr 存储的是数组的起始地址,而 arr[0] 存储的是第一个元素的值。
int array[] = { 1,2,3 };
//%zu 是 size_t (unsigned int)的标准格式化字符串
printf("sizeof(array):%zu\n", sizeof(array));
printf(" sizeof(array[0]):%zu\n", sizeof(array[0]));
  • sizeof(arr) 返回整个数组的大小(字节数)。这包括数组中所有元素的总大小。
  • sizeof(arr[0]) 返回数组中单个元素的大小(字节数)。对于 int 类型的数组,这通常是 4 字节(在大多数现代架构上)。
2-1-2 指针的算术运算
  • 指针可以进行算术运算,如增减。
  • 指针的自增(++)和自减(--)运算符会改变指针的值,使其指向数组的下一个或上一个元素。

int array[] = {1, 2, 3};
int *ptr = array; // 指针指向数组的第一个元素

printf("%d\n", *ptr); // 输出第一个元素

ptr++; // 指针指向下一个元素
printf("%d\n", *ptr); // 输出第二个元素

ptr++; // 指针指向下一个元素
printf("%d\n", *ptr); // 输出第三个元素
  • 当你对指针进行加法或减法运算时,编译器会根据指针指向的数据类型自动调整偏移量。例如,如果p是一个指向int类型的指针,那么p + 1实际上是将p的地址值增加了sizeof(int)字节。
2-1-3 两种形式
  1. 前缀形式 (++ptr--ptr)
    • 当你使用前缀形式时,指针的值首先增加或减少,然后表达式返回新的指针值。
    • 例如,++ptr 将指针ptr向前移动一个int类型的大小(假设ptr是一个指向int类型的指针),然后返回移动后的指针。
  2. 后缀形式 (ptr++ptr--)
    • 当你使用后缀形式时,表达式首先返回指针的当前值,然后指针的值增加或减少。
    • 例如,ptr++ 首先返回ptr的当前值,然后ptr向前移动一个int类型的大小。

int array[] = {1, 2, 3};
int *ptr = array;
// 前缀形式
printf("Prefix: %d\n", *++ptr); // 输出2,因为ptr先自增,再解引用
// 后缀形式
printf("Postfix: %d\n", *ptr++); // 输出2,因为ptr先解引用,再自增
// 现在ptr指向了数组的第三个元素
printf("Current value: %d\n", *ptr); // 输出3
2-1-4 使用指针遍历数组
  • 我们可以使用++和–遍历数组

int arr[] = {1, 2, 3, 4, 5};
int n = sizeof(arr) / sizeof(arr[0]);
int *ptr = arr; 

for (int i = 0; i < n; i++) 
{
	printf("%d ", *ptr); 
	ptr++; 
}

2-2 二维数组指针—行指针和列指针
  • 在C语言中,二维数组可以通过行指针和列指针来访问。
    • 行指针是指向二维数组中一行的指针
    • 列指针是指向二维数组中一列的指针
      请添加图片描述
2-2-1 行指针:多级指针
  • 行指针是一个指向包含多个元素的一维数组的指针。
  • 当我们声明一个二维数组时,例如 int arr[3][3];arr 本身就是一个行指针,它指向二维数组的第一行。第一级指针通常指向数组的行,而第二级指针则指向每行的第一个元素。
int arr[3][3]={
	{1,2,3},
	{4,5,6},
	{7,8,9},
}
int (*row_ptr)[3] = arr;
for (int i = 0; i < 3; i++) 
{
	for (int j = 0; j < 3; j++) {
		printf("%d ", row_ptr[i][j]);
		//printf("%d ", *(*(row_ptr + i) + j));
	}
	printf("\n");
}
  • 通过使用 row_ptr,我们可以访问二维数组中的任意元素。例如,*(*(row_ptr + i) + j) 就可以访问 arr 数组的第 i 行第 j 列的元素。
2-2-2 列指针
  • 列指针是一个指向二维数组中单个元素的指针。
  • 在C语言中,你可以通过使用运算符 & 来获取一个元素的地址,从而创建一个列指针。例如,如果你想要创建一个指向 arr[1][2] 的列指针,你可以这样做:
int *col_ptr = &arr[1][2];
  • 我们可以这样进行遍历,col_ptr 就是一个列指针,它指向 arr 数组的第1列的第1行元素。你可以通过递增 col_ptr 来访问该列的其他元素。例如,col_ptr + 1 将指向 arr 数组的第2列的第1行元素,以此类推。
int arr[3][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };

// 列指针
int *col_ptr = &arr[0][1];

// 通过列指针访问元素
for (int i = 0; i < 3; i++) 
{
	printf("%d ", *(col_ptr + i));
}
printf("\n");

2-3 多级指针(进阶)
  • 多级指针是C语言中的一个概念,它指的是指针的指针,即一个指针变量存储了另一个指针变量的地址。
  • 在C语言中,你可以创建任意深度的多级指针,这在处理复杂的数据结构时非常有用,例如动态二维数组、链表等。
int var = 5; // 声明一个整型变量
int *ptr1;   // 声明一个指向整型的指针
int **ptr2;  // 声明一个指向整型指针的指针,即多级指针

// 初始化变量和指针
var = 5;
ptr1 = &var;    // ptr1 指向 var
ptr2 = &ptr1;   // ptr2 指向 ptr1

// 通过多级指针访问变量
printf("Value of var through ptr2: %d\n", **ptr2);
  • 还是说人话:卡牌p上记录了pp卡牌的位置,卡牌pp上记录了货物a的位置。通过卡牌p可以找开票pp的位置,通过pp可以找到a的位置。哎,就是套娃请添加图片描述
2-3-1 多级指针的用途
  • 动态内存分配(后面我们讲到malloc再说)
  • 数据结构,结构体和内嵌指针(后面我们讲到结构体再说)
// 定义二叉树节点结构体
typedef struct TreeNode {
    int data;
    struct TreeNode* left;
    struct TreeNode* right;
} TreeNode;
  • 函数返回多个值(后面我们讲到malloc,函数和结构体再说)
typedef struct {
    int value1;
    int value2;
} ReturnValue;

ReturnValue* getTwoValues() {
    ReturnValue* result = (ReturnValue*)malloc(sizeof(ReturnValue));
    if (result == NULL) {
        exit(1); 
    }
    result->value1 = 10;
    result->value2 = 20;
    return result;
}
ReturnValue* values = getTwoValues(); // 使用多级指针返回多个值

printf("Value 1: %d\n", values->value1);
printf("Value 2: %d\n", values->value2);

2-4 指针数组和数组指针(进阶)
  • 在 C 语言中,指针数组和数组指针是两个不同的概念。
2-4-1 指针数组:是数组
  • *定义:指针数组是一个数组,其元素是指针。
  • 说人话:一系列的卡牌,每张卡牌都指向一个不同的货架
  • *语法类型名 *数组名[数组大小];
int *ptrArray[10];  // 这是一个指针数组,包含 10 个指向 int 的指针
  • ptrArray 是一个数组,它有 10 个元素,每个元素都是 int* 类型的指针。
  • 你可以为这个数组的每个元素分配内存,并使它们指向不同的 int 变量。
  • 这种类型的数组常用于存储指向不同数据的指针,例如,可以存储多个字符串的地址。
int a = 10, b = 20, c = 30;
int* p1=&a;
int* p2 = &b;
int* p3 = &c;

int* ptrArray[3];

// 初始化指针数组
ptrArray[0] = p1;
ptrArray[1] = p2;
ptrArray[2] = p3;

int n = sizeof(ptrArray) / sizeof(int*);

for (int i = 0; i < n; i++) {
	printf("ptrArray[%d] = %p\n", i, ptrArray[i]);
	printf("ptrArray[%d] = %d\n", i, *ptrArray[i]);
}

请添加图片描述

2-4-2 数组指针:是指针
  • *定义:数组指针是一个指针,它指向一个数组。
  • 说人话:这张特殊的卡牌,通过它我们可以访问一个特殊的货架,这个货架里放着一系列的卡牌。
  • *语法类型名(*)[数组大小];
int (*arrayPtr)[10];  // 这是一个指向包含 10 个 int 的数组的指针
  • arrayPtr 是一个指针,它指向一个包含 10 个 int 的数组。
  • 你可以为这个指针分配内存,并使它指向一个实际的数组。
  • 这种类型的指针常用于函数参数,当你需要传递一个数组的地址时,但又不希望改变数组的大小。
int array[]={1,2,3};

// 声明一个数组指针,指向上面声明的数组
int (*arrayPtr)[3] = &array;
int n= sizeof(array) / sizeof(array[0]);
// 输出数组指针指向的数组的内容
for (int i = 0; i < n; i++) {
	printf("arrayPtr[%d] = %d\n", i, (*arrayPtr)[i]);
}
2-4-3 数组指针和多级指针
  • 数组指针是指向数组的指针。当你声明一个数组指针时,你实际上是在声明一个指针,这个指针指向整个数组
int arr[10]; // 声明一个包含10个整数的数组
int (*arrayPtr)[10]; // 声明一个数组指针,指向包含10个整数的数组
arrayPtr = &arr; // 将数组arr的地址赋给数组指针
  • 多级指针是指向指针的指针。当你声明一个多级指针时,你实际上是在声明一个指针,这个指针指向另一个指针。\
int *ptr; // 声明一个指向整数的指针
int **ptrPtr; // 声明一个指向指针的指针,即多级指针
ptrPtr = &ptr; // 将ptr的地址赋给多级指针
2-4-3 用途
  • 指针数组用于存储多个指针,通常用于处理字符串数组或其他需要存储多个指针的情况。(字符串我们后续讲)
  • 数组指针用于指向一个数组,常用于传递数组给函数,而无需关心数组的具体大小。

2-5 指针实现动态数组(进阶)
  • (后面我们讲到malloc再说)

3指针与函数

3-1 传递指针给函数
  • 我们来回顾一下函数的基本知识:
int func(int a)
{
	a=10;
	return a;
}
int main()
{
	int a=20;
	printf("func(a):%d\n",func(a));
	printf("a:%d\n",a);
}
  • 弹幕里头回答一下这两题的答案:请添加图片描述






  • 答案是
    • func(a):10
    • a:20
  • 这是由于函数在进行传参时候,其实是进行了一次值拷贝,讲外面的a拷贝给了函数内的形参。
  • 那么这时候如果我希望直接修改a的值而不进行return赋值给a,我们可以使用指针进行传参。
void func(int* a)
{
	*a=10;
}
int main()
{
	int a=20;
	fun(&a);
	printf("a:%d\n",a);
}
  • 在这个修改后的例子中,当我们将a的地址(即&a)传递给func函数时,func函数接收到的实际上是一个指向a的指针。在func函数内部,我们通过解引用这个指针(使用*操作符)来直接访问并修改a的值。因此,当func函数执行完毕后,a的值将被修改为10。
  • 需要注意的是函数的参数是int*类型,因此传入参数的时候需要注意传入int*的内容,因此需要取a的地址,保证类型一致。
3-1-1 swap
  • 我们来看一个最经典的例子,my_swap(int*a,int*b)函数是一个经典的函数,用于交换a和b的值
#include <stdio.h>

// 交换两个整数的值
void my_swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main() {
    int x = 10;
    int y = 20;

    printf("Before swap: x = %d, y = %d\n", x, y);
    my_swap(&x, &y);
    printf("After swap: x = %d, y = %d\n", x, y);

    return 0;
}
  • 我们使用mermaid过一下上述的流程
a:10
b:20
temp
  • int temp = *a;
a:10
b:20
temp:10
  • *a = *b;
a:20
b:20
temp:10
  • *b = temp;
a:20
b:10
temp:10

3-2 传递数组给函数
  • 在C语言中,你可以将数组作为参数传递给函数。当你传递一个数组给函数时,实际上传递的是数组的指针。这是因为数组名在表达式中被视为指向数组第一个元素的指针。
#include <stdio.h>

void printArray(int* arr, int size) {
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

int main() {
    int myArray[] = {1, 2, 3, 4, 5}; // 定义并初始化一个数组
    int size = sizeof(myArray) / sizeof(myArray[0]); // 计算数组的大小

    printArray(myArray, size); // 调用函数,传递数组及其大小

    return 0;
}

3-2-1 函数传递到数组中无法计算数组大小问题
  • 可能由同学看到上面的例子可能有疑问,为什么还需要额外传递数组的大小进入函数,为什么我们不能在函数内部动态计算数组的大小呢?
    • 计算数组大小sizeof(myArray) / sizeof(myArray[0]);
  • 实践出真知
void printArray(int* arr, int size)
{
   printf("sizeof(myArray) / sizeof(myArray[0]):%zu\n", sizeof(arr) / sizeof(arr[0]));//输出2
   printf("size:%d\n", size);//输出5
}
  • sizeof(arr) / sizeof(arr[0])输出是指针的大小
  • 这是因为当你传递数组到函数时,你实际上传递的是数组的指针,而不是整个数组。

3-3 冒泡排序
  • 说了这么多数组和函数指针的例子,我们来看看实际的运用需求

  • 假如我们有个数组,数组内由杂乱无章的随机数据,我希望写一个函数,讲数组传入,把数组内元素按照从小到大的顺序进行排序。

  • 这里我们简单介绍一下最简答的一个排序算法----冒泡排序

  • 冒泡排序是一种简单的排序算法,它重复地遍历要排序的数列,一次比较两个元素,如果它们的顺序错误就把它们交换过来。遍历数列的工作是重复进行的,直到没有再需要交换的元素为止。

  • 假设我们由这样一个数组如下:请添加图片描述

  • 首先检查他们是否是按照从小到大的顺序:请添加图片描述

  • 如果是,交换他们的次序:请添加图片描述

  • 然后继续遍历下一次的两个数据请添加图片描述

  • 如果是,继续交换次序请添加图片描述

  • 上述过程一次类推,当一行的数据都完成排序后再次回到开头再次进行两两排序

  • 代码实现如下:

#include <stdio.h>


void bubbleSort(int* arr, int size);

int main() {
    int arr[] = { 64, 34, 25, 12, 22, 11, 90 };
    int n = sizeof(arr) / sizeof(arr[0]);
    printf("Before pass : ");
    for (int k = 0; k < n; k++) {
        printf("%d ", arr[k]);
    }
    printf("\n");
    bubbleSort(arr, n);
    printf("Sorted array: \n");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    return 0;
}

void bubbleSort(int* arr, int size) {
    int i, j, temp;
    for (i = 0; i < size - 1; i++) {

       
        for (j = 0; j < size - i - 1; j++) 
        {
            if (arr[j] > arr[j + 1]) 
            {
                // 交换 arr[j] 和 arr[j+1]
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
            printf("After pass %d: ", i + 1);
            for (int k = 0; k < size; k++) {
                printf("%d ", arr[k]);
            }
            printf("\n");
        }
        
    }
}

  • 这里我写了每一次交换的输出请添加图片描述

3-3 函数返回值为指针(进阶)
  • 函数返回值为指针意味着该函数的返回类型是指针类型。
int* func();
double func1();
3-3-1 局部变量指针返回报错,悬垂指针(dangling pointer)
  • 需要特别注意的是如果返回的指针指向的是局部变量,那么在函数返回后,局部变量会被销毁,这会导致指针指向无效的内存地址。
  • 我们来看一个例子
int* func()
{
	int a=10;
	int* p=&a;
	return p;
}
  • 上述代码毫无疑问会报错!!!
3-3-2 正确的使用:返回堆区开辟的指针
  • 正确的应该这样做,应当返回指向动态分配内存(堆区)的指针。动态分配的内存将持续存在,直到被显式释放。使用malloccalloc函数可以在堆上分配内存,并返回指向该内存的指针。
int * func()
{
	int*p =(int*)malloc(sizeof(int));
	*p = 10;
	return p;
}

3-4 函数指针和回调函数(进阶)
3-4-1 函数签名
  • 在讲函数指针之前我们需要明确一个概念
  • 函数签名(Function Signature)是编程语言中用于描述函数接口的一个术语,它包括函数的名称、参数类型和数量、以及返回类型。函数签名不包含函数体,即函数的实现细节。
返回类型 函数名(参数类型1, 参数类型2, ...);
  • 例子一个add函数
int add(int a,int b);
  • 函数签名是 int(int, int),接受两个 int 类型的参数,并返回一个 int 类型的值。

3-4-2 函数指针
  • 在C语言中,函数名确实代表了函数的地址。
  • 函数指针是指向函数的指针变量。函数指针可以用来保存函数的地址,并可以在需要时调用该函数。
  • 函数指针的定义方式与普通指针类似,但需要指定函数的返回类型和参数列表,也就是函数签名
  • 我们为上述add函数(函数签名为int(int,int)),设计一个指针指向add
int (*funcPtr)(int, int);
fp = add;
  • 然后我们可以正常调用add函数
fp(10,20);

3-4-3 回调函数
  • 回调函数(Callback Function)是一种常见的编程模式,它允许我们将函数作为参数传递给其他函数,以便在特定事件发生时被调用。
  • 我们来看下述例子:
#include <stdio.h>

// 定义一个回调函数类型
typedef void (*Callback)(int);

void processValue(int value, Callback callback)
{
    if (value > 10) {
        callback(value);
    }
}


void printValue(int value) 
{
    printf("The value is: %d\n", value);
}

int main() {
    int value = 15;

    // 调用 processValue 函数,并传递 printValue 作为回调函数
    processValue(value, printValue);

    return 0;
}
  • processValue 函数接受一个整数和一个回调函数。如果传入的整数大于10,它就会调用这个回调函数。printValue 是一个简单的回调函数,它打印传入的值。

3-4-4 函数指针和回调函数历程----四则运算计算器
  • 那么函数指针和回调函数有上面用处呢,提供一个统一的可替换的用户接口。
  • 举个例子我们来看一个两位数的四则运算函数,我们可以对函数指针进行封装。
    • 如下两位数的四则运算函数的签名都是int(int,int),我们就可以设计一个统一的函数指针接口int (*funcPtr)(int, int);
    • 这样用户在调用的时候就无需关注实现细节,直接替换实现即可
#include <stdio.h>

typedef int (*Operation)(int, int);

int add(int a, int b) {
    return a + b;
}
int sub(int a, int b) 
{
    return a - b;
}
int mul(int a, int b)
{
    return a * b;
}
int div(int a, int b) 
{
    if (b != 0) {
        return a / b;
    } else {
        printf("Division by zero!\n");
        return 0;
    }
}
int calculate(int a, int b, Operation op) 
{
    return op(a, b);
}
int main() 
{
    int a = 10;
    int b = 5;
    printf("Addition: %d\n", calculate(a, b, add));
    printf("Subtraction: %d\n", calculate(a, b, sub));
    printf("Multiplication: %d\n", calculate(a, b, mul));
    printf("Division: %d\n", calculate(a, b, div));

    return 0;
}
  • 学习过面向对象的同学可以就不陌生了,这是一种非常好的面向对象思想
    • Operation 类型定义了一个接口,它描述了所有四则运算函数的共同特征:
      • 它们都接受两个 int 类型的参数并返回一个 int 类型的结果
      • int (*Operation)(int, int);
      • typedef int (*Operation)(int, int);是使用typedef简化定义。
    • 然后,每种运算实现了这个接口。通过 calculate 函数,可以传入任何符合 Operation 接口的函数,这样 calculate 函数就可以执行不同的运算,而不需要知道具体的实现细节。

4 指针与常量

4-1 常量const
  • 在我们看常量指针和指针常量之前,咱们先回顾常量是啥
  • 在C语言中,常量是一个在程序执行期间其值保持不变的量。
  • 常量可以分为不同的类型,包括
    • 字面常量(如数字、字符串)
      • 整数字面量:如 420xFF
        • 你无法10=1;
      • 浮点数字面量:如 3.142.718f
      • 字符字面量:如 'A''\n'
      • 字符串字面量:如 "Hello, World!"
    • 枚举常量Enum,
      • 枚举是一种用户定义的数据类型,它包含一组命名的整数常量。例如:
        enum Color {RED, GREEN, BLUE};
        
    // 这里RED, GREEN, BLUE是枚举常量,默认情况下它们的值分别是0, 1, 2。
    ```
    • 宏定义常量#define,这里PI是一个宏定义常量,在预处理阶段会被替换为3.14159。
      #define PI 3.14159
      
    • 通过const关键字声明的常量。
  • const关键字用于声明一个变量为常量,这意味着在程序执行期间,该变量的值不能被修改。一般我们命名为大写变量
const int MAX_SIZE = 100;
  • 在程序运行的全阶段,你无法修改MAX_SIZE的值!!!修改了会报错。
4-2 常量指针和指针常量
4-2-1 常量指针(Pointer to Constant):只读不可以修改
  • 常量指针是指向常量的指针。这意味着,指针指向的内存地址中的值是常量,不能通过指针修改该值。声明一个常量指针的语法如下:
const type *ptr;
  • 熟悉的说人话环节:还是货架的例子,你不能通过卡牌上的编号修改对应位置的货物!!!(给你的卡牌(指针)权限是只读不允许修改)
  • 举例子:
int var = 10;
const int *ptr = &var;
*ptr = 20; // 错误,不能通过ptr修改var的值
//可以正常访问
printf("The value of var is: %d\n", *ptr);
4-2-2 指针常量(Constant Pointer):不能移情别恋,纯爱(不是)
  • 这就是纯爱(迫真)请添加图片描述

  • 指针常量是指针本身是常量。这意味着,指针的地址是常量,不能改变指针所指向的地址。

type * const ptr;
  • 一旦 ptr 被初始化指向某个 int 变量,就不能改变 ptr 指向的地址。例如:
    • 但是你还可以修改其中的数值*ptr = 15;
int var = 10;
int * const ptr = &var;
ptr = &var2; // 错误,不能改变ptr指向的地址
//但是可以修改其中的数值
*ptr = 15;
4-2-3 同时是常量指针和指针常量
  • 那么十分同时可以是纯爱(不是)且只读(保护数据)呢,当然有!!!!
  • 你还可以创建一个同时是常量指针和指针常量的变量,这意味着指针指向的值和指针本身都是常量。声明这种类型的语法如下:
const type * const ptr;
  • 这样不能通过指针修改指向的值,也不能改变指针指向的地址。



5 指针和结构体

5-1 结构体指针
5-1-1 定义
  • 和正常的类型一样,结构体指针我们这样定义:
struct Student {
    char name[50];
    int age;
    float score;
};

struct Student stu1 = {"张三", 20, 90.5};
struct Student *ptr = &stu1;
5-1-1 正常访问
  • 如下,先解引用,然后当成正常的结构体进行访问
(*ptr).member
5-1-2 ->访问(推荐)
  • 值得注意的是,结构体指针访问数据的时候除了和正常一样使用解引用,还可以使用->进行数据访问
ptr->member
  • 箭头操作符 -> 的优先级高于解引用操作符 *,这意味着 ptr->member 等同于 (*ptr).member。但是,使用箭头操作符更加直观和简洁,特别是在处理结构体指针时。
  • 说人话:这东西更方便!!!而且更好记忆。
  • 例子:
#include <stdio.h>

struct Student {
    char name[50];
    int age;
    float score;
};

int main() {
    struct Student stu1 = {"张三", 20, 90.5};

    struct Student *ptr = &stu1;

    // 使用箭头操作符访问结构体成员
    printf("姓名:%s\n", ptr->name);
    printf("年龄:%d\n", ptr->age);
    printf("分数:%f\n", ptr->score);

    return 0;
}


5-2 typedef简化结构体指针定义
  • 在C语言中,使用 typedef 关键字可以为结构体定义一个新的名称,这样就可以简化结构体指针的定义。通过 typedef,你可以创建一个结构体类型的别名,使得在声明结构体变量或指针时更加简洁。
#include <stdio.h>

// 定义一个结构体类型
typedef struct {
    char name[50];
    int age;
    float score;
} Student;

int main() {
    // 定义一个结构体变量
    Student stu1 = {"张三", 20, 90.5};

    // 定义一个指向结构体变量的指针
    Student *ptr = &stu1;

    // 使用箭头操作符访问结构体成员
    printf("姓名:%s\n", ptr->name);
    printf("年龄:%d\n", ptr->age);
    printf("分数:%f\n", ptr->score);

    return 0;
}


5-3 结构体指针和函数
  • 我们可以吧结构体指针传入函数以修改结构体内的数据
#include <stdio.h>


typedef struct {
    int x;
    int y;
} Point;


void modifyPoint(Point *p, int newX, int newY) {
    p->x = newX;
    p->y = newY;
}
int main() 
{
    Point point = {1, 2};
    modifyPoint(&point, 10, 20);
    printf("x: %d, y: %d\n", point.x, point.y);
    return 0;
}

5-4 结构体内嵌指针(进阶)
  • 在C语言中,结构体可以包含指针类型的成员。这种结构体称为内嵌指针的结构体。内嵌指针可以指向任何类型的数据,包括基本数据类型、数组、函数或其他结构体。
typedef struct {
    int *ptr;
} PointerStruct;
  • 我们可以正常使用
int value = 10; 
PointerStruct ptrStruct; 
ptrStruct.ptr = &value; 
printf("值:%d\n", *ptrStruct.ptr);
5-4-1 结构体内嵌指针与二级指针
  • 那么如果结构体本身使用指针进行访问呢,哎,就是套娃,那就是二级指针
typedef struct {
    int *ptr;
} PointerStruct;
PointerStruct* ptrStruct; 
*(ptrStruct->ptr)=10;
printf("值:%d\n", *(ptrStruct->ptr));

5-5 结构体内嵌结构体指针(进阶)
5-5-1 内嵌其他结构体(进阶)
  • 结构体内嵌结构体指针是一种高级的数据结构设计技术,它允许你创建复杂的数据结构,如链表、树、图等。
  • 通过在结构体中嵌入其他结构体的指针,你可以实现多层次的数据嵌套,从而创建出灵活且功能强大的数据结构。
  • 例如我们举个游戏的例子:请添加图片描述
typedef struct 
{
    int attackPower; // 武器的攻击力 
    char name[50]; // 武器的名称
} Weapon;
// 定义一个盔甲结构体
typedef struct {
    int defensePower; // 盔甲的防御力
    int durability;  // 盔甲的耐久度
    char name[50];   // 盔甲的名称
} Armor;


// 定义一个库存结构体
typedef struct {
    Weapon* weapons[10]; // 玩家持有的武器数组
    Armor* armors[10];  // 玩家持有的盔甲数组
    int weaponCount;    // 武器数量
    int armorCount;     // 盔甲数量
} Inventory;

// 定义一个玩家结构体
typedef struct {
    Inventory* inventory; // 玩家的库存
    char playerName[50]; // 玩家的名称
} Player;
  • 通过结构体内嵌其他结构体,我们可以很好的封装一个对象(又是面向对象内容)
int main() {
    // 创建一个武器实例
    Weapon sword = {100, "剑"};

    // 创建一个盔甲实例
    Armor plateArmor = {50, 100, "板甲"};

    // 创建一个库存实例
    Inventory inventory;
    inventory.weapons[0] = &sword;
    inventory.armors[0] = &plateArmor;
    inventory.weaponCount = 1;
    inventory.armorCount = 1;

    // 创建一个玩家实例
    Player player;
    strcpy(player.playerName, "玩家1");
    player.inventory = &inventory;

    // 使用玩家持有的武器
    printf("%s 使用了 %s,攻击力为:%d\n", player.playerName, player.inventory->weapons[0]->name, player.inventory->weapons[0]->attackPower);

    // 穿戴玩家持有的盔甲
    printf("%s 穿戴了 %s,防御力为:%d\n", player.playerName, player.inventory->armors[0]->name, player.inventory->armors[0]->defensePower);

    return 0;
}
5-5-2 结构体内嵌自身(进阶)
  • 结构体内嵌自身是指一个结构体中包含一个指向相同类型的指针。这种设计通常用于实现链表、树等数据结构。
5-5-2-1 链表

请添加图片描述

  • 链表是一种常见的数据结构,它由一系列节点(Node)组成,每个节点包含数据和指向下一个节点的指针。链表可以用于实现栈、队列、哈希表等高级数据结构。链表的主要特点包括:
    1. 动态大小:链表的大小不是固定的,可以在运行时动态地增加或减少节点。
    2. 插入和删除操作效率高:在链表中插入或删除节点通常只需要常数时间(O(1)),而不需要移动其他元素,这在数组中通常需要O(n)的时间。
    3. 非连续存储:链表中的节点可以存储在内存中的任何位置,节点之间的顺序由指针确定,而不是物理位置。
5-5-2-2 链表实现
  • Node 结构体定义了一个链表节点,其中 next 成员是一个指向另一个 Node 结构体的指针。
typedef struct {
    int data;
    struct Node *next; 
} Node;
  • 这里不多介绍了,感兴趣的同学了解了解即可。具体代码如下:
#include <stdio.h>
#include <stdlib.h>

// 定义一个链表节点结构体
typedef struct Node {
    int data;
    struct Node* next;
} Node;

// 函数声明
Node* createNode(int data);
void appendNode(Node** head, int data);
void printList(Node* head);
void freeList(Node* head);

int main() {
    Node* head = NULL; // 链表头指针

    // 向链表中添加节点
    appendNode(&head, 1);
    appendNode(&head, 2);
    appendNode(&head, 3);

    // 打印链表
    printf("链表内容:\n");
    printList(head);

    // 释放链表内存
    freeList(head);

    return 0;
}

// 创建一个新的节点
Node* createNode(int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    if (newNode == NULL) {
        fprintf(stderr, "内存分配失败\n");
        exit(EXIT_FAILURE);
    }
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

// 向链表末尾添加节点
void appendNode(Node** head, int data) {
    Node* newNode = createNode(data);
    if (*head == NULL) {
        *head = newNode;
    }
    else {
        Node* current = *head;
        while (current->next != NULL) {
            current = current->next;
        }
        current->next = newNode;
    }
}

// 打印链表内容
void printList(Node* head) {
    Node* current = head;
    while (current != NULL) {
        printf("%d -> ", current->data);
        current = current->next;
    }
    printf("NULL\n");
}

// 释放链表内存
void freeList(Node* head) {
    Node* current = head;
    while (current != NULL) {
        Node* temp = current;
        current = current->next;
        free(temp);
    }
}

  • 输出内容如下
  • 请添加图片描述

5-6 结构体内嵌函数指针(进阶)
  • 上节课前面的学长提到过了结构体内嵌函数,这是再C++的一个典型用法,但是再纯正的C语言是行不通的(大家也别怪前面的学长~讲错很正常)
  • 正确的做法是内嵌函数指针
    • 结构体可以内嵌函数指针,这使得结构体不仅能够存储数据,还能存储指向函数的指针,从而允许结构体在运行时执行特定的代码。这种能力使得结构体可以模拟面向对象编程中的对象和方法。
#include <stdio.h>

// 定义一个函数类型
typedef void (*FunctionType)(void);

// 定义一个结构体,包含一个函数指针
typedef struct {
    int value;
    FunctionType function;
} MyStruct;

// 定义一个函数,供结构体中的函数指针使用
void printValue(MyStruct *obj) 
{ 
	printf("Value: %d\n", obj->value); 
}

int main() {
    // 创建一个结构体实例
    MyStruct myStruct;
    myStruct.value = 10;
    myStruct.function = printValue;

    // 通过函数指针调用函数
    myStruct.function(&myStruct);

    return 0;
}
5-6-1 学过C++的同学(this)
  • 题外话,在C语言中,结构体本身并不存储 this 指针。实际上在C语言中,函数通常通过显式传递结构体指针来访问成员。
void printValue(MyStruct *obj) 
{
    printf("Value: %d\n", obj->value);
}

6 指针与字符和字符串

6-1 字符指针
  • 字符指针是一个指向字符变量的指针。它可以用来访问和修改字符变量的值。
char ch = 'A';
char *ptr = &ch;
printf("字符: %c\n", *ptr); // 输出字符
6-2 字符数组(字符串)
  • 字符串在C语言中通常是通过字符数组实现的。字符数组的最后一个元素是空字符(‘\0’),表示字符串的结束。
char str[] = "Hello";
char *ptr = str;
printf("字符串: %s\n", ptr); // 输出字符串
6-3 字符指针数组
  • 字符指针数组是一个数组,其中每个元素都是一个指向字符的指针。它可以用来存储多个字符串。
char *arr[] = {"Hello", "World", "C Programming"};
printf("字符串: %s\n", arr[0]);
6-4 字符指针与字符串函数
  • C标准库提供了许多处理字符串的函数,如 strlen, strcpy, strcat, strcmp 等。这些函数通常接受字符指针作为参数
#include <string.h>

char str1[] = "Hello";
char str2[] = "World";
int len = strlen(str1); // 获取字符串长度
strcpy(str2, str1); // 复制字符串
strcat(str1, str2); // 连接字符串
int cmp = strcmp(str1, str2); // 比较字符串
6-5 动态分配字符串
  • 使用 malloccalloc 函数可以动态分配内存来存储字符串。
#include <stdlib.h>

char *ptr = (char *)malloc(10 * sizeof(char)); // 分配内存
if (ptr != NULL) {
    strcpy(ptr, "Hello"); // 复制字符串
    printf("字符串: %s\n", ptr); // 输出字符串
    free(ptr); // 释放内存
}


7 指针与文件I/O(进阶)

  • 在C语言中,文件I/O操作通常涉及到文件指针(FILE类型指针),它是一个指向FILE结构体的指针,该结构体定义了标准库中用于文件操作的各种信息。文件指针允许程序与文件进行读写操作,如打开文件、读取文件内容、写入数据到文件等。
7-1 打开文件
FILE *fp = fopen("example.txt", "r");
if (fp == NULL) {
    perror("Error opening file");
    return -1;
}
7-2 读取文件内容
char buffer[1024];
while (fgets(buffer, sizeof(buffer), fp) != NULL) {
    printf("%s", buffer);
}
fclose(fp);

7-3 写入数据到文件
FILE *fp = fopen("example.txt", "w");
if (fp == NULL) {
    perror("Error opening file");
    return -1;
}

fprintf(fp, "Hello, World!");
fclose(fp);



  • 后面的内容全是进阶辣,感兴趣的同学再继续学习吧请添加图片描述




  • 还想继续?那来吧!

8 指针与动态内存分配(进阶)

  • 动态内存分配是C语言中的一个高级特性,它允许程序在运行时从堆区(heap)分配内存,而不是在编译时从栈区(stack)分配。
  • 动态内存分配提供了更大的灵活性和控制能力,但也要求程序员负责管理内存的分配和释放,以避免内存泄漏和访问越界等问题。
8-1 程序四大区(进阶)
  • 程序在执行时,其内存被划分为四个主要区域,分别是代码区、栈区、堆区和数据区。这些区域各自有不同的用途和生命周期。
  1. 代码区(Text Segment)
    • 代码区存储程序的机器代码,即CPU执行指令的集合。
    • 它通常包含函数定义、程序入口点等。
    • 代码区是只读的,以防止程序在执行过程中修改自己的代码。
    • 在程序的生命周期内,代码区的内容通常不会改变。
  2. 数据区(Data Segment)
    • 数据区包含程序中定义的全局变量和静态变量。
    • 全局变量是在所有函数外部定义的变量,它们在程序的整个执行期间都存在。
    • 静态变量在函数内部定义,但使用 static 关键字,它们在程序的整个执行期间存在,并且只初始化一次。
    • 数据区在程序开始执行前被初始化,并且在程序结束前一直存在。
  3. 栈区(Stack)
    • 栈区用于存储局部变量、函数参数、返回地址等。
    • 每当调用一个函数时,相应的信息(如返回地址、局部变量等)会被压入栈中。
    • 当函数返回时,这些信息会被弹出栈。
    • 栈是自动管理的,由编译器在函数调用时分配和释放内存。
    • 栈的大小通常有限,并且是连续的。
  4. 堆区(Heap)
    • 堆区用于动态内存分配,程序可以在运行时从堆区请求内存。
    • 堆的大小通常比栈大得多,但它不是连续的,因此可以动态地增长和收缩。
    • 动态分配的内存不会随着函数调用的结束而自动释放,程序员必须显式地使用 free 函数来释放它们。
    • 堆区的管理是程序员的责任,不当的管理可能导致内存泄漏。

8-2 void*的特性(进阶)
  • void* 是一个特殊的指针类型,它可以指向任何类型的数据。这意味着你可以将任何类型的指针赋值给 void* 类型的指针,反之亦然。
  • 但是,当你将 void* 指针赋值给其他类型的指针时,必须进行显式类型转换。
int *ptr = (int *)malloc(sizeof(int)); // 从void*转换为int*
  • 使用 void* 指针时,你需要记住它不保持任何关于它指向的数据类型的信息,因此在解引用之前必须进行正确的类型转换。

8-3 mallocfree``(进阶)
  • malloc 函数用于从堆区分配指定大小的内存块,并返回一个指向该内存块的 void* 类型的指针。如果内存分配失败,malloc 将返回 NULL
void* malloc(size_t size);
  • free 函数用于释放之前通过 malloccallocrealloc 分配的内存。当你不再需要动态分配的内存时,应该使用 free 函数来释放它,以避免内存泄漏。
void free(void *ptr);
  • 普通数据的动态分配
#include <stdio.h>
#include <stdlib.h>

int main() {
    int *ptr = (int *)malloc(sizeof(int)); // 动态分配一个int类型的内存

    if (ptr == NULL) {
        fprintf(stderr, "内存分配失败\n");
        return 1;
    }

    *ptr = 10; // 给分配的内存赋值
    printf("值: %d\n", *ptr); // 输出值

    free(ptr); // 释放分配的内存
    return 0;
}

  • 数组的动态分配
#include <stdio.h>
#include <stdlib.h>

int main() {
    int n = 5;
    int *array = (int *)malloc(n * sizeof(int)); // 动态分配一个包含5个int的数组

    if (array == NULL) {
        fprintf(stderr, "内存分配失败\n");
        return 1;
    }

    for (int i = 0; i < n; i++) {
        array[i] = i * i; // 给数组赋值
    }

    // 输出数组
    for (int i = 0; i < n; i++) {
        printf("%d ", array[i]);
    }
    printf("\n");

    free(array); // 释放分配的内存
    return 0;
}

  • 二维数组的动态分配
#include <stdio.h>
#include <stdlib.h>

int main() {
    int rows = 3;
    int cols = 4;
    int **array2D = (int **)malloc(rows * sizeof(int *)); // 动态分配行指针

    if (array2D == NULL) {
        fprintf(stderr, "内存分配失败\n");
        return 1;
    }

    for (int i = 0; i < rows; i++) {
        array2D[i] = (int *)malloc(cols * sizeof(int)); // 动态分配每行的列
        if (array2D[i] == NULL) {
            fprintf(stderr, "内存分配失败\n");
            // 释放之前已分配的行
            for (int j = 0; j < i; j++) {
                free(array2D[j]);
            }
            free(array2D);
            return 1;
        }
    }

    // 给二维数组赋值
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            array2D[i][j] = i * cols + j;
        }
    }

    // 输出二维数组
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%d ", array2D[i][j]);
        }
        printf("\n");
    }

    // 释放二维数组的内存
    for (int i = 0; i < rows; i++) {
        free(array2D[i]);
    }
    free(array2D);

    return 0;
}


9 C语言编译冷知识(进阶)

  • 能看到这里的你,已经很厉害了~
  • 让 我们回到梦开始的地方请添加图片描述
#include <stdio.h>
int main()
{
	printf("Hello World\n");
	return 0;
}
  • 你是否好奇,你的一段简单的C语言程序,点击运行按钮的时候,到底做了什么呢?
  • 当你编写了一段C语言程序并点击运行按钮时,计算机实际上执行了一系列复杂的步骤来将你的源代码转换成可执行的机器代码。这个过程通常被称为编译过程,它大致可以分为四个阶段:预处理、编译、汇编和链接。

9-1 预处理
  • 预处理阶段是编译过程的第一步,由预处理器(如C语言中的cpp)处理。在这个阶段,预处理器会执行以下操作:
    1. 展开所有的宏定义。
    2. 处理所有的文件包含指令(#include),将指定文件的内容插入到当前位置。
    3. 移除所有的注释。
    4. 根据指令(如#define)替换所有的宏。
    5. 条件编译指令(如#ifdef#ifndef#if#endif)的控制。
  • 预处理后的代码通常会有显著的增长,因为它包含了所有被包含的文件内容。

9-2 编译
  • 编译阶段是由编译器(如GCC的cc1)执行的。在这个阶段,编译器会将预处理后的代码转换成汇编语言。这个过程包括:
    1. 词法分析:将源代码分解成一系列的记号(token)。
    2. 语法分析:检查记号序列是否符合C语言的语法规则,并构建抽象语法树(AST)。
    3. 语义分析:检查AST的语义正确性,如类型检查。
    4. 代码生成:将AST转换成汇编语言代码。

9-3 汇编
  • 汇编阶段是由汇编器(如GCC的as)执行的。汇编器将汇编语言代码转换成机器代码。这个过程包括:
    1. 将汇编语言指令转换为机器指令。
    2. 分配内存地址给各个指令和数据。
    3. 生成可重定位的目标文件(.o文件),其中包含机器代码和数据。

9-4 链接
  • 链接阶段是由链接器(如GCC的ld)执行的。链接器将一个或多个目标文件和所需的库文件合并,生成最终的可执行文件。这个过程包括:
    1. 合并各个目标文件中的代码和数据。
    2. 解析外部引用,确保所有函数和数据项都能正确链接。
    3. 设置程序的入口点。
    4. 生成可执行文件(通常是.exe.out文件)。

9-5 C语言编译器
  • C语言编译器是一种将C语言源代码转换成机器语言(即二进制代码)的工具,以便计算机可以理解和执行。
  • 常用的C语言编译器包括:
    • GCC(GNU Compiler Collection):这是一个开源的编译器集合,支持多种编程语言,包括C、C++、Objective-C、Fortran、Ada、Go等。GCC是Linux系统下最常用的编译器。
    • Clang:由苹果公司开发的编译器,与GCC兼容,但通常更快且更易于调试。
    • MSVC(Microsoft Visual C++):微软开发的编译器,主要用于Windows平台。
    • ICC(Intel C++ Compiler):由英特尔开发,针对英特尔处理器进行了优化。

10 Cmake和CmakeList和Makefile(进阶)

  • CMake是一个跨平台的安装(编译)工具,它可以用来管理软件的编译过程。它使用一个名为CMakeLists.txt的文件来编写构建系统的描述,该文件描述了软件项目的构建规则和依赖关系。CMake可以生成不同平台上的本地构建文件,如Makefile、Visual Studio的项目文件等。
  • CMakeLists.txt文件是CMake的核心配置文件,它包含了构建项目的所有指令。例如,你可以指定源文件、头文件、库依赖、编译器标志、安装路径等。CMake会根据CMakeLists.txt文件和CMake的内置规则来生成对应平台的构建文件。
  • Makefile是一个文件,包含了用于编译源代码并生成可执行文件或库文件的指令。它是由GNU Make程序读取和执行的。Makefile通常由手动编写,也可以由其他工具生成,如CMake。
  • CMake与Makefile的区别在于,CMake提供了一个更高层次的抽象,可以自动处理不同平台的构建细节,而Makefile则更接近于构建过程的底层细节。使用CMake,你可以更容易地为多个平台创建构建系统,因为它会根据你的CMakeLists.txt文件和系统的CMake模块来生成相应的Makefile。

总结-完结撒花

  • 自此我们的C语言培训课程就到这里结束了
  • 感谢大家一路一来的坚持和努力,同时感谢各位学长学姐的培训!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/896441.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

如何利用 Python抓取网页数据 其他方式抓取网页数据列举

在 Python 中可以使用多种方法抓取网页数据&#xff0c;以下是一种常见的方法&#xff0c;使用requests和BeautifulSoup库。 一、安装所需库 在命令提示符或终端中执行以下命令安装requests和BeautifulSoup库&#xff1a; pip install requests pip install beautifulsoup4二…

python——类

问&#xff1a;小编为什么突然开始发python&#xff1f;难道C语言你不行了&#xff1f; 废话少说&#xff0c;让我们进入python中的类的学习&#xff01;&#xff01; &#xff08;一&#xff09;基本知识 &#xff08;1&#xff09;掌握类的概念 1、类的定义&#xff1a; 即…

python安装transformer教程

本章教程,记录在Windows中如何使用python安装transformer。 一、安装依赖 pip install transformers推荐使用国内镜像源,速度会快很多。 二、测试代码 from transformers import pipeline# 加载一个文本生成模型 text_generator = pipe

LCWLAN设备的实际使用案例

我们的LCWLAN设备在实际使用中以裸板的形式放在客户的智能总线控制器中&#xff0c;客户的 智能总线刀片灯&#xff0c;柔性灯货架&#xff0c;柔性感应钢网柜以及智能电子料架等设备都是接到总线控制 器中&#xff0c;然后总控制器通过CAN总线和我们的LCWLAN设备连接&#xff…

Linux DEADLINE调度算法详解

介绍 在实时系统中&#xff0c;调度算法的选择对于任务的及时执行至关重要。为了满足实时性需求&#xff0c;Linux内核引入了不同的调度算法&#xff0c;其中 DEADLINE 调度算法是为硬实时任务而设计的。DEADLINE 调度算法的目标是在多任务的情况下确保任务在其指定的最后期限…

Cpp::STL—容器适配器Stack和Queue的讲解和模拟实现(15)

文章目录 前言一、适配器模式概念分类 二、Stack核心作用代码实现 三、Queue核心作用代码实现 四、deque双端队列貌似兼收并蓄&#xff1f;实则也难以兼得~ 总结 前言 适配器也是STL六大组件之一&#xff0c;请跟我一起领悟它的智慧&#xff01;   正文开始&#xff01; 一、…

如何实现简单的 WinCC 项目分屏?

说明&#xff1a; 本文主要介绍了在不使用分屏器的情况下&#xff0c;通过 WinCC 项目中的设置&#xff0c;实现简单的分屏操作。两台显示器分别显示不同的 WinCC 画面&#xff0c;独自操作&#xff0c;互不影响。 试验环境 &#xff1a; 本文试验时所用硬件及软件环境…

案例分享—国外优秀UI设计作品赏析

国外UI界面设计之所以出色&#xff0c;首要原因在于其注重用户体验。设计师们深入洞察用户需求&#xff0c;通过细致的用户调研和数据分析&#xff0c;确保界面布局、色彩搭配及交互方式都能贴合用户习惯&#xff0c;从而提供流畅、直观的操作体验&#xff0c;增强用户满意度和…

【MySQL】数据库基础、库的操作、表的操作、数据类型

目录 1. 数据库基础1.1 MySQL是什么1.2 使用案例1.3 服务器&#xff0c;数据库&#xff0c;表关系 2. 库的操作2.1 字符集和校验规则2.1.1 查看系统默认字符集以及校验规则2.1.2 查看数据库的字符集和校验规则2.1.3 修改数据库的字符集和校验规则 2.2 库的操作2.2.1 创建数据库…

c++算法第4天

本篇文章包含三道算法题&#xff0c;难度由浅入深&#xff0c;适合新手练习哟 第一题 题目链接 牛牛的快递_牛客题霸_牛客网 题目解析 <1kg -------> 20元 大于1kg&#xff1a;超出部分每千克1元 加急 5元 代码原理 代码编写 #include …

QT 实现自定义水波进度条

1.界面实现效果 以下是具体的项目需要用到的效果展示。 2.简介 原理:随着进度的改变,在我们的绘制图像void paintEvent(QPaintEvent *) override;事件中绘制图形。 使用QPainter来绘制正弦波,通过定时器,不断的更新我们绘制的图形,动态改变正弦波的参数来创建动画效果…

【从零开始的LeetCode-算法】3099. 哈沙德数

如果一个整数能够被其各个数位上的数字之和整除&#xff0c;则称之为 哈沙德数&#xff08;Harshad number&#xff09;。给你一个整数 x 。如果 x 是 哈沙德数 &#xff0c;则返回 x 各个数位上的数字之和&#xff0c;否则&#xff0c;返回 -1 。 示例 1&#xff1a; 输入&am…

提高阅读效率:三种读书笔记方法的实践

你是否曾经感到&#xff0c;尽管阅读了大量书籍&#xff0c;却很少有几本能够留下持久的印象&#xff0c;甚至书中的人物也逐渐从记忆中消失。实际上&#xff0c;这种阅读方式可能并没有太大的价值。要想真正从阅读中获益&#xff0c;培养良好的阅读习惯至关重要&#xff0c;而…

IDEA下lombok安装及找不到get,set的问题的解决方法

在IDEA中使用Lombok,但是在编译时&#xff0c;提示找不到set()和get()方法&#xff0c;明明在javabean中使用了Data注解&#xff0c;但是编译器就是找不到。 Idea下安装Lombok(需要二步) 第一步&#xff1a; pom.xml中加入lombok依赖包 1 2 3 4 5 6 7 <!-- https://mvnre…

Linux的开发工具gcc Makefile gdb的学习

一&#xff1a;gcc/g 1. 1 背景知识 1. 预处理&#xff08;进行宏替换) 预处理 ( 进行宏替换 ) 预处理功能主要包括宏定义,文件包含,条件编译,去注释等。 预处理指令是以#号开头的代码行。 实例: gcc –E hello.c –o hello.i 选项“-E”,该选项的作用是让 gcc 在预处理结…

如何在算家云搭建PhotoMaker(图像生成)

一、PhotoMaker简介 PhotoMaker是一种高效、个性化的文本转图像生成方法&#xff0c;能通过堆叠 ID 嵌入自定义的逼真人类照片。相当于把一张人类照片的特征提取出来&#xff0c;然后生成你想要的不同风格照片&#xff0c;如写真等等。 主要特点&#xff1a; 在几秒钟内快速…

远控代码的重构-远控网络编程的设计上

套路化代码 但是我们这是一个MFC工程,我们需要考虑不是所有操作都需要到main函数里面实现,有些操作可以在main函数之前完成,有些可以在main函数返回以后完成,静态全局变量满足这个需求,我们需要添加一个自己的类 编辑器细节1 添加类和添加类向导的区别,一个是添加自己的类,一…

ESP8266 模块介绍—AT指令学习 笔记

零、简介 感谢百文网韦东山 老师对ESP8266模块的讲解 笔记在CSDN也有文章备份 大家可以在我的gitee仓库 中下载笔记源文件、ESP8266资料等 笔记源文件可以在Notion中导入 一、ESP8266-01S模块详细介绍 1. 名字的由来 ESP8266 是方形的主控芯片旁边的长方形是一个Flash-0…

000010 - Mapreduce框架原理

Mapreduce框架原理 1. InputFormat 数据输入1.1 切片与 MapTask 并行度决定机制1.2 Job 提交流程源码和切片源码详解1.2.1 Job 提交流程源码详解1.2.2 FileInputFormat 切片源码解析&#xff08;input.getSplits(job)&#xff09; 1.3 FileInputFormat 切片机制1.3.1 切片机制1…

基于Springboot个性化图书推荐系统的设计与实现

基于Springboot个性化图书推荐系统的设计与实现 开发语言&#xff1a;Java 框架&#xff1a;springboot JDK版本&#xff1a;JDK1.8 服务器&#xff1a;tomcat7 数据库&#xff1a;mysql 5.7 数据库工具&#xff1a;Navicat11 开发软件&#xff1a;idea 源码获取&#xff1a;…