如何动态分配结构数组？

我该如何动态地为轨道分配一个结构数组，以便我可以通过all_albums_p[i]访问它？我需要它可以通过all_albums_p [i]访问，因为我要返回all_albums_p。如何动态分配结构数组？

struct tracks_{ 
    char tracks_title; 
    int playlist_hits; 
}; 

struct album_ { 
    int num_tracks; 
    struct tracks_ tracks; 
}; 

typedef struct album_ album; 
typedef struct tracks_ tracks; 

album *all_albums_p = (album *)malloc(sizeof(album)*number_of_album);

** * ** * **我已经改变了* ** * ****

struct tracks_{ 
     char *tracks_title; 
     int *playlist_hits; 
    };

来源

2012-03-31 Learning C

'char track_title'几乎肯定是错的。 – 2012-03-31 19:52:55

你的代码已经是正确的解决方案，你可以使用'all_albums_p [i]'来访问数组 – thumbmunkeys 2012-03-31 19:53:19

如何为tracks_title中的字符串分配？ – 2012-03-31 19:54:28

权现在，您的每张专辑都有一首曲目，曲目名称预计为单个字符，即i除了你可能想要的，一个字符数组。

您已经正确地分配了您的专辑，但您也需要分配每个专辑的曲目。

最简单的方法是只指定一个固定数量的轨道作为最大值，并确保其他代码不超过该数量。

const int MAX_TRACKS = 20; 
const int MAX_HITS = 20; 
const int MAX_TRACK_NAME_LENGTH = 63; 

struct track_{ 
    char tracks_title[MAX_TRACK_NAME_LENGTH+1]; 
    int playlist_hits[MAX_HITS]; 
    int playlist_hits_count; 
}; 

struct album_ { 
    int num_tracks; 
    struct track_ tracks[MAX_TRACKS]; 
};

或者，您可以动态分配曲目和曲目名称到所需的确切大小，如果您拥有该信息便利。例如，假设你只是在做专辑的现有阵列的副本：

struct track_ { 
    char *track_title; 
    int *playlist_hits; 
    int playlist_hits_count; 
}; 

struct album_ { 
    int num_tracks; 
    struct track_ *tracks; 
}; 

typedef struct album_ album; 
typedef struct track_ track; 

album *copy_albums(album *all_albums_p, int number_of_album) { 
    album *all_albums_copy = (album *)malloc(sizeof(album) * number_of_album); 

    // copy each album 
    for (int album_i = 0; album_i < number_of_album; album_i++) { 
     album * current_album = all_albums_p + album_i; 
     album * copy_album = all_albums_copy + album_i; 

     copy_album->num_tracks = current_album->num_tracks; 
     copy_album->tracks = (track *)malloc(sizeof(track) * current_album->num_tracks); 

     // copy each track, and it's hits, and make a new copy of it's name 
     for (int track_i = 0; track_i < current_album->num_tracks; track_i++) { 
      track * current_track = current_album->tracks + track_i; 
      track * copy_track = copy_album->tracks + track_i; 

      copy_track->playlist_hits_count = current_track->playlist_hits_count; 
      copy_track->playlist_hits = (int *)malloc(sizeof(int) * current_track->playlist_hits_count); 
      memcpy(copy_track->playlist_hits, current_track->playlist_hits, current_track->playlist_hits_count * sizeof(int)); 

      copy_track->track_title = _strdup(current_track->track_title); 
     } 
    } 

    return all_albums_copy; 
}

来源

2012-03-31 19:59:16 fcrick

我无法使用标题的修正号码。我必须将其分配给我读取的大小。 – 2012-03-31 20:01:59

我添加了一些附加代码，可以告诉您如何动态分配所有内容。您应该能够使用从用户读入的数据做类似的事情。 – fcrick 2012-03-31 20:14:32

typedef struct tracks_{ 
    char tracks_title[101]; 
    int playlist_hits; 
} tracks; 

typedef struct album_ { 
    int num_tracks; 
    struct tracks_ tracks[20]; 
} album; 

album *all_albums_p = (album *)malloc(sizeof(album)*number_of_album);

将分配number_of_albums倍，每张专辑一个固定的最大20首曲目专辑。

来源

2012-03-31 20:03:35

你有一些选择。

为标题VS动态字符串为标题修复最大长度的字符串：
```
enum { MAX_TITLE_LENGTH = 32 }; 
typedef struct tracks 
{ 
    char tracks_title[MAX_TITLE_LENGTH]; 
    int playlist_hits; 
} tracks; 
```
VS
```
typedef struct tracks 
{ 
    char *tracks_title; 
    int playlist_hits; 
} tracks; 
```
首先让道分配简单，释放简单，但遇到麻烦，如果您会发现比您的最大音量更长的曲目标题。如果你有很多短小的曲目，它可能会浪费更多的空间。
对于专辑，您需要为每个专辑使用固定大小的曲目阵列，或者使用指针或“灵活数组成员”（或者，如果您坚持使用1999年以前的编译器，则可能会需要使用'struct hack'）。
```
enum { MAX_TRACKS_PER_ALBUM = 32 }; 
typedef struct album 
{ 
    int  num_tracks; 
    tracks tracks[MAX_TRACKS_PER_ALBUM]; 
} album; 
```
VS
```
typedef struct album 
{ 
    int  num_tracks; 
    tracks *tracks; 
} album; 
```
VS
```
typedef struct album 
{ 
    int  num_tracks; 
    tracks tracks[]; 
} album; 
```
最后很简单，只要你不希望他们的阵列来使用。（您可以使用灵活数组成员的相册指针阵列。）既然你做希望专辑的数组，你可能最好关闭与指针的版本：
```
album *all_albums = (album *)malloc(sizeof(album) * number_of_albums); 
```
但是，你需要初始化专辑结构（因为malloc()不会这么做），而且您需要为每个专辑分配适当数量的曲目。

来源

2012-03-31 20:07:55

如何动态分配结构数组？

回答

相关问题