程式師世界 >> 編程語言 >> C語言 >> 關於C語言 >> 不可或缺 Windows Native (8)，windowsnative

不可或缺 Windows Native (8)，windowsnative

編輯：關於C語言

不可或缺 Windows Native (8)，windowsnative

[源碼下載]

不可或缺 Windows Native (8) - C 語言: 結構體，共用體，枚舉，類型定義符

作者：webabcd

介紹
不可或缺 Windows Native 之 C 語言

結構體
共用體
枚舉
類型定義符

示例
cStruct.h

#ifndef _MYHEAD_STRUCT_
#define _MYHEAD_STRUCT_ 

#ifdef __cplusplus  
extern "C"
#endif  

char *demo_cStruct();

#endif

cStruct.c

/*
 * 結構體，共用體，枚舉，類型定義符
 *
 * 注：結構體變量在做參數傳遞時，其內每個成員都會被傳遞，會降低效率。所以一般通過結構體指針傳遞
 */


#include "pch.h"
#include "cStruct.h"
#include "cHelper.h"


void struct_demo1();
void struct_demo2();
void struct_demo3();
void struct_demo4();

void union_demo();

void enum_demo1();

void typedef_demo1();


// 定義一個名為 birth 的結構體類型
/*
 * struct 結構名
 * {
 *     成員表列
 * };
 */
struct birth
{
    int year; // 結構體成員
    int month; // 結構體成員
    int day; // 結構體成員
};


char *demo_cStruct()
{
    // 結構體基礎 1
    struct_demo1();

    // 結構體基礎 2
    struct_demo2();

    // 結構體指針（指向結構體變量的指針）
    struct_demo3();

    // 結構體數組
    struct_demo4();


    // 共用體（聯合體）
    union_demo();


    // 枚舉
    enum_demo1();


    // 類型定義符
    typedef_demo1();


    return "看代碼及注釋吧";
}


// 結構體基礎 1
void struct_demo1()
{
    // 定義一個名為 employee 的結構體類型
    struct employee
    {
        int num; // 結構體成員
        char *name = "unknown"; // 結構體成員，可以為其設置默認值
        float sarlary; // 結構體成員
        struct birth birthday; // 結構體成員，可以是另一個結構體
    };

    // 聲明一個 employee 類型的結構體
    struct employee employee1;

    // 為結構體賦值（訪問結構體成員通過“.”來實現）
    employee1.num = 100;
    employee1.name = "webabcd";
    employee1.sarlary = 100.5f;
    employee1.birthday.year = 1980;
    employee1.birthday.month = 2;
    employee1.birthday.day = 14;

    // 占用內存空間為 24 字節
    int size = sizeof(struct employee);
}


// 結構體基礎 2
void struct_demo2()
{
// 常用的結構體類型可以用宏定義來表示（也可以用 typedef, 後面再說）
#define EMPLOYEE struct employee
    EMPLOYEE
    {
        int num;
        char *name;
    } employee1, employee2 = { 100, "webabcd" }; // 聲明結構體變量的時候就可以對其初始化
    EMPLOYEE employee3 = { 100, "webabcd" };


    // 在定義結構體類型的時候，就聲明變量的話，可以省去結構體名
    struct
    {
        int num;
        char *name;
    } employee4, employee5 = { 100, "webabcd" }; // 聲明結構體變量的時候就可以對其初始化


    // 相同類型的結構體是可以互相賦值的，其成員無論是基本類型還是指針都會復制出一份新的
    employee1 = employee2;
    employee2.num = 99;
    employee2.name = "wanglei";
    // 結果：employee1（num=100, name="webabcd"）, employee2（num=99, name="wanglei"）
}


// 結構體指針（指向結構體變量的指針）
void struct_demo3()
{
    struct employee
    {
        int num;
        char *name;
    };

    struct employee employee1 = { 100, "webabcd" };
    
    // 定義一個結構體指針（指向結構體變量的指針）
    struct employee *employee = &employee1;

    char *name = employee1.name;

    // (*employee) - 是結構體指針所指向的結構體內容
    name = (*employee).name;

    // 如果通過結構體指針訪問結構體指針所指向的結構體的成員的話，通過“->”來實現
    name = employee->name;
}


