如何動態分配結構數組？

我該如何動態地爲軌道分配一個結構數組，以便我可以通過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

如何動態分配結構數組？

回答

相關問題