C語言：函數指針，數組，結構體詳情 - c,c#,知識哈哈哼嘿動態日志

動態

詳情

返回

C語言：函數指針，數組，結構體 - 動態詳情

10:42 上午 · 11月 03 ,2025

函數指針、數組、結構體

一、函數指針

1.1 函數名

一個函數在編譯時被分配一個入口地址，這個地址就稱為函數的指針，函數名代表函數的入口地址

#include <stdio.h>

// 一個函數在編譯時被分配一個入口地址，這個地址就稱為函數的指針，函數名代表函數的入口地址
void func() {
    printf("這是func函數內部的打印\n");
}

int main() {
    // 函數名，編譯器做了特殊處理，func, &func, *func 都是指同一個地址
    printf("%p, %p, %p\n", func, &func, *func);
    // 調函數     函數地址()
    func();
    (&func)();
    (*func)();

    return 0;
}

1.2 函數指針

函數指針：它是指針，指向函數的指針
語法格式：
```
返回值 (*函數指針變量)(形參列表);
```
- 函數指針變量的定義，其中返回值、形參列表需要和指向的函數匹配

#include <stdio.h>

/*
// ============= 無參無返回值
void f1() {}

// p1 函數指針變量
void (* p1)(); // 先定義變量
p1 = f1;  // 再賦值
// 定義同時初始化
void (* p11)() = f1;

// ============= 有參無返回值
void f2(int a, int b, int c) {}
void (* p2)(int, int, int) = f2;

// ============= 有參有返回值
int f3(int a, int b) { return 1;}
int (* p3)(int, int) = f3;
*/

// 函數定義
int my_add(int a, int b) {
    int res = a + b;

    return res;
}

int main() {
    // 定義一個變量 p1, 指向my_add
    int (* p1)(int, int) = my_add; // 定義同時賦值，叫初始化
    int temp = p1(1, 2); // 簡單理解  p1就是my_add的別名
    printf("temp = %d\n", temp);

    int (* p2)(int, int); // 先定義
    p2 = my_add; // 後賦值
    temp = p2(10, 10);
    printf("temp = %d\n", temp);

    return 0;
}

1.3 回調函數

函數指針變量做函數參數，這個函數指針變量指向的函數就是回調函數
回調函數可以增加函數的通用性：在不改變原函數的前提下，增加新功能

#include <stdio.h>

// 函數定義
int my_add(int a, int b) { // 具體實現功能
    return a + b;
}

int my_sub(int a, int b) { // 具體實現功能
    return a - b;
}

// 有個想法  計算器  知道有2個參數   具體實現沒有想好
// p 函數指針變量
// 回調函數可以增加函數的通用性：在不改變原函數的前提下，增加新功能
int calc(int x, int y, int (*p)(int, int)) { // 計算器，這個函數是框架，不實現功能，也不關心具體實現，留好通過的位置
    int temp = p(x, y); // 調用別的函數實現功能，p就是回調函數
    return temp;
}

int main() {
    int temp;
    temp = calc(1, 2, my_add);
    printf("加法：temp = %d\n", temp);

    temp = calc(1, 2, my_sub);
    printf("減法：temp = %d\n", temp);

    return 0;
}

二、數組

2.1 基本語法

在這裏插入圖片描述

2.1.1 數組的使用

數據類型：數組中所有元素的類型（int、float、char等）
數組名：標識符，遵循變量命名規則

元素個數：編譯時確定的正整數（常量表達式）

#include <stdio.h>

int main() {
  // 定義同時賦值，叫初始化
  int arr[5] = {1, 2, 4, 5, 6};
  //            0  1  2  3  4
  arr[0] = 8; // 修改元素
  // 不要使用下標不存在的元素，越界，超過數據範圍，後面容易導致程序崩潰
  // arr[10] = 99; // err
  printf("%d, %d, %d, %d, %d\n", arr[0], arr[1], arr[2], arr[3], arr[4]);
  // for 遍歷  
  for(int i = 0; i < 5; i++) { // i = 0, 1, 2, 3, 4
      printf("%d, ", arr[i]);
  }

  return 0;
}