// 結構體數組
void struct_demo4()
{
    struct employee
    {
        int num;
        char *name;
    };

    // 定義一個結構體數組
    struct employee employees[2] =
    {
        { 100, "webabcd" },
        { 200, "wanglei" }
    };

    // 結構體數組和指針的關系，與一般數組和指針的關系是一樣的
    struct employee *employee1 = employees;
    struct employee *employee2 = &employees[0];
}


// 共用體（聯合體）
void union_demo()
{
    // 所謂共用體，就是讓幾個變量共用一個內存空間，共用體占用空間大小為該共用體最大基本類型成員的整倍數，且大小要正好包含住共用體最大類型成員
    // 注：以下如果有列出結果的，均為我的環境的結果。比如我這裡 int 是占用 4 個字節的

    union u // 占用 4 個字節（a 占用 4 個字節，b 占用 4 個字節，由於他們共用一個內存空間，所以這個共用體占用 4 個字節）
    {
        int a;
        int b;
    } u1;

    u1.a = 1;
    u1.b++;
    // 上面執行後的結果是 u1.a 等於 2，u1.b 等於 2，因為他們是共用一個內存空間



    union // 占用 12 個字節（a 占用 4 個字節，b 占用 10 個字節，該共用體最大基本類型為 int，它占 4 個字節，以它來對齊，則這個共用體占用 12 個字節）
    {
        int a; // 共用體最大基本類型成員
        char s[10]; // 共用體最大類型成員
    } u2;

    u2.a = 0x61626364; // abcd
    char s1 = u2.s[0]; // d
    char s2 = u2.s[0]; // c
    char s3 = u2.s[0]; // b
    char s4 = u2.s[0]; // a
    // 由上可見，我的 cpu 是小端模式，即高地址存高字節，低地址存低字節
    // 注：網絡字節順序是按大端模式，即高位數據存放在低位地址（可以通過 ntohs, ntohl, htons, htonl 做轉換）
}


// 枚舉
void enum_demo1()
{
    /*
     * enum 枚舉名
     * {
     *     枚舉值表
     * };
     */

    // 定義一個名為 weekday 的枚舉類型
    enum weekday
    {
        sun, mon, tue, wed, thu, fri, sat
    } a, b, c = fri; // 聲明並初始化枚舉變量

    // 聲明一個 weekday 類型的枚舉變量，並初始化
    weekday d = sat; // 枚舉值不是字符串呦

    // 判斷一個枚舉值的話，可以用枚舉值或枚舉值索引
    if (d == sat && d == 6)
    {
        // 用枚舉值索引復制枚舉值時，需要強制類型轉換
        weekday e = (enum weekday)3; // wed
    }
    

    // 在定義枚舉類型的時候，就聲明變量的話，可以省去枚舉名
    enum
    {
        v1, v2, v3
    } e1, e2, e3 = v3;
}


// 類型定義符
void typedef_demo1()
{
    // typedef - 類型定義符


    // INTEGER 類型就是 int 類型
    typedef int INTEGER;
    INTEGER a, b;

    // INTP 類型就是指向 int 類型的指針
    typedef int* INTP;

    // NAME 類型就是長度為 20 的 char 數組
    typedef char NAME[20];
    NAME a1, a2;

    // STR 類型就是 char 指針
    typedef char *STR;
    STR s1, s2;

    // EMP 類型就是 struct employee 結構體
    typedef struct employee
    {
        int num;
        char *name;
    } EMP;
    EMP emp1 = { 100, "webabcd" };


    // 注：宏定義是字符串替換，typedef 是類型替換；宏定義是由預處理完成的，typedef 則是在編譯時完成的
}

OK
[源碼下載]