文章/答案/技术大牛

发布

社区首页 >问答首页 >初始化和访问C中另一个结构中的嵌套struct指针

问初始化和访问C中另一个结构中的嵌套struct指针
EN

Stack Overflow用户

提问于 2015-04-30 09:43:19

回答 3查看 1.1K关注 0票数 1

我的问题在于嵌套结构的初始化，然后添加到该结构中。我不知道如何正确地访问结构，甚至尝试初始化它。我可以用malloc初始化第一个struct char指针，但是当我尝试初始化嵌套的结构时，我可以使用：

Rooms[i].Connected[i].conncet_room.

有一个故障，我通常的错误是：

下标值既不是数组也不是指针。

这一行代码是：

Rooms[i].Connected[j].connect_room=(char*)malloc(sizeof(char*));

下面是我使用的代码：

typedef struct Connections
{
    char* connect_room; 
} Connections;

typedef struct ROOM
{
   char*  name;
   char*  event;
   int connect_id;
   Connections Connected;
} ROOM;


main(){
    // creates memory space for 6 rooms.
    int sizeOf=6; 
    ROOM* Rooms = malloc(sizeOf*sizeof *Rooms);

    int i,j;
    for(i=0;i<sizeOf;i++)
    {
        Rooms[i].name=(char*)malloc(sizeof(char*));
        Rooms[i].event=(char*)malloc(sizeof(char*));
        for(j=0;j<sizeOf,j++)
            Rooms[i].Connected[j].connect_room=(char*)malloc(sizeof(char*));
    }
}

strcpy( Rooms[0].name, "kitchen"); // This works
strcpy( Rooms[0].Connected[0].connect_room, "hallway"); // This doesn't works
strcpy( Rooms[0].Connected[1].connect_room, "deck"); // This doesn't works

重要的是，我希望这个结构是这样的：(下面是一个结构布局的例子，而不是代码)

 Rooms[0]
     name --> "bed_room"
     event --> "sleep"
     Connected[0]
         connection_room --> "bath_room"
     ...
     Connected[5]
         connection_room --> "hall_way"

每个房间将有一个名称和一个事件，然后它将有1-6 connection_rooms.

最后，一旦嵌套的结构被成功初始化。我将如何添加到.connect_room？

strcpy(Rooms[0].Connected[0].connect_room, "bath_room");

我和gcc一起编的

struct

char

arrays

pointers

回答 3

Stack Overflow用户

回答已采纳

发布于 2015-04-30 10:50:14

似乎您有一个固定数量的房间，您在运行时初始化。每个房间似乎也有最多的连接。在这种情况下，您不需要malloc任何东西。定义一个数组，并让连接成为指向该数组的指针。

C不擅长处理和查找字符串。(好的，它可以做得很好，但是字符串处理有点麻烦。)因此，让我们不要让Room连接字符串，而是指向其他房间的指针：

typedef struct Room Room;

#define MAX_CONN 6

struct Room {
   char *name;
   char *event;
   Room *conn[MAX_CONN];    // Connected rooms or NULL
};

这些连接最多是一个指向其他房间的MAX_CONN指针数组。未使用的插槽是NULL。(你甚至可以直接连接，因此这六个插槽指的是北、东、南、西、楼上和楼下的出口。)

由于我建议不要使用字符串作为标识手段，所以我们将使用房间数组条目的序号。裸露的数字有点不直观，所以让我们声明一个枚举值列表：

enum {
    Hallway,
    Bathroom,
    Bedroom,
    NRooms
};

这将房间名称声明为常量0、1和2，而NRooms是房间数3。

现在，房间数组声明：

int main()
{
    Room rooms[NRooms] = {
        [Hallway] = {
            .name = "Hallway", 
            .event = "loiter",
            .conn = {
                rooms + Bedroom,
                rooms + Bathroom
            }
        },
        [Bedroom] = {
            .name = "Bedroom", 
            .event = "sleep",
            .conn = {
                rooms + Hallway
            }

        },
        [Bathroom] = {
            .name = "Bathroom", 
            .event = "wash",
            .conn = {
                rooms + Hallway
            }

        }
    };

    room_print(&rooms[Hallway]);    // or: rooms + Hallway
    room_print(&rooms[Bedroom]);
    room_print(&rooms[Bathroom]);

    return 0;
}

数组被初始化。我在这里使用了指定首字母，这是一个C99特性，允许您显式地指定数组索引和结构成员名。这里有点过分，但如果您创建更多的空间并为您的房间结构添加更多的东西，它可能会很方便。(在本例中，一切都是按顺序初始化的，因此可以省略所需的初始化符，而只使用传统的位置初始化。)

表示法rooms + x使用指针算法在rooms数组中创建指向元素x的指针。表达式等效于&rooms[x]。

未显式初始化的数组元素和结构元素被初始化为零或空值。对于指针，这是NULL。

最后，将创建的数据结构付诸实践的room_print例程：

void room_print(const Room *room)
{
    int i;

    printf("This is the %s where you %s.\n",
        room->name, room->event);

    i = 0;
    while (i < MAX_CONN && room->conn[i]) {
        printf("A door leads to the %s.\n",
            room->conn[i]->name);
        i++;
    }

    printf("\n");
}

抱歉，有点冗长，因为您只询问了如何访问连接，但我认为这个示例显示了如何使用C初始化符来处理类似于您的结构示例布局的内容。

当然，数据在运行时仍然可以更改。没有什么能阻止你说：

room[Bathroom].name = "Private bathroom";
room[Bathroom].conn[1] = Bedroom;
room[Bedroom].conn[1] = Bathroom;

票数 0

Stack Overflow用户

发布于 2015-04-30 10:06:56

如果您希望每个房间都有1-6个Connections项目，您需要更改您的ROOM声明。您可以通过静态或动态分配来实现这一点。

静态分配

typedef struct ROOM
{
    char* name;
    char* event;
    int connect_id;
    Connections Connected[6];
} ROOM;

// Don't need code to dynamically allocate Connected
for (j = 0; j < 6, j++) {
    // 256 is max size of connect_room string
    Rooms[i].Connected[j].connect_room = malloc(sizeof(char)*256);
}

如果有，则不需要动态分配connect_room变量：

typedef struct Connections 
{
    char connect_room[256]; 
} Connections;

您也可以使用name和event的ROOM成员来完成这一任务。

也许您应该坚持静态分配，然后才能更好地适应动态分配。您必须考虑释放所有动态分配的内存。

动态分配

typedef struct ROOM
{
    char* name;
    char* event;
    int connect_id;
    Connections* Connected;
} ROOM;

// To dynamically allocate Connected for each room:
Rooms[i].Connected = malloc(sizeof(Connections)*6);
for (j = 0; j < 6, j++) {
    // 256 is max size of connect_room string
    Rooms[i].Connected[j].connect_room = malloc(sizeof(char)*256);
}