How do you change the size of a global array?

I've been trying to find the solution to this, but have been consistently coming up empty handed.

Say I have 2 global arrays, one of char and one of int

Code:

---

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

int intArray[]; // assumed to have 1 element
char charArray[]; // assumed to have 1 element

int main(void)
{
int newsize;
maxsize = findNewSize();
}

---

Is it possible to change the size of the arrays once I have calculated the max size? How exactly would this be done?

Thank you very much for any help.

No. But you can change your program to have global pointers to arrays, and malloc what you initially need, then realloc later on if they need to grow.

so I would have....

Code:

---

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

int *intArray[];
char *charArray[];

int main(void)
{
int newsize;
maxsize = findNewSize();
}

---

How would I use maxsize and realloc what I need?

My problem is that I don't know the size that I need the arrays until the program starts and I read data from an input file.

Here's some code to get you going, as an example. You can look up realloc to see how it works.

Code:

---

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

int * intArray ;
char * charArray ;

#define INITSIZE 5

int main(void)
{
        int newsize;
        intArray = malloc(INITSIZE * sizeof(int)) ;
        charArray = malloc(INITSIZE * sizeof(char)) ;
        .
        .
        .
        maxsize = findNewSize();
       
        return 0 ;
}

---

Just keep in mind that whatever you 'malloc'/'realloc' should be cleaned up with a call to 'free'.

Thank you very much, I'm gonna go ahead and mess around with this.

If an INITSIZE isn't required for my case, I can go ahead and findNewSize(); and use that value to malloc the array. Is this correct?

Sure. You do a malloc first, then realloc.

Here's a little more robust approach:

Code:

---



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

int* a1 = 0, *a2 = 0;
int buffer_size = 0;

int reset_global_arrays( size_t size )
{
        free( a1 );
        free( a2 );
        if( size == 0 )
        {
                a1 = a2 = 0;
        }
        else
        {
                a1 = realloc( a1, size * sizeof( *a1 ) );
                a2 = realloc( a2, size * sizeof( *a2 ) );
                if( !a1 || !a2 )
                {
                        reset_global_arrays( 0 );
                        return 0;
                }
        }       
        buffer_size = size;
        return 1;
}

void fatal( const char* message, int code )
{
        perror( message );
        exit( code );
}

int main( void )
{
        size_t initial_size = 1024;
        if( !reset_global_arrays( initial_size ) )
                fatal( "reset_global_arrays", 1 );
// ...do stuff...       
        reset_global_arrays( 0 );       
        return 0;       
}

---

Quote:

---

Originally Posted by Dino

Sure. You do a malloc first, then realloc.

---

realloc can be used in place of the first malloc. There's no reason you must use malloc first.


Quzah.

Ah. Thanks.