2.1.2 數組的初始化

在定義數組的同時進行賦值，稱為初始化
全局數組若不初始化，編譯器將其初始化為零
局部數組若不初始化，內容為隨機值

#include <stdio.h>

int main() {
    // 全部初始化
    int a1[5] = {1, 2, 3, 4, 5};
    // 部分初始化，沒有初始化的，默認賦值為0
    int a2[5] = {1, 2};
    // 所有元素初始化為0
    int a3[5] = {0};
    // 定義的時候， []可以不寫數字，一定要初始化
    int a4[] = {1, 3, 5, 7, 9}; // 根據初始化的元素個數確定數組的大小

    // for 遍歷  
    for(int i = 0; i < 5; i++) { // i = 0, 1, 2, 3, 4
        printf("%d, ", a4[i]);
    }

    return 0;
}

2.1.3 數組名

數組名是一個地址的常量，代表數組中首元素的地址

#include <stdio.h>

int main() {
    int a[] = {1, 3, 5, 7, 9}; // 內容，元素
    //         0  1  2  3  4   位置，下標
    // 數組名是一個地址的常量
    // a = NULL; // err
    // 代表數組中首元素的地址
    printf("a = %p, &a[0] = %p\n", a, &a[0]);
    // sizeof(a) 和 sizeof(&a[0]) 區別
    // 編譯器對數組名做特殊處理，sizeof(a) 不是測量指針的大小，測量這個數組的大小
    // 有5個元素，每個元素是int類型   5 * sizeof(int) = 5 * 4 = 20
    printf("sizeof(a) = %d, sizeof(&a[0]) = %d\n", sizeof(a), sizeof(&a[0]));
    // 求 元素個數    總大小 / 一個元素的大小
    printf("%d, %d\n", sizeof(a)/sizeof(int), sizeof(a)/sizeof(a[0]));

    return 0;
}

2.2 數組案例

2.2.1 一維數組的最大值

#include <stdio.h>
#include <stdlib.h> // srand()   rand()
#include <time.h>   // time()

int main() {
    int a[10];
    int n = sizeof(a)/sizeof(a[0]);
    srand(time(0)); // 隨機種子

    // 分別賦值，50以內的隨機數  1~50
    for (int i = 0; i < n; i++) {
        a[i] = rand() % 50 + 1;
        printf("%d, ", a[i]);
    }
    printf("\n");

    int max = a[0]; // 假設第0個元素為最大值
    for (int i = 1; i < n; i++) {
        if (max < a[i]) {
            max = a[i]; // 保存最大值
        }
    }

    printf("max = %d\n", max);

    return 0;
}

int main01() {
    // int a[10];
    // 分別賦值，50以內的隨機數  1~50

    // 1. 隨機種子
    srand(time(0));
    // 2. 產生隨機數
    int n = rand();
    printf("n = %d\n", n);

    int m = rand() % 50 + 1;
    printf("m = %d\n", m);

    return 0;
}

2.2.2 一維數組的逆置

#include <stdio.h>
#include <stdlib.h> // srand()   rand()
#include <time.h>   // time()

int main() {
    int a[10];
    int n = sizeof(a)/sizeof(a[0]);
    srand(time(0)); // 隨機種子

    // 分別賦值，50以內的隨機數  1~50
    for (int i = 0; i < n; i++) {
        a[i] = rand() % 50 + 1;
        printf("%d, ", a[i]);
    }
    printf("\n");
    int left = 0;
    int right = n - 1;
    int temp;

    while(left < right) {
        temp = a[left];
        a[left] = a[right];
        a[right] = temp;
        left++;
        right--;
    }

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

    return 0;
}

2.3 數組和指針

2.3.1 通過指針操作數組元素

