指针的用法：
测试代码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;
}运行结果如下：
