c语言指针

wh_xia_jun2024-07-02 20:16

指针

在C语言中，变量名不是地址。变量名是用来标识内存地址的符号，它表示变量在计算机内存中的位置。当定义一个变量时，系统会为该变量分配一个内存地址，并且可以使用变量名来访问该变量的值。

在C语言中，指针是一种特殊的变量，它存储的是其他变量的内存地址，而不是值本身。通过指针，我们可以间接地访问和修改其指向的内存区域的值。

指针的声明和定义如下：

复制代码 
数据类型 *指针变量名;

其中，数据类型可以是任何有效的C语言数据类型，如int、char、float等。指针变量名是你为指针变量选择的名称。

下面是一个完整的例子，演示了如何声明、定义和使用指针变量：

复制代码 
​
cpp 复制代码 
#include <stdio.h>  
  
int main() {  
    int num = 10;  
    int *ptr; // 声明指针变量ptr  
    ptr = &num; // 将num的地址赋值给ptr  
  
    printf("num的值为：%d\n", num);  
    printf("num的地址为：%p\n", &num);  
    printf("ptr指向的值为：%d\n", *ptr);  
    printf("ptr的地址为：%p\n", ptr);  
  
    return 0;  
}

在上面的例子中，我们声明了一个整型变量num并初始化为10。然后声明了一个指向整型的指针变量ptr。通过将&num赋值给ptr，我们将num的地址存储在了ptr中。使用*ptr可以访问ptr所指向的内存区域的值，即num的值。通过&num可以得到num的地址。程序输出了num的值、num的地址、ptr指向的值以及ptr的地址。

数据交互：

可以使用指针来交换两个变量的值，这是一个非常常见的使用指针的例子。以下是一个使用 C 语言实现的示例：

首先，定义一个交换函数，它接收两个整数的指针：

复制代码 
​
#include <stdio.h>  
  
void swap(int *a, int *b) {  
    int temp = *a;  
    *a = *b;  
    *b = temp;  
}

然后，你可以在主函数中这样使用这个函数：

复制代码 
​
​
int main() {  
    int x = 5;  
    int y = 10;  
    printf("Before swap: x = %d, y = %d\n", x, y);  
    swap(&x, &y);  
    printf("After swap: x = %d, y = %d\n", x, y);  
    return 0;  
}

在这个例子中，swap函数通过接收两个指针来交换两个整数的值。当我们调用swap(&x, &y)时，我们传递的是x和y的地址，所以函数能够直接影响到这两个变量的值。

ps:

在C语言中，函数的参数传递是值传递。这意味着当你传递一个变量到函数中时，函数会创建一个新的副本，而不是直接引用原始变量。因此，在函数内部对参数的任何修改都不会影响原始变量的值。

下面是一个简单的示例来说明这个概念：

复制代码 
​
cpp 复制代码 
#include <stdio.h>  
  
void addOne(int num) {  
    num = num + 1;  
    printf("num inside the function: %d\n", num);  
}  
  
int main() {  
    int num = 0;  
    addOne(num);  
    printf("num in main: %d\n", num);  
    return 0;  
}

在这个例子中，addOne函数接收一个整数参数num，然后对它加一。然而，这种修改不会影响到main函数中的num变量。输出将是：

复制代码 
makefile复制代码
​
num inside the function: 1  
num in main: 0

这表明尽管在函数内部num的值被改变了，但这种改变并没有影响到函数外部的原始变量。这就是因为在C语言中，函数参数是通过值传递的。

如果你希望在函数中修改一个变量的值，并影响到原始变量，你需要使用指针。通过指针，你可以直接引用和修改内存中的原始值，而不是传递一个副本。

数组与指针

在C语言中，数组和指针之间有一个非常紧密的关系。数组的名称可以被看作是一个指向数组第一个元素的指针。同样，一个指向某个特定类型的指针也可以被看作是一个指向该类型的数组。这种关系可以在下面的示例代码中看到：

复制代码 
​
cpp 复制代码 
#include <stdio.h>  
  
