นิยามโครงสร้างอ้างอิงตนเอง?

ฉันไม่ได้เขียน C มานานมากแล้วดังนั้นฉันจึงไม่แน่ใจว่าฉันควรจะทำสิ่งที่เรียกซ้ำเหล่านี้อย่างไร ... ฉันต้องการให้แต่ละเซลล์มีเซลล์อื่น แต่ฉันได้รับข้อผิดพลาด บรรทัด "field" child "มีประเภทที่ไม่สมบูรณ์" ว่าไง?

typedef struct Cell {
  int isParent;
  Cell child;
} Cell;

เห็นได้ชัดว่าเซลล์ไม่สามารถมีเซลล์อื่นได้เนื่องจากจะกลายเป็นการเรียกซ้ำที่ไม่มีวันสิ้นสุด

อย่างไรก็ตามเซลล์สามารถมีตัวชี้ไปยังเซลล์อื่นได้

typedef struct Cell {
  bool isParent;
  struct Cell* child;
} Cell;

ในภาษา C คุณไม่สามารถอ้างอิง typedef ที่คุณสร้างขึ้นโดยใช้โครงสร้างเอง คุณต้องใช้ชื่อโครงสร้างเช่นเดียวกับในโปรแกรมทดสอบต่อไปนี้:

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

typedef struct Cell {
  int cellSeq;
  struct Cell* next; /* 'tCell *next' will not work here */
} tCell;

int main(void) {
    int i;
    tCell *curr;
    tCell *first;
    tCell *last;

    /* Construct linked list, 100 down to 80. */

    first = malloc (sizeof (tCell));
    last = first;
    first->cellSeq = 100;
    first->next = NULL;
    for (i = 0; i < 20; i++) {
        curr = malloc (sizeof (tCell));
        curr->cellSeq = last->cellSeq - 1;
        curr->next = NULL;
        last->next = curr;
        last = curr;
    }

    /* Walk the list, printing sequence numbers. */

    curr = first;
    while (curr != NULL) {
        printf ("Sequence = %d\n", curr->cellSeq);
        curr = curr->next;
    }

    return 0;
}

แม้ว่ามันอาจจะซับซ้อนกว่านี้มากในมาตรฐาน แต่คุณสามารถคิดว่ามันเป็นคอมไพเลอร์ที่รู้เกี่ยวกับstruct Cellบรรทัดแรกของบรรทัดtypedefแต่ไม่รู้เรื่องtCellจนถึงบรรทัดสุดท้าย :-) นั่นคือสิ่งที่ฉันจำกฎนั้นได้

จากมุมมองทางทฤษฎีภาษาสามารถรองรับเฉพาะโครงสร้างอ้างอิงตัวเองเท่านั้นที่ไม่ใช่โครงสร้างแบบรวมตัวเอง

มีวิธีแก้ไขดังนี้:

struct Cell {
  bool isParent;
  struct Cell* child;
};

struct Cell;
typedef struct Cell Cell;

ถ้าคุณประกาศแบบนี้มันจะบอกคอมไพเลอร์อย่างถูกต้องว่า struct Cell และ plain-ol'-cell นั้นเหมือนกัน ดังนั้นคุณสามารถใช้ Cell ได้เหมือนปกติ ยังคงต้องใช้ struct Cell ภายในการประกาศครั้งแรกแม้ว่า

ฉันรู้ว่าโพสต์นี้เก่าอย่างไรก็ตามเพื่อให้ได้เอฟเฟกต์ที่คุณต้องการคุณอาจต้องลองทำสิ่งต่อไปนี้:

#define TAKE_ADVANTAGE

/* Forward declaration of "struct Cell" as type Cell. */
typedef struct Cell Cell;

#ifdef TAKE_ADVANTAGE
/*
   Define Cell structure taking advantage of forward declaration.
*/
struct Cell
{
   int isParent;
   Cell *child;
};

#else

/*
   Or...you could define it as other posters have mentioned without taking
   advantage of the forward declaration.
*/
struct Cell
{
   int isParent;
   struct Cell *child;
};

#endif

/*
    Some code here...
*/

/* Use the Cell type. */
Cell newCell;

ในสองกรณีที่กล่าวถึงในส่วนของโค้ดด้านบนคุณต้องประกาศโครงสร้างเซลล์ลูกของคุณเป็นตัวชี้ หากไม่ทำเช่นนั้นคุณจะได้รับข้อผิดพลาด "field" child "has not complete type" เหตุผลก็คือต้องมีการกำหนด "struct Cell" เพื่อให้คอมไพเลอร์ทราบว่าจะจัดสรรพื้นที่เท่าใดเมื่อถูกใช้งาน