數組名字是數組的首元素地址，但它是一個常量
* 和 [] 效果一樣，都是操作指針所指向的內存

#include <stdio.h>

int main() {
    int a[5] = {1, 3, 5, 7, 9};
    // 定義一個變量，保存首元素地址，首元素是int,  需要int *
    int * p;
    p = &a[0]; // p不是指向整個數組，只是指向首元素
    p = a; // a和&a[0]一樣

    // *(p+i) ===> p[i]   * 和 [] 效果一樣，都是操作指針所指向的內存
    for (int i = 0; i < 5; i++) {
        printf("%d, %d\n", *(p+i), p[i]);
    }

    return 0;
}

int main01() {
    int a = 10;

    int * p = &a;

    // * 和 [] 效果一樣，都是操作指針所指向的內存
    // *p = 123;
    // *(p+0) = 123;  // ====>   *(p+i) ===> p[i]
    p[0] = 123;

    printf("%d, %d, %d, %d\n", a, *p, *(p+0), p[0]);

    return 0;
}

2.3.2 指針數組

指針數組，它是數組，數組的每個元素都是指針類型

#include <stdio.h>

int main() {
    // 指針數組，它是數組，數組的每個元素都是指針類型
    int a = 10, b = 20, c = 30;

    int * p[] = {&a, &b, &c};

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

    return 0;
}

int main01() {
    int a = 10, b = 20, c = 30;
    int * p1 = &a;
    int * p2 = &b;
    int * p3 = &c;

    return 0;
}

2.3.3 數組名做函數參數

數組名做函數參數，函數的形參本質上就是指針

#include <stdio.h>

// 數組名做函數參數，函數的形參本質上就是指針
void print_arr2(int a[5]) { // 形參數組，不是數組，是指針變量
    // a = NULL; // 是變量才能賦值
    // printf("形參的數組 sizeof(a) = %d\n", sizeof(a)); // 8, 64位系統，指針大小為8
}

// void print_arr(int a[5], int n)
// void print_arr(int a[], int n)
void print_arr(int * a, int n)  // 9、10、11行，等價，只有指針變量，保存首元素地址
{
    for (int i = 0; i < n; i++) {
        printf("%d, ", a[i]);
    }
    printf("\n");
}

int main() {
    int a[5] = {1, 3, 5, 7, 9};
    // 非形參的數組，是數組
    // a = NULL; // 數組名是常量
    printf("非形參的數組 sizeof(a) = %d\n", sizeof(a)); // 20, 整個數組大小

    print_arr(a, 5);
    // print_arr(&a[0], 5); // a和&a[0]值一樣

    return 0;
}

2.3.4 二維數組

二維數組在內存中是按行連續存儲的，即先存儲第 0 行的所有元素，再存儲第 1 行，以此類推。
對於int a2，內存佈局為：

a0 → a0 → a0 → a1 → a1 → a1

#include <stdio.h>

int main() {
  // 3個 int [4]  3個一維數據
  int a[3][4] = {
      {00, 01, 02, 03},
      {10, 11, 12, 13},
      {20, 21, 22, 23},
  };

  for (int i = 0; i < 3; i++) { // i = 0, 1, 2
      for (int j = 0; j < 4; j++) { // j = 0, 1, 2, 3
          // 打印保留2位，不夠，前面補0
          printf("%02d, ", a[i][j]);
      }
      printf("\n");
  }

  return 0;
}

2.4 字符數組與字符串

2.4.1 字符數組與字符串區別

C語言中沒有字符串這種數據類型，可以通過char的數組來替代
數字0(和字符 '\0' 等價)結尾的char數組就是一個字符串，字符串是一種特殊的char的數組

在這裏插入圖片描述

如果char數組沒有以數字0結尾，那麼就不是一個字符串，只是普通字符數組

#include <stdio.h>