int main() {  
    // 定义一个包含5个整数的数组  
    int array[5] = {1, 2, 3, 4, 5};  
  
    // 定义一个指向整数的指针  
    int *ptr;  
  
    // 将ptr指向array的第一个元素  
    ptr = array;  
  
    // 使用指针访问数组元素  
    for(int i = 0; i < 5; i++) {  
        printf("array[%d] = %d\n", i, *(ptr + i));  
    }  
  
    // 修改数组中的元素值通过指针  
    *(ptr + 2) = 20;  
  
    // 打印修改后的数组  
    printf("Modified array: ");  
    for(int i = 0; i < 5; i++) {  
        printf("%d ", array[i]);  
    }  
    printf("\n");  
  
    return 0;  
}

在这个例子中，我们首先定义了一个包含5个整数的数组array，然后定义了一个指向整数的指针ptr。我们将ptr指向array的第一个元素，然后使用一个循环通过指针访问数组的每个元素。我们也可以使用指针修改数组中的元素值，如示例中我们将第三个元素值修改为20。

二维数组的指针：

cpp 复制代码 
include <stdio.h>
int main(void)
​
{
​
int zippo[4][2] = { {2,4}, {6,8}, {1,3}, {5, 7} };
int (*pz)[2];
pz = zippo;
​
printf("   pz = %p,    pz + 1 = %p\n",
       pz,         pz + 1);
printf("pz[0] = %p, pz[0] + 1 = %p\n",
       pz[0],      pz[0] + 1);
printf("  *pz = %p,   *pz + 1 = %p\n",
       *pz,        *pz + 1);
printf("pz[0][0] = %d\n", pz[0][0]);
printf("  *pz[0] = %d\n", *pz[0]);
printf("    **pz = %d\n", **pz);
printf("      pz[2][1] = %d\n", pz[2][1]);
printf("*(*(pz+2) + 1) = %d\n", *(*(pz+2) + 1));
​
return 0;
}
/* zippo1.c -- zippo info */



​

include <stdio.h>
int main(void)
{
int zippo[4][2] = { {2,4}, {6,8}, {1,3}, {5, 7} };
​
printf("   zippo = %p,    zippo + 1 = %p\n",
       zippo,         zippo + 1);
printf("zippo[0] = %p, zippo[0] + 1 = %p\n",
       zippo[0],      zippo[0] + 1);
printf("  *zippo = %p,   *zippo + 1 = %p\n",
       *zippo,        *zippo + 1);
printf("zippo[0][0] = %d\n", zippo[0][0]);
printf("  *zippo[0] = %d\n", *zippo[0]);
printf("    **zippo = %d\n", **zippo);
printf("      zippo[2][1] = %d\n", zippo[2][1]);
printf("*(*(zippo+2) + 1) = %d\n", *(*(zippo+2) + 1));
​
return 0;
}

函数与指针

函数指针是指向函数的指针变量。它可以用来存储函数的地址，并在需要时调用该函数。下面是一个简单的例子，演示了如何定义和使用函数指针。

cpp 复制代码 
#include <stdio.h>  
  
// 定义一个函数，用于计算两个整数的和  
int add(int x, int y) {  
    return x + y;  
}  
  
int main() {  
    // 定义一个函数指针，指向add函数  
    int (*fp)(int, int) = add;  
  
    // 定义一个整数数组  
    int arr[] = {1, 2, 3, 4, 5};  
  
    // 使用函数指针调用add函数，计算数组元素的和  
    int sum = 0;  
    for (int i = 0; i < 5; i++) {  
        sum = fp(sum, arr[i]);  
    }  
  
    // 输出计算结果  
    printf("Sum of array elements: %d\n", sum);  
  
    return 0;  
}

在这个例子中，我们定义了一个函数add，用于计算两个整数的和。然后，我们定义了一个函数指针fp，指向add函数。在main函数中，我们使用fp来调用add函数，计算一个整数数组的元素之和，并输出结果。

在C语言中，函数指针是指向函数的指针变量。它通常用于回调函数、函数参数传递和函数表等场景。分别给出这三个场景下应用的例子

当然，以下是函数指针在C语言中的三种常见应用场景的例子：

  1. 回调函数（Callback Functions）

在C语言中，函数指针最常见的用途是实现回调函数。以下是一个简单的例子：

cpp 复制代码 
#include <stdio.h>  
  
