Changing the size of a global array in the main function

Question

I am writing a program that needs to create a variable number of linked lists. The following is declared globally at the beginning of the program:

struct Node
{
    int Line;
    struct Node *Next;
} ;

struct Node* Heads[5];
struct Node* Currs[5]; 

int NumOfNames;

The first function in main() will calculate and store a value for NumOfNames. I then need the size of Heads[5] and Currs[5] to be changed to Heads[NumOfNames] and Currs[NumOfNames] in order to create NumOfNames amount of linked lists. Can anything along these lines be done?

I am quite new to programming and my knowledge of malloc and realloc is very poor, but I think I somehow need to use these functions in order to achieve my goal.

Thank you for any advice in advance.

You cannot have globally declared arrays with variable length. Therefore you definitely need to use `malloc` and friends. — Jabberwocky, May 05 '15 at 12:03
@MichaelWalz So if I understand correctly, when I globally declare `Heads` and `Currs`, memory is being allocated to them. Then, once `NumOfNames` has been calcluated I need to use `realloc` in order to reallocate enough memory for each of the arrays to be of size `NumOfNames`? — KOB, May 05 '15 at 12:06
`Heads` is an array, not a pointer. You cannot invoke `realloc` on an array. — William Pursell, May 05 '15 at 12:09

Jabberwocky · Answer 1 · 2015-05-05T12:19:03.793

3

You need this:

struct Node
{
    int Line;
    struct Node *Next;
} ;

struct Node** Heads;
struct Node** Currs; 
int NumOfNames ;

main()
{
  int NumOfNames = ... ; // calculate the number of names
  ...
  Heads = malloc(NumOfNames * sizeof (struct Node*));
  // now Heads point to an array of pointers to struct Node of length NumOfNames
  ...
  Heads[1] = malloc(sizeof (struct Node));
  ...
}

edited May 05 '15 at 12:19

answered May 05 '15 at 12:09

Jabberwocky

48,281
17
65
115

1

This example would be better if it also showed when and how to use realloc. – William Pursell May 05 '15 at 12:10
Thank you. Where you have `Heads[1] = malloc(sizeof (struct Node));`, does this same line need to be implemented for `Heads[1]` through to `Heads[NumOfNames]`? – KOB May 05 '15 at 12:11
@KOB yes. More precisely to `Heads[0]` to `Heads[NumOfNames - 1]` – Jabberwocky May 05 '15 at 12:12
@WilliamPursell not sure why we need `realloc` here. – Jabberwocky May 05 '15 at 12:14
Because the question is: 'how to change size?' – William Pursell May 05 '15 at 12:15
1

@WilliamPursell, ok but the "how to change size" is about changing the size of the statically allocated array, and as we don't have anymore statically allocated arrays, "changing" the size is pointless. – Jabberwocky May 05 '15 at 12:17

score 2 · Answer 2 · answered May 05 '15 at 12:12

Stop using static arrays, and allocate at runtime instead:

struct Node* Heads;
struct Node* Currs; 

Heads = malloc(NumOfNames * sizeof *Heads);
Currs = malloc(NumOfNames * sizeof *Currs);

Then you can access Heads[0] through Heads[NumOfNames - 1] (inclusive), assuming the allocations succeeded of course.

score 1 · Accepted Answer · edited May 23 '17 at 10:26

What you have there is static allocation and the memory is allocated on stack (actually not really on stack, since these are global variables - see the comments). It means that the size of the array needs to be known at compile time. On the other hand, you want to be able to allocate memory at run time since you don't know the size (NumOfNames) earlier. That is called dynamic allocation and you need malloc (or calloc,...) for that. Such memory is allocated on heap. For more information on this please read e.g. these:

To do what you want using malloc you can do this:

struct Node
{
    int Line;
    struct Node *Next;
} ;

struct Node** Heads;
struct Node** Currs; 

int NumOfNames;

int main() {
    // ...
    NumOfNames = 42;
    Heads = malloc(NumOfNames * sizeof(struct Node*));
    Currs = malloc(NumOfNames * sizeof(struct Node*));

    // if you want to allocate the Nodes too...
    int i;
    for (i = 0; i < NumOfNames; i++) {
        Heads[i] = malloc(sizeof(struct Node));
        Currs[i] = malloc(sizeof(struct Node));
    }
    // ...
}

When you allocate memory dynamically (using malloc, calloc, realloc,...), please be sure to free() it as well when you don't need it anymore.

In the OP's case the variables global variabls and therefore they are not on the stack. — Jabberwocky, May 05 '15 at 12:20
@MichaelWalz You are right. Global variables are not placed on a stack (but not on heap either). They're still allocated statically though. For further reading on global variables: http://stackoverflow.com/questions/1169858/global-memory-management-in-c-in-stack-or-heap — geckon, May 05 '15 at 12:24

score 1 · Answer 4 · edited May 23 '17 at 12:14

If you are allowed to use C99 (flag -std=c99 for gcc), then you have variable length arrays available. Here too.

// From the wikipedia page
float read_and_process(int n)
{
    float vals[n];

    for (int i = 0; i < n; i++)
        vals[i] = read_val();
    return process(vals, n);
}

Your Heads and Currs can then use a variable as size. On the other hand, you can't make them global, you'll have to pass pointers and sizes around to sub-functions.

Note also that if you are new to programming and C, the use of malloc and free is something you really want to learn.

Note also that VLA are not very popular, for example because they don't return errors if you don't have enough memory to allocate space for them, possibly resulting in hard to debug and dangerous problems.

I felt I had to write this alternative, but I also really think you should go for malloc and free, and learn how this is done. Check if malloc returned NULL and exit gracefully :)

Changing the size of a global array in the main function

4 Answers4