構造体配列を動的に割り当てる方法は？

Question

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; 
    }; 

Answer 1

右現在、各アルバムには1つのトラックがあり、トラック名は1つの文字になる予定です。おそらくあなたが望むもの、すなわち文字配列のnstead。

既にアルバムを正しく割り当てていますが、各アルバムのトラックも割り当てる必要があります。

これを行う最も簡単な方法は、固定数のトラックを最大値として指定し、他のコードがそれを超えないようにすることです。

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; 
} 

Answer 2

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); 

は、アルバムごとの固定最大20台のトラックとアルバムnumber_of_albums時間を割り当てます。

Answer 3

いくつかの選択肢があります。タイトルの動的な文字列対タイトル

1. 修正の最大の長さの文字列は：

   enum { MAX_TITLE_LENGTH = 32 }; 
   typedef struct tracks 
   { 
       char tracks_title[MAX_TITLE_LENGTH]; 
       int playlist_hits; 
   } tracks; 
   

   対

   typedef struct tracks 
   { 
       char *tracks_title; 
       int playlist_hits; 
   } tracks; 
   

   最初はトラックの割り当ては単純、と単純にリリースになりますが、トラブルの場合に実行されますあなたの最大の長さよりも長いトラックタイトルが見つかりました。また、ショートトラックのタイトルが多い場合は、代わりにスペースを無駄にする可能性があります。

2. アルバムの場合、アルバムごとにトラックの固定サイズの配列、またはポインタまたは 'フレキシブルな配列メンバー'を使用する必要があります（または、1999年以前のコンパイラがついている場合は、 'struct hack'を使う必要があります）。

   enum { MAX_TRACKS_PER_ALBUM = 32 }; 
   typedef struct album 
   { 
       int  num_tracks; 
       tracks tracks[MAX_TRACKS_PER_ALBUM]; 
   } album; 
   

   typedef struct album 
   { 
       int  num_tracks; 
       tracks tracks[]; 
   } album; 
   

   対

   typedef struct album 
   { 
       int  num_tracks; 
       tracks *tracks; 
   } album; 
   

   対最後には、限り、あなたはそれらの配列を望んでいないとして使用することが非常に簡単です。 （フレキシブルなアレイメンバーでアルバムポインタの配列を使用することもできます。）

   album *all_albums = (album *)malloc(sizeof(album) * number_of_albums); 
   

   しかし、あなたはmalloc()がそうしないので（アルバム構造を初期化する必要があります、そして：）あなたは、ポインタのバージョンでオフおそらく最高です、アルバムの配列をしたいを行うことを考えますアルバムごとに適切なトラック数を割り当てる必要があります。