// 定义一个函数指针类型  
typedef void (*callback_t)(int);  
  
// 定义一个函数，这个函数接受一个整数和一个回调函数  
void demo_function(int x, callback_t callback) {  
    printf("The value of x is: %d\n", x);  
    // 调用回调函数  
    callback(x);  
}  
  
// 定义一个回调函数，用于输出一个整数的平方  
void square(int x) {  
    printf("The square of %d is: %d\n", x, x * x);  
}  
  
int main() {  
    // 调用demo_function函数，并传入回调函数square  
    demo_function(5, square);  
    return 0;  
}
  1. 函数参数传递（Function Parameters Passing）

函数指针也可以作为参数传递给其他函数，以实现更灵活的功能。以下是一个例子：

cpp 复制代码 
#include <stdio.h>  
  
// 定义一个函数，这个函数接受一个整数和一个函数指针  
void apply_func(int x, void (*func)(int)) {  
    func(x);  
}  
  
// 定义一个函数，用于输出一个整数的平方  
void square(int x) {  
    printf("The square of %d is: %d\n", x, x * x);  
}  
  
int main() {  
    // 调用apply_func函数，并传入函数square作为参数  
    apply_func(5, square);  
    return 0;  
}
  1. 函数表（Function Tables）

函数指针还可以用于实现函数表，以便根据运行时的决策来调用不同的函数。以下是一个例子：

cpp 复制代码 
#include <stdio.h>  
  
// 定义一个函数指针类型，用于指向处理函数的指针数组的函数指针类型  
typedef void (*operation_t)(int);  
  
// 定义几个处理函数  
void print_square(int x) { printf("%d\n", x * x); }  
void print_cube(int x) { printf("%d\n", x * x * x); }  
void print_quartic(int x) { printf("%d\n", x * x * x * x); }  
  
// 定义一个包含这三个函数的函数指针数组（即函数表）  
operation_t operations[] = { print_square, print_cube, print_quartic };  
  
int main() {  
    // 通过函数表调用不同的函数  
    for (int i = 0; i < 3; i++) {  
        operations[i](i + 1);  // 分别计算并打印1的平方、立方和四次方，2的平方、立方和四次方，以及3的平方、立方和四次方。  
    }  
    return 0;  
}

在C语言中，函数的可变参数（Variable Arguments）是一种特殊的函数参数类型，它允许函数接受可变数量的参数。这种参数类型被表示为...（三个点），通常作为函数参数列表的最后一个参数。

可变参数的应用场景是在函数需要处理可变数量或类型的参数时，例如函数需要接受任意数量的整数、字符串或其他数据类型，或者需要接受不同数量的参数进行不同的操作。

下面是一个简单的示例，演示了如何使用可变参数实现一个函数，该函数接受任意数量的整数并计算它们的和：

cpp 复制代码 
#include <stdio.h>  
#include <stdarg.h>  
  
int sum(int count, ...) {  
    va_list args;  // 定义一个va_list类型的变量，用于存储可变参数的列表  
    int sum = 0;   // 初始化一个sum变量用于计算总和  
  
    va_start(args, count);  // 初始化args变量，将其指向第一个可变参数  
  
    // 遍历可变参数列表，计算它们的总和  
    for (int i = 0; i < count; i++) {  
        int num = va_arg(args, int);  // 依次获取每个整数参数的值  
        sum += num;  
    }  
  
    va_end(args);  // 清理va_list变量  
  
    return sum;  
}  
  
int main() {  
    int a = 1, b = 2, c = 3;  
    printf("Sum: %d\n", sum(3, a, b, c));  // 输出：Sum: 6  
    return 0;  
}

在上面的示例中，sum函数接受一个整数count表示可变参数的数量，然后使用一个va_list类型的变量args来存储可变参数的列表。通过调用va_start宏初始化args变量，然后使用va_arg宏依次获取每个整数参数的值，并计算它们的总和。最后，调用va_end宏清理args变量。

在C语言中，fopen函数用于打开文件，并返回一个文件指针。如果打开文件成功，它会返回一个指向文件的指针，该指针随后可用于进行其他的输入和输出操作。如果打开文件失败，fopen则会返回NULL。

