結構內的結構：指向或不指向？

我想了解當涉及到在另一個結構內參考一個結構時，使用指標和值之間的區別。

我的意思是，我可以有這兩個宣告：

struct foo {
    int bar。
};

struct fred {
    struct foo barney; 
    struct foo *wilma; 

看來我可以從barney和wilma條目中獲得相同的行為，只要我在訪問它們時相應地取消參考。 barney的情況在直覺上感覺 "不對"，但我不能說為什么。

我是否只是依賴于某些 C 的未定義行為？如果不是，那么選擇一種風格而不是另一種風格的理由是什么呢？

下面的代碼顯示了我是如何得出兩種用例都是等價的結論的；clang和gcc都沒有抱怨什么。

#include <stdio.h>/span>
#include <stdlib.h>

struct a_number {
    int i;
};

struct s_w_ptr {
    struct a_number *n; 
};

struct s_w_val {
    struct a_number n; 
};

void store_via_ptr(struct s_w_ptr *swp, struct s_w_val *swv){
    struct a_number *i = malloc(sizeof(i))。
    i->i = 1;
    swp->n = i;
    swv->n = *i;
}

void store_via_val(struct s_w_ptr *swp，struct s_w_val *swv) {
    struct a_number j; 
    j.i = 2;
    swp->n = &j;
    swv->n = j;
}

int main（void） {

    struct s_w_ptr *swp = malloc（sizeof（swp））。
    struct s_w_val *swv = malloc（sizeof（swv））。

    store_via_ptr(swp, swv)。
    printf("p: %d | v: %d
", swp->n->i, swv->n.i）。)

    store_via_val(swp, swv);
    printf（"p: %d | v: %d
", swp->n->i, swv->n.i）。)
}

uj5u.com熱心網友回復：

在一個結構中同時擁有結構成員和在一個結構中擁有指向結構的指標是完全有效的。它們必須以不同的方式使用，但都是合法的。

為什么要在結構中設定結構？

一個原因是將事物組合在一起。例如：

struct car
{
    struct motor motor; //一個有多個成員描述馬達的結構 
    struct wheel wheel; //一個有多個成員描述車輪的結構。
    ...
}

struct car myCar = {....initializer...}。

myCar.wheel = SomeOtherWheelModel; // 替換車輪的單一賦值。
myCar.wheel.pressure = 2.1; //改變單個車輪成員。

為什么要在一個結構中設定一個結構指標？

一個非常明顯的原因是，通過使用N倍于結構大小的動態分配，可以作為N個結構的陣列。

另一個典型的例子是鏈接串列，你有一個指向與包含指標的結構型別相同的結構的指標。

uj5u.com熱心網友回復：

C結構可以用來分組相關的資料，例如一本書的標題、作者、分配的書號等等。但我們使用結構的大部分內容是在記憶體中創建資料結構（在 "結構 "一詞的不同意義上）。

考慮到這本書的作者有一個名字、一個出生日期、其他傳記資訊、一個他們寫過的書的串列，以及更多。我們可以在struct book中包括一個struct author，它將包含所有這些資訊。但是，如果作者寫了一百本書，我們可以有100份所有資訊的副本，每份結構書中都有一份。此外，我們不能用struct author繼續 "在結構中直接包含資料 "的模式，因為如果這些struct book成員也必須包含作者的struct author，那么它就不能為作者出版的每本書包含一個struct book--每個物件都必須包含自己。

更有效的做法是創建一個struct author，并讓該作者的每個struct book鏈接到他們的struct author。

另一個例子是，我們使用指標來創建資料結構，以實作對資料的有效訪問。如果我們正在讀取數千個專案的資料，并希望按名稱對它們進行排序，那么一種選擇是為一些結構分配記憶體，讀取資料，并對資料進行排序。當新的資料被讀取并且我們已經用完了我們分配的所有記憶體時，我們分配新的記憶體，如果有必要的話，將所有的舊資料復制到新的記憶體中，并移動一些資料，這樣我們就可以在適當的位置插入新資料。然而，我們有許多比這更好的選擇。我們可以使用鏈接串列、二進制樹、其他種類的樹和哈希表。

這些資料結構實際上需要使用指標。二叉樹將有一個根節點，每個節點包含兩個指標，一個指向排序順序比它早的節點子樹，另一個指向比它晚的節點子樹。我們可以通過跟蹤指向較早或較晚的節點的指標來查找樹中的專案，從而找到正確的位置。我們還可以通過改變一些指標來插入專案。如果樹剛好變得不平衡，我們可以通過改變指標重新排列樹中的節點。節點中的大部分資料不需要改變或復制，只需要改變一些指標。

我們還可以使用指標來為同一資料建立多個結構。所有關于書籍的資料都可以存盤在一個地方，一棵按名字排序的樹可以包含節點，其中每個節點包含一個指向書籍結構的指標和兩個指向子樹的指標。我們可以有一棵這樣的樹，按書名排序，另一棵按作者姓名排序，還有一棵按指定書號排序。然后我們就可以有效地按書名、作者或書號來查詢一本書，但完整的圖書資料只有一個主副本，在struct book物件中。查詢的資料在樹中，它只包含指標。這比為每棵樹復制所有的 struct book 資料要有效得多。

因此，我們在使用結構或指標作為成員之間進行選擇的原因并不是 C 語法是否允許我們參考資料--我們在兩種情況下都可以獲得資料。原因是一種方法需要嵌入資料，這是不靈活的，需要復制資料，而另一種方法是靈活和高效的。

uj5u.com熱心網友回復：

在struct中擁有一個struct，而不是在struct中擁有一個struct的指標，有幾個好處：

1. 它需要更少的記憶體分配。
2. 它需要更少的記憶體分配。 在你在struct中擁有一個指向struct的指標的情況下，編譯器將分配記憶體以在父struct中存盤指向struct的指標，并且為子struct單獨分配記憶體。
3. 通常需要額外的指令來訪問子結構的內容。 例如，考慮到程式正在讀取子結構的內容。 如果使用struct內的struct，程式將對變數的地址應用一個偏移，并讀取該記憶體位置的內容。 在一個struct中的struct指標的情況下，程式實際上將對父struct變數地址應用一個偏移，獲取子struct的地址，然后從記憶體中讀取子struct的內容。
4. 需要為父代和子代結構宣告一個單獨的變數，如果使用一個初始化器，那么就需要一個單獨的初始化器。 在一個struct中的struct的情況下，只必須宣告一個變數，并且使用一個初始化器。
5. 在使用動態記憶體分配的情況下，開發者必須記住在變數超出范圍之前為子物件和父物件取消記憶體分配。 在struct中的struct的情況下，必須只為一個變數釋放記憶體。
。
6. 最后，正如例子中所示，如果使用了一個指標，可能需要進行Null檢查以確保指向子結構的指標已經被初始化。
7. 直接對子結構所做的任何更改都將影響父結構，如果不希望出現這種行為，這可能是一個問題。

在結構中擁有一個結構的主要優勢是如果你需要在程式中用另一個結構來替換子結構，例如一個鏈接串列。 一個不太常見的情況可能是，如果子結構可以是一個以上的型別。 在這種情況下，你可能為子程式使用一個void *型別。 我也可以在一個結構中使用一個指標來指向一個陣列，在這種情況下，所指向的陣列可能在不同的實體中大小不一。

根據我對上面的例子的了解，我傾向于在結構中使用結構，因為這兩個物件的大小和型別都是固定的，而且它們似乎不需要被分開。

uj5u.com熱心網友回復：

首先讓我們考慮一下這個函式

這個宣告

struct a_number *i = malloc(sizeof(i)) 。

等同于下面的宣告

所以一般來說，當sizeof( struct a_number )大于sizeof( struct a_number * )時，該函式可以呼叫未定義行為。

看來你的意思是

struct a_number *i = malloc(sizeof( *i ) ) 。
                                    ^^^ 

如果你將把這個函式分成兩個函式來處理它的每個引數，就像

void store_via_ptr1( struct s_w_ptr *swp ) /span>{
    struct a_number *i = malloc(sizeof( *i );
    i->i = 1;
    swp->n = i。
}

而且

void store_via_ptr( struct s_w_val *swv )/span> {
    struct a_number *i = malloc(sizeof( *i))。
    i->i = 1;
    swv->n = *i。
}

那么在第一個函式中，指標swp所指向的物件將需要記住在函式中釋放所分配的記憶體。否則就會出現記憶體泄漏。

第二個函式已經產生了記憶體泄漏。

第二個函式已經產生了一個記憶體泄漏，因為分配的記憶體沒有被釋放。

現在讓我們來討論一下這個問題。

現在讓我們來考慮第二個函式

void store_via_val（struct s_w_ptr *swp, struct s_w_val *swv） { struct a_number j; j.i = 2; swp->n = &j; swv->n = j; }

這里的指標swp->n將指向一個本地物件j。所以在退出函式后，這個指標將是無效的，因為被指向的物件將不存在。

所以這兩個函式都是不正確的。相反，你可以寫下面的函式

int store_via_ptr（struct s_w_ptr *swp ） {
    swp->n = malloc( sizeof( *swp->n ) 。)

    int success = swp->n != NULL;

    if ( success ) swp->n->i = 1;

    return success;
}

而且

void store_via_val( struct s_w_val *swv )/span> {
    swv->n.i = 2;
}

何時將一個結構型別的整個物件包含在另一個結構型別的物件中，或者在另一個結構型別的物件中使用一個結構型別物件的指標，取決于設計和使用這些物件的環境。

例如，考慮一個結構體Point

struct Point
{
    int x;
    int y;
};

在這種情況下，如果你想宣告一個結構體Rectangle，那么自然要像這樣定義它

另一方面，如果你有一個兩邊單鏈的串列，那么它可以看起來像

struct Node { int值。 struct Node *next; /span> }; struct List { struct Node *head; struct Node *tail;/span> };

uj5u.com熱心網友回復：

兩個問題：

1. 在store_via_ptr中，你為i動態地分配了記憶體。當你使用s_w_val時，你復制了該結構，然后留下指標。這意味著該指標將丟失，并且不能在以后傳遞給free。

2. 在store_via_val中，你讓swp->n指向local變數j。這個變數的生命期將在函式回傳時結束，留給你的是一個無效的指標。

第一個問題可能會導致記憶體泄漏（在你的簡單例子問題中，你從不關心這個問題）。

第二個問題更糟糕，因為它將導致未定義的行為當你解除對指標swp->n的參考時。 <解釋一下

與此無關，在main函式中，你不需要為這些結構動態分配記憶體。你可以將它們定義為普通的結構物件，并在呼叫函式時使用指標到運算子&。

標籤：

上一篇：將指標設定為NULL可修復專案

下一篇：BiometricPrompt.Authenticate()不等待用戶進行認證