หากคุณพยายามใช้ "struct Cell" ภายในคำจำกัดความของ "struct Cell" คอมไพเลอร์จะยังไม่สามารถทราบได้ว่า "struct Cell" ควรใช้พื้นที่เท่าใด อย่างไรก็ตามคอมไพเลอร์รู้อยู่แล้วว่าตัวชี้ใช้พื้นที่เท่าใดและ (ด้วยการประกาศไปข้างหน้า) ก็รู้ว่า "เซลล์" เป็น "โครงสร้างเซลล์" ชนิดหนึ่ง (แม้ว่าจะยังไม่รู้ว่า "เซลล์โครงสร้าง" มีขนาดใหญ่เพียงใด ). ดังนั้นคอมไพเลอร์สามารถกำหนด "Cell *" ภายในโครงสร้างที่กำลังกำหนด

อีกวิธีหนึ่งที่สะดวกคือการพิมพ์โครงสร้างล่วงหน้าด้วยแท็กโครงสร้างเป็น:

//declare new type 'Node', as same as struct tag
typedef struct Node Node;
//struct with structure tag 'Node'
struct Node
{
int data;
//pointer to structure with custom type as same as struct tag
Node *nextNode;
};
//another pointer of custom type 'Node', same as struct tag
Node *node;

มาดูนิยามพื้นฐานของ typedef typedef ใช้เพื่อกำหนดนามแฝงให้กับชนิดข้อมูลที่มีอยู่ไม่ว่าจะเป็นผู้ใช้กำหนดเองหรือ inbuilt

typedef <data_type> <alias>;

ตัวอย่างเช่น

typedef int scores;

scores team1 = 99;

ความสับสนในที่นี้เกิดขึ้นกับโครงสร้างการอ้างอิงตัวเองเนื่องจากสมาชิกของประเภทข้อมูลเดียวกันซึ่งไม่ได้กำหนดไว้ก่อนหน้านี้ ดังนั้นในวิธีมาตรฐานคุณสามารถเขียนโค้ดของคุณเป็น: -

//View 1
typedef struct{ bool isParent; struct Cell* child;} Cell;

//View 2
typedef struct{
  bool isParent;
  struct Cell* child;
} Cell;

//Other Available ways, define stucture and create typedef
struct Cell {
  bool isParent;
  struct Cell* child;
};

typedef struct Cell Cell;

แต่ตัวเลือกสุดท้ายจะเพิ่มบรรทัดและคำพิเศษบางคำโดยปกติเราไม่ต้องการทำ (เราขี้เกียจคุณรู้ไหม;)) ดังนั้นชอบ View 2

โครงสร้างที่มีการอ้างอิงถึงตัวมันเอง เหตุการณ์นี้เกิดขึ้นทั่วไปในโครงสร้างที่อธิบายโหนดสำหรับลิงค์ลิสต์ แต่ละโหนดต้องการการอ้างอิงไปยังโหนดถัดไปในห่วงโซ่

struct node
{
       int data;
       struct node *next; // <-self reference
};

คำตอบก่อนหน้านี้ดีมากฉันแค่คิดว่าจะให้ข้อมูลเชิงลึกว่าทำไมโครงสร้างจึงไม่มีอินสแตนซ์ประเภทของตัวเอง (ไม่ใช่ข้อมูลอ้างอิง)

สิ่งสำคัญอย่างยิ่งที่ต้องสังเกตว่าโครงสร้างเป็นประเภท 'ค่า' กล่าวคือมีค่าจริงดังนั้นเมื่อคุณประกาศโครงสร้างคอมไพเลอร์จะต้องตัดสินใจว่าจะจัดสรรหน่วยความจำให้กับอินสแตนซ์ของมันเท่าใดจึงจะส่งผ่านสมาชิกทั้งหมดและเพิ่ม เพิ่มหน่วยความจำเพื่อหาหน่วยความจำโอเวอร์ทั้งหมดของโครงสร้าง แต่ถ้าคอมไพเลอร์พบอินสแตนซ์ของโครงสร้างเดียวกันภายในสิ่งนี้จะเป็นความขัดแย้ง (กล่าวคือเพื่อให้ทราบว่าหน่วยความจำของโครงสร้าง A ใช้เวลาเท่าใดคุณต้องตัดสินใจว่าหน่วยความจำเท่าใด โครงสร้าง A ใช้เวลา!)

แต่ประเภทการอ้างอิงจะแตกต่างกันหากโครงสร้าง 'A' มี 'การอ้างอิง' ไปยังอินสแตนซ์ของประเภทของมันเองแม้ว่าเราจะยังไม่รู้ว่าหน่วยความจำถูกจัดสรรให้กับหน่วยความจำเท่าใด แต่เราก็รู้ว่าหน่วยความจำถูกจัดสรรให้กับหน่วยความจำเท่าใด ที่อยู่ (เช่นข้อมูลอ้างอิง)

HTH