int main() {
    // 1. 普通字符數組，沒有結束符'\0'或數字0
    char s1[] = {'a', 'b', 'c'};
     // %s 打印的原理，從第一個字符開始打印，直到遇到結束符，停止打印
    printf("s1 = %s\n", s1);
    // 2. 字符串，有結束符'\0'或數字0
    char s2[] = {'a', 'b', 'c', '\0'};
    char s3[] = {'a', 'b', 'c', 0};
    // %s 打印的原理，從第一個字符開始打印，直到遇到結束符，停止打印
    printf("s2 = %s\n", s2);
    printf("s3 = %s\n", s3);
    // 3. 區分 字符數組 還是 字符串
    char s4[3] = {'a', 'b', 'c'}; // 數組
    char s5[4] = {'a', 'b', 'c'}; // 串， 只初始化3個元素，沒有初始化的賦值為0
    // 4. 重點， 字符串方式初始化
    char s6[] = "abc"; // 雙引號，默認隱藏了結束符
    char s7[] = {'a', 'b', 'c', '\0'}; // s6和s7等價，不同的寫法
    printf("%s, %s\n", s6, s7);

    return 0;
}

2.4.2 字符串輸入

#include <stdio.h>

int main() {
    char name[15];
    printf("請輸入姓名:");
    scanf("%s", name); // 不是修改name，給分別給name的元素賦值
    // scanf("%s", &name[0]);
    printf("name = %s\n", name);

    return 0;
}

2.4.3 字符指針

字符指針可直接賦值為字符串，保存的實際上是字符串的首地址
此時，字符串指針所指向的內存不能修改，指針變量本身可以修改

#include <stdio.h>

int main() {
    char s1[] = "abc"; // 雙引號，默認隱藏了結束符
    //           012
    // char s2[] = {'a', 'b', 'c', '\0'}; // s1和s2等價，不同的寫法
    // 保存首元素地址，首元素是char，需要char *
    char * p = s1; // char * p = &s1[0];  // 指向數組首元素，數組的元素本身可以改的，也可以通過指針間接修改
    p[0] = 'x';
    printf("s1 = %s\n", s1);

    // 字符指針 可以 直接指向字符串，字符串本身是常量，不可以通過指針間接修改字符串的元素
    char * p2 = "hello";
    //           0
    // p2[0] = 'x'; // err
    printf("p2 = %s\n", p2);

    return 0;
}

2.4.4 字符串常用庫函數

功能，參數，返回值

strlen

功能：計算字符串的長度（不包含末尾的終止符 '\0'）。
參數：const char *str（指向待計算長度的字符串的指針）。
返回值：size_t（無符號整數，表示字符串中字符的個數）。

#include <string.h>
char str[] = "hello";
printf("%zu", strlen(str));  // 輸出：5（不含'\0'）

strcpy

功能：將源字符串（包括 '\0'）複製到目標字符串。
參數：
- char *dest（指向目標字符串的指針）
- const char *src（指向源字符串的指針）
返回值：char *（指向目標字符串 dest 的指針）。
注意：需確保目標字符串有足夠空間，否則會導致緩衝區溢出。

char dest[20];
char src[] = "world";
strcpy(dest, src);  // dest 變為 "world"（包含'\0'）

strcat

功能：將源字符串追加到目標字符串的末尾（覆蓋目標字符串原有的 '\0'，並在新字符串末尾添加 '\0'）。
參數：
- char *dest（指向目標字符串的指針）
- const char *src（指向源字符串的指針）
返回值：char *（指向目標字符串 dest 的指針）。
注意：需確保目標字符串有足夠空間容納拼接後的結果。

char dest[20] = "hello";
char src[] = "world";
strcat(dest, src);  // dest 變為 "helloworld"

strcmp

功能：比較兩個字符串（按 ASCII 碼值逐個字符比較）。
參數：
- const char *str1（指向第一個字符串的指針）
- const char *str2（指向第二個字符串的指針）
返回值：
- 若 str1 > str2：返回正整數
- 若 str1 == str2：返回 0
- 若 str1 < str2：返回負整數

