C语言基础（十三）

指针的用法：

测试代码1：

#include "date.h" 
#include <stdio.h>  
#include <stdlib.h>  
  
int main() {  
    int time = getTime();
    int n = 3, m = 4;  
    
    // 使用malloc函数动态分配n行的指针数组，并将其赋值给二级指针arr。 
    int **arr = (int **)malloc(n * sizeof(int *));  
    // 循环遍历每一行。
    for (int i = 0; i < n; i++) {  
        // 为每一行动态分配m个整型元素的空间。
        arr[i] = (int *)malloc(m * sizeof(int));  
        // 循环遍历每一列。
        for (int j = 0; j < m; j++) {  
            //  填充二维数组的值
            arr[i][j] = i * m + j + 1; 
        }  
    }  
  
    // 使用指针遍历动态分配的二维数组  
    int *ptr;  
    for (int i = 0; i < n; i++) {  
        for (int j = 0; j < m; j++) {  
            // 将二维数组arr中每个元素的地址赋值给指针ptr。 
            ptr = &arr[i][j];  
            // 打印指针ptr指向的地址和值。
            printf("Address: %p, Value: %d\n", (void *)ptr, *ptr);  
        }  
    }  

    // 释放动态分配的内存空间
    for (int i = 0; i < n; i++) {
         free(arr[i]);  // 释放每一行的内存空间
    }
         free(arr);  // 释放指针数组的内存空间
         
         return 0;  
}

运行结果如下：

 

测试代码2：

#include "date.h" 
#include <stdio.h>  
  
// 函数声明  
void modifyChar(char *ptr);  
void modifyInt(int *ptr);  
void modifyFloat(float *ptr);  
  
int main() {  
    int time = getTime();
    char ch = 'A';  
    int num = 10;  
    float value = 3.14f;  
  
    // 调用 modifyChar 函数  
    printf("Before calling modifyChar: %c\n", ch);  
    modifyChar(&ch);  
    printf("After calling modifyChar: %c\n", ch);  
  
    // 调用 modifyInt 函数  
    printf("Before calling modifyInt: %d\n", num);  
    modifyInt(&num);  
    printf("After calling modifyInt: %d\n", num);  
  
    // 调用 modifyFloat 函数  
    printf("Before calling modifyFloat: %.2f\n", value);  
    modifyFloat(&value);  
    printf("After calling modifyFloat: %.2f\n", value);  
  
    return 0;  
}  
  
// 函数定义  
void modifyChar(char *ptr) {  
    *ptr = 'B';  
}  
  
void modifyInt(int *ptr) {  
    *ptr = 20;  
}  
  
void modifyFloat(float *ptr) {  
    *ptr = 2.71f;  
}

运行结果如下：

 

测试代码3：

#include "date.h" 
#include <stdio.h>  
#include <stdlib.h> // 引入stdlib.h以使用malloc和free  
#include <string.h> // 引入string.h以使用strlen和strcpy  
  
// 函数声明：返回指向动态分配字符串的指针  
char* createDynamicString(const char* input) {  
    // 计算输入字符串的长度（包括结尾的'\0'）  
    size_t length = strlen(input) + 1;  
  
    // 使用malloc动态分配足够的内存存储字符串  
    char *str = (char*)malloc(length * sizeof(char));  
    if (str == NULL) {  
        // 如果malloc失败，返回NULL  
        return NULL;  
    }  
  
    // 使用strcpy将输入字符串复制到新分配的内存中  
    strcpy(str, input);  
  
    // 返回指向新字符串的指针  
    return str;  
}  
  
int main() {  
    int time = getTime();
    // 调用函数，传入一个字符串  
    char *myString = createDynamicString("Hello, Dynamic World!");  
  
    // 检查返回值是否为NULL，以处理malloc失败的情况  
    if (myString != NULL) {  
        // 如果分配成功，则打印字符串  
        printf("The dynamic string is: %s\n", myString);  
  
        // 使用完毕后，释放分配的内存  
        free(myString);  
    } else {  
        // 如果malloc失败，则打印错误消息  
        printf("Memory allocation failed!\n");  
    }  
  
    return 0;  
}

运行结果如下：

 

测试代码4:

#include "date.h" 
#include <stdio.h>  
#include <stdlib.h> // 引入stdlib.h以使用malloc  
  
// 函数声明，返回指向int的指针  
int* createIntPointer() {  
    // 动态分配一个整数的内存  
    int *ptr = (int*)malloc(sizeof(int));  
    if (ptr != NULL) {  
        *ptr = 10; // 初始化分配的内存  
    }  
    return ptr; // 返回指向整数的指针  
}  
  
int main() { 
    int time = getTime(); 
    // 调用函数，接收返回的指针  
    int *myInt = createIntPointer();  
  
    if (myInt != NULL) {  
        // 通过指针访问并打印整数的值  
        printf("The value is: %d\n", *myInt);  
  
        // 释放之前分配的内存  
        free(myInt);  
    }  
  
    return 0;  
}

运行结果如下：

 

测试代码5：

#include "date.h" 
#include <stdio.h>  
  
int addFive(int x) {  
    return x + 5;  
}  
int main() { 
    int time = getTime(); 
    int (*funcPtr)(int); // 定义指向函数的指针  
    funcPtr = addFive; // 将函数的地址赋给指针  
  
    // 通过指针调用函数  
    int result = funcPtr(10);  
    printf("The result is: %d\n", result); // 输出: The result is: 15  
  
    return 0;  
}

运行结果如下：

 

测试代码6：

#include "date.h" 
#include <stdio.h>  
  
// 定义两个函数  
int add(int a, int b) {  
    return a + b;  
}  
  
int multiply(int a, int b) {  
    return a * b;  
}  
  
int main() {  
    int time = getTime();
    // 定义指向函数的指针  
    int (*addPtr)(int, int) = add;  
    int (*multiplyPtr)(int, int) = multiply;  
  
    // 通过指针调用函数  
    printf("5 + 3 = %d\n", addPtr(5, 3));  
    printf("5 * 3 = %d\n", multiplyPtr(5, 3));  
  
    // 定义一个指向函数的指针数组  
    int (*funcPtrs[2])(int, int);  
    funcPtrs[0] = add;  
    funcPtrs[1] = multiply;  
  
    // 通过指针数组调用函数  
    printf("Using array to call functions:\n");  
    printf("funcPtrs[0](7, 2) = %d (addition)\n", funcPtrs[0](7, 2));  
    printf("funcPtrs[1](7, 2) = %d (multiplication)\n", funcPtrs[1](7, 2));  
  
    // 循环遍历数组中的函数  
    for (int i = 0; i < 2; i++) {  
        if (i == 0) {  
            printf("Calling addition: ");  
        } else {  
            printf("Calling multiplication: ");  
        }  
        printf("%d(%d, %d) = %d\n", i, 7, 4, funcPtrs[i](7, 4));  
    }  
  
    return 0;  
}

运行结果如下：