文件

fopen函数的原型如下：

复制代码 
FILE *fopen(const char *path, const char *mode);

  • path：这是一个字符串，表示要打开的文件的路径或文件名。

复制代码 
mode

：这也是一个字符串，表示打开文件的模式。下面是一些常见的模式：

  • r：以只读方式打开文件。文件必须存在。

  • w：以只写方式打开文件。如果文件存在，内容会被清空。如果文件不存在，会尝试创建一个新文件。

  • a：以追加方式打开文件。如果文件存在，写操作将在文件的末尾进行。如果文件不存在，会尝试创建一个新文件。

  • r+：以读/写方式打开文件。文件必须存在。

  • w+：以读/写方式打开文件。如果文件存在，内容会被清空。如果文件不存在，会尝试创建一个新文件。

  • a+：以读/追加方式打开文件。如果文件存在，写操作将在文件的末尾进行。如果文件不存在，会尝试创建一个新文件。

​

​

在C语言中，fread()函数用于从文件中读取数据。它是一个非常强大的工具，因为它可以读取任意类型的数据，无论是字符、整数、浮点数，还是自定义的数据结构。

fread()

fread()函数的原型如下：

复制代码 
size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);

参数说明：

  • ptr：指向用于存储数据的内存块的指针。

  • size：要读取的每个元素的大小，以字节为单位。

  • nmemb：要读取的元素的数量。

  • stream：指向FILE对象的指针，该对象指定了一个输入流。

fread()函数会从stream指向的文件中读取nmemb个元素，每个元素的大小为size字节，并将这些数据存储在由ptr指向的内存块中。函数返回成功读取的元素数量。如果返回值小于nmemb，则可能表示发生了错误或者到达了文件的末尾。

例如，以下代码将从文件中读取一个整数数组：

cpp 复制代码 
#include <stdio.h>  
  
int main() {  
    FILE *file;  
    int numbers[10];  
    size_t i, n;  
  
    file = fopen("numbers.txt", "r");  
    if (file == NULL) {  
        printf("Cannot open file\n");  
        return 1;  
    }  
  
    n = fread(numbers, sizeof(int), 10, file);  
    for (i = 0; i < n; i++) {  
        printf("%d ", numbers[i]);  
    }  
    printf("\n");  
  
    fclose(file);  
    return 0;  
}

在这个例子中，我们打开名为"numbers.txt"的文件，并使用fread()函数从文件中读取10个整数。然后，我们遍历这些整数并打印出来。注意，我们使用了sizeof(int)作为fread()的第二个参数，这是因为我们要读取的是整数，所以我们需要知道每个整数在内存中占用的字节数。

相关推荐
盼海9 分钟前
排序算法(五)--归并排序
数据结构·算法·排序算法
网易独家音乐人Mike Zhou4 小时前
【卡尔曼滤波】数据预测Prediction观测器的理论推导及应用 C语言、Python实现（Kalman Filter）
c语言·python·单片机·物联网·算法·嵌入式·iot
搬砖的小码农_Sky6 小时前
C语言：数组
c语言·数据结构
Swift社区7 小时前
LeetCode - #139 单词拆分
算法·leetcode·职场和发展
Kent_J_Truman8 小时前
greater＜＞() 、less＜＞()及运算符 ＜ 重载在排序和堆中的使用
算法
先鱼鲨生8 小时前
数据结构——栈、队列
数据结构
一念之坤8 小时前
零基础学Python之数据结构 -- 01篇
数据结构·python
IT 青年8 小时前
数据结构 （1）基本概念和术语
数据结构·算法
熬夜学编程的小王8 小时前
【初阶数据结构篇】双向链表的实现（赋源码）
数据结构·c++·链表·双向链表
Dong雨9 小时前
力扣hot100--＞栈/单调栈
算法·leetcode·职场和发展
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04玄机平台应急响应—webshell查杀05Coze扣子平台完整体验和实践（附国内和国际版对比）06Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO07【目标跟踪】相机运动补偿08Unity中PICO实现 隔空取物 和 接触抓取物体09RAG 实践- Ollama+RagFlow 部署本地知识库10怎样让音频速度变慢？请跟随以下方法进行操作