printf("%d", strcmp("apple", "banana"));  // 輸出負數（'a' < 'b'）
printf("%d", strcmp("hello", "hello"));   // 輸出 0（相等）

2.4.5 字符串案例

需求：自定義一個函數my_strlen()，實現的功能和strlen一樣

實現思路：

遍歷字符串，從首字符開始計數
遇到終止符 '\0' 時停止計數
返回計數結果

#include <stdio.h>

// 自定義字符串長度計算函數
size_t my_strlen(const char *str) {
    size_t len = 0;  // 計數器，初始化為0
    
    // 遍歷字符串，直到遇到'\0'
    while (str[len] != '\0') {
        len++;  // 每多一個字符，長度+1
    }
    
    return len;  // 返回計算的長度
}

// 測試函數
int main() {
    char str1[] = "hello world";
    char str2[] = "";  // 空字符串
    char str3[] = "a";
    
    printf("my_strlen(\"%s\") = %zu\n", str1, my_strlen(str1));  // 輸出：11
    printf("my_strlen(\"%s\") = %zu\n", str2, my_strlen(str2));  // 輸出：0
    printf("my_strlen(\"%s\") = %zu\n", str3, my_strlen(str3));  // 輸出：1
    
    return 0;
}

三、結構體

在 C 語言中，結構體是一種自定義用户自定義數據類型，允許將不同類型的數據組合成一個整體，用於表示具有多個相關屬性的複雜對象（如學生、書籍、座標等）。

struct 結構體名 {
    數據類型 成員名1;
    數據類型 成員名2;
    // ... 更多成員
};

3.1 結構體的使用

#include <stdio.h>

// 結構體：複合類型(多個類型的集合)，自定義類型
// 類型定義  struct  結構體名字
// struct Student 合在一起，才是類型
struct Student{
    char name[30];
    int age;
    char sex;
};

int main() {
    // 結構體類型  變量
    struct Student s = {"mike", 18, 'm'};  // 初始化
    // 如果是普通變量  用. 訪問成員
    printf("%s, %d, %c\n", s.name, s.age, s.sex);
    // 如果是指針變量，用->訪問成員
    struct Student * p;
    p = &s;
    printf("%s, %d, %c\n", p->name, p->age, p->sex);

    return 0;
}

3.2 結構體值傳參

傳值是指將參數的值拷貝一份傳遞給函數，函數內部對該參數的修改不會影響到原來的變量

#include <stdio.h>
#include <string.h> // strcpy()

struct Student{
    char name[30];
    int age;
    char sex;
};

void func(struct Student s) {
    strcpy(s.name, "tom");
    s.age = 22;
    s.sex = 'm';
    printf("函數裏面：%s, %d, %c\n", s.name, s.age, s.sex);
}

int main() {
    // 結構體類型   變量
    struct Student s = {"mike", 18, 'm'};
    // 通過一個函數，修改成員
    func(s); // 傳遞是變量本身，沒有加&，叫值傳遞
    printf("調用函數後：%s, %d, %c\n", s.name, s.age, s.sex);

    return 0;
}

3.3 結構體地址傳遞

傳址是指將參數的地址傳遞給函數，函數內部可以通過該地址來訪問原變量，並對其進行修改。

#include <stdio.h>
#include <string.h> // strcpy()

struct Student{
    char name[30];
    int age;
    char sex;
};

void func(struct Student * p) {
    strcpy(p->name, "tom");
    p->age = 22;
    p->sex = 'm';
    printf("函數裏面：%s, %d, %c\n", p->name, p->age, p->sex);
}

int main() {
    // 結構體類型   變量
    struct Student s = {"mike", 18, 'm'};
    // 通過一個函數，修改成員
    func(&s); // 傳遞是變量加&，叫地址傳遞
    printf("調用函數後：%s, %d, %c\n", s.name, s.age, s.sex);

    return 0;
}

c , c# , 知識