指针的使用：

测试代码1：
 

#include <stdio.h>  
  
// 标准的 main 函数声明，包括可选的 envp 参数  
int main(int argc, char *argv[], char *envp[]) {  
    // argc 命令行参数的数量（包括程序名）  
    // argv 指向字符指针的指针数组，每个元素都是一个指向参数的字符串  
    // envp 指向环境变量的指针数组，每个元素都是一个指向环境字符串的指针 
    
    int time = getTime();
    // 打印程序名  
    printf("Program name: %s\n", argv[0]);  
  
    // 遍历命令行参数（除了程序名）  
    for (int i = 1; i < argc; i++) {  
        printf("Argument %d: %s\n", i, argv[i]);  
    }  
  
    // 通常不会在这里处理 envp，大多数程序中不是必需的。  
    // 如果需要访问环境变量 
    if (envp != NULL) {  
        for (int i = 0; envp[i] != NULL; i++) {  
            // 打印环境变量字符串，没有解析。 
            printf("Environment variable %d: %s\n", i, envp[i]);  
        }  
    }  
    return 0;  
}

运行结果如下：

 

测试代码2：

#include "date.h"
#include <stdio.h>  
  
int main() {  

    int time = getTime();
    int a = 10;  
    int b = 20;  
      
    // 定义两个整数指针  
    int *ptr1 = &a;  
    int *ptr2 = &b;  
      
    // 二级指针，初始时指向ptr1  
    int **pptr = &ptr1;  
    
    const char *ptr = "Hello";
    const char **ptr_ptr = &ptr;

    printf("Value of ptr: %s\n", ptr);
    printf("Value of ptr_ptr: %s\n", *ptr_ptr);

      
    printf("Before change: *ptr1 = %d, *ptr2 = %d\n", *ptr1, *ptr2);  
      
    // 通过pptr改变ptr1的值，让它指向ptr2所指向的地址  
    *pptr = ptr2;  
      
    // ptr1现在指向的是ptr2所指向的地址  
    printf("After change: *ptr1 = %d, *ptr2 = %d\n", *ptr1, *ptr2);  
      
    return 0;  
}

运行结果如下：

 

测试代码3：

#include "date.h" 
#include <stdio.h>  
#include <stdlib.h>  
#include <string.h> 
// 二级指针 
int main() {  
    int time = getTime();
    // 存储3个字符串  
    int numStrings = 3;  
    char **strings = (char **)malloc(numStrings * sizeof(char *));  
  
    // 检查malloc是否成功  
    if (strings == NULL) {  
        perror("Failed to allocate memory for strings");  
        return 1;  
    }  
  
    // 为每个字符串分配内存  
    for (int i = 0; i < numStrings; i++) {  
        strings[i] = (char *)malloc(50 * sizeof(char)); // 每个字符串最多49个字符加上一个'\0'  
        if (strings[i] == NULL) {  
            perror("Failed to allocate memory for a string");  
            // 释放之前分配的内存  
            for (int j = 0; j < i; j++) {  
                free(strings[j]);  
            }  
            free(strings);  
            return 1;  
        }  
    }  
  
    // 填充字符串  
    strcpy(strings[0], "Hello");  
    strcpy(strings[1], "World");  
    strcpy(strings[2], "C Programming");  
  
    // 通过二级指针访问和打印字符串  
    for (int i = 0; i < numStrings; i++) {  
        printf("%s\n", *(strings + i)); // 或者 strings[i]  
    }  
  
    // 释放内存  
    for (int i = 0; i < numStrings; i++) {  
        free(strings[i]);  
    }  
    free(strings);  
  
    return 0;  
}

运行结果如下：

 

测试代码4：

#include "date.h" 
#include <stdio.h>  

int add(int a, int b) {  
    return a + b;  
}  
  
int main() {  
    int time = getTime();
    // 基本数据类型的指针
    int var = 20;  
    int *ptr = &var;  
    printf("基本数据类型的指针: Value of var: %d, Value of *ptr: %d\n", var, *ptr);  
    *ptr = 22;  
    printf("修改后: Value of var: %d\n", var);  
  
    // 数组指针
    int arr[] = {10, 20, 30, 40, 50};  
    int *arrPtr = arr;  
    printf("数组指针: Value of arr[0]: %d, Value of arrPtr[0]: %d\n", arr[0], arrPtr[0]);  
    for (int i = 0; i < 5; i++) {  
        printf("arr[%d] = %d\n", i, *(arrPtr + i));  
    }  
  
    // 函数指针 
    int (*funcPtr)(int, int) = add;  
    int result = funcPtr(10, 20);  
    printf("函数指针: Result: %d\n", result);  
  
    // 二级指针（指针的指针）
    int var2 = 3000;  
    int *ptr2 = &var2;  
    int **pptr = &ptr2;  
    printf("二级指针: Value of var2: %d, Value of **pptr: %d\n", var2, **pptr);  
    **pptr = 4000;  
    printf("修改后: New value of var2: %d\n", var2);  
  
    return 0;  
}

运行结果如下：

 

测试代码5：

#include "date.h" 
#include <stdio.h>  
#include <stdlib.h>  
#include <string.h>  
  
// 函数声明  
int countSubstring(const char *str, const char *substr);  
  
int main() {  
    int time = getTime();
    char *inputStr = NULL; // 使用NULL初始化指针  
    char *searchStr = NULL; // 使用NULL初始化指针  
    int length, capacity = 1024; // 设置初始容量  
    int count;  
  
    // 分配内存给主串  
    inputStr = (char *)malloc(capacity * sizeof(char));  
    if (inputStr == NULL) {  
        perror("内存分配失败");  
        return 1;  
    }  
  
    // 分配内存给子串  
    searchStr = (char *)malloc(capacity * sizeof(char));  
    if (searchStr == NULL) {  
        free(inputStr);  
        perror("内存分配失败");  
        return 1;  
    }  
  
    // 输入主串  
    printf("请输入主串: ");  
    fgets(inputStr, capacity, stdin);  
    // 去除fgets读取的换行符  
    inputStr[strcspn(inputStr, "\n")] = 0;  
  
    // 输入子串  
    printf("请输入子串: ");  
    fgets(searchStr, capacity, stdin);  
    // 去除fgets读取的换行符  
    searchStr[strcspn(searchStr, "\n")] = 0;  
  
    // 检查输入是否为空  
    if (strlen(inputStr) == 0 || strlen(searchStr) == 0) {  
        printf("输入不能为空！\n");  
        free(inputStr);  
        free(searchStr);  
        return 1;  
    }  
  
    // 统计子串在主串中出现的次数  
    count = countSubstring(inputStr, searchStr);  
    printf("'%s' 在 '%s' 中出现了 %d 次。\n", searchStr, inputStr, count);  
  
    // 释放内存  
    free(inputStr);  
    free(searchStr);  
  
    return 0;  
}  
  
// 统计子串在主串中出现的次数  
int countSubstring(const char *str, const char *substr) {  
    int count = 0;  
    const char *tmp = str;  
    while ((tmp = strstr(tmp, substr)) != NULL) {  
        count++;  
        tmp++; // 移动到下一个字符，可能会错过重叠的子串  
        // 如果需要计算重叠子串，可以注释掉上面这行
    }  
    return count;  
}

运行结果如下：