You've tagged this as C++ as well as C.

If you're using C++ things are a lot easier. The standard template library has a template called vector which allows you to dynamically build up a list of objects.

#include <stdio.h>
#include <vector>

typedef std::vector<char*> words;

int main(int argc, char** argv) {

        words myWords;

        myWords.push_back("Hello");
        myWords.push_back("World");

        words::iterator iter;
        for (iter = myWords.begin(); iter != myWords.end(); ++iter) {
                printf("%s ", *iter);
        }

        return 0;
}

If you're using C things are a lot harder, yes malloc, realloc and free are the tools to help you. You might want to consider using a linked list data structure instead. These are generally easier to grow but don't facilitate random access as easily.

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

typedef struct s_words {
        char* str;
        struct s_words* next;
} words;

words* create_words(char* word) {
        words* newWords = malloc(sizeof(words));
        if (NULL != newWords){
                newWords->str = word;
                newWords->next = NULL;
        }
        return newWords;
}

void delete_words(words* oldWords) {
        if (NULL != oldWords->next) {
                delete_words(oldWords->next);
        }
        free(oldWords);
}

words* add_word(words* wordList, char* word) {
        words* newWords = create_words(word);
        if (NULL != newWords) {
                newWords->next = wordList;
        }
        return newWords;
}

int main(int argc, char** argv) {

        words* myWords = create_words("Hello");
        myWords = add_word(myWords, "World");

        words* iter;
        for (iter = myWords; NULL != iter; iter = iter->next) {
                printf("%s ", iter->str);
        }
        delete_words(myWords);
        return 0;
}

Yikes, sorry for the worlds longest answer. So WRT to the "don't want to use a linked list comment":

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

typedef struct {
    char** words;
    size_t nWords;
    size_t size;
    size_t block_size;
} word_list;

word_list* create_word_list(size_t block_size) {
    word_list* pWordList = malloc(sizeof(word_list));
    if (NULL != pWordList) {
        pWordList->nWords = 0;
        pWordList->size = block_size;
        pWordList->block_size = block_size;
        pWordList->words = malloc(sizeof(char*)*block_size);
        if (NULL == pWordList->words) {
            free(pWordList);
            return NULL;    
        }
    }
    return pWordList;
}

void delete_word_list(word_list* pWordList) {
    free(pWordList->words);
    free(pWordList);
}

int add_word_to_word_list(word_list* pWordList, char* word) {
    size_t nWords = pWordList->nWords;
    if (nWords >= pWordList->size) {
        size_t newSize = pWordList->size + pWordList->block_size;
        void* newWords = realloc(pWordList->words, sizeof(char*)*newSize); 
        if (NULL == newWords) {
            return 0;
        } else {    
            pWordList->size = newSize;
            pWordList->words = (char**)newWords;
        }

    }

    pWordList->words[nWords] = word;
    ++pWordList->nWords;


    return 1;
}

char** word_list_start(word_list* pWordList) {
        return pWordList->words;
}

char** word_list_end(word_list* pWordList) {
        return &pWordList->words[pWordList->nWords];
}

int main(int argc, char** argv) {

        word_list* myWords = create_word_list(2);
        add_word_to_word_list(myWords, "Hello");
        add_word_to_word_list(myWords, "World");
        add_word_to_word_list(myWords, "Goodbye");

        char** iter;
        for (iter = word_list_start(myWords); iter != word_list_end(myWords); ++iter) {
                printf("%s ", *iter);
        }

        delete_word_list(myWords);

        return 0;
}

Right now, each of your albums has a single track, and the track name is expected to be a single character, instead of what you probably want, a character array.

You're already allocating your albums correctly, but you need to allocate the tracks of each album, too.

The simplest way to do this would be to just specify a fixed number of tracks as a maximum, and just make sure your other code doesn't exceed that.

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

Alternatively, you could dynamically allocate the tracks and the track names to the exact sizes needed if you had that information handy. For example, say you were just making a copy of an existing array of albums:

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

If you are using pointer to read and print the struct values then no need of array.If you are trying to use array then this is the way to do it.

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

    int main (void)
    {
       struct student  
       {   
          char initial [21];
          int age;
          float id; 
          char grade [3];
       } list[5];

       struct student *tag = ( struct student * ) malloc ( sizeof ( struct student ) * 5);

       int i;
       for(i=0;i<5;i++)
       {   
          printf("Enter the student initial\n");
          scanf("%s",list[i].initial);
          printf("Enter the student age\n");
          scanf("%d",&list[i].age);
          printf("Enter the student id\n");
          scanf("%f",&list[i].id);
          printf("Enter the grade\n");
          scanf("%s",list[i].grade);
          tag++;
       }   

       int n;

       for ( n = 0; n < 5; n++ ) { 
          printf ( "%s is %d, id is %f, grade is %s \n", 
                list [ n ].initial, list [ n ].age, list [ n ].id, list [ n ].grade);
       }   

       return 0;

    }

The way you have it written now , used to be called the "struct hack", until C99 blessed it as a "flexible array member". The reason you're getting an error (probably anyway) is that it needs to be followed by a semicolon:

#include <stdlib.h>

struct my_struct {
    int n;
    char s[];
};

When you allocate space for this, you want to allocate the size of the struct plus the amount of space you want for the array:

struct my_struct *s = malloc(sizeof(struct my_struct) + 50);

In this case, the flexible array member is an array of char, and sizeof(char)==1, so you don't need to multiply by its size, but just like any other malloc you'd need to if it was an array of some other type:

struct dyn_array { 
    int size;
    int data[];
};

struct dyn_array* my_array = malloc(sizeof(struct dyn_array) + 100 * sizeof(int));

Edit: This gives a different result from changing the member to a pointer. In that case, you (normally) need two separate allocations, one for the struct itself, and one for the "extra" data to be pointed to by the pointer. Using a flexible array member you can allocate all the data in a single block.

Please see comments below in the code

 // Some includes here - stdlib stdio

// This is needed for getDog
 struct Dog  {
    char name[21]; 
    double age;
    double weight;
 };
    

void getDog( FILE *fp, struct Dog *dgy ) 
{
//    char dogName[21]; Not required
//    double dogAge;
//    double dogWeight;

  // Check return value - ensure no buffer overrun
    if (fscanf(fp, "%20s%lf%lf", dgy->name, &dgy->age, &dgy->weight) != 3) {
       // Got an error - do summat about it
    }
//    strcpy(, dogName);  - Not required as fscanf does this for you
//    dgy->age = dogAge;
//    dgy->weight = dogWeight;
}

int main( int argc, char *argv[] )
{

    FILE *fp = fopen( argv[ 1 ], "r" );
    
// Is fp == NULL - if so error do summat about this
    // read in number of dogs
    int n;
    if ( fscanf( fp, "%d", &n ) != 1 ) {  // What is the point of || n < 1 ?
        invalidInput();
       // No point continuing to rest of code!
    }

    struct Dog *dgy = malloc(n * sizeof(struct Dog)); // Link below

    for (int i = 0; i < n; i++ ) {
        getDog(fp, dgy + i);
    }
    
    fclose(fp);
}

• See Do I cast the result of malloc?