Saving the values of a dynamically changing array into a pointer C

Question

I am trying to solve this problem. I am a beginner in C.

                        uint8_t *instrumentStringsCount;
instrumentStringsCount = malloc(sizeof(uint8_t));
dbGettingStringsNumbers(instrumentStringsCount, familyID);
uint8_t sizeCount = instrumentStringsCount[0];
uint8_t i = 0;

char stringTransferArray[10];
char *mainArray[sizeCount];

while(i < sizeCount)
{
    sprintf(stringTransferArray, "%d strings", instrumentStringsCount[i+1]);
    mainArray[i]= stringTransferArray;
    i++;
}

The thing is that stringTransferArray is dynamically changing (instrumentStringsCount: being fetched from the db). So the values of the pointers are always being changed to the last value in the array. I know the reason for that; however, I just need a way to solve this.

Thanks for your efforts

Answer 1

My problem is in this line: mainArray[i]= stringTransferArray; the stringTransferArray is changing and when that happens, all the values of the mainArray show the last value associated with stringTransferArray

As for your problem, there are functions to duplicate strings. It's not really standardized in the C specification, but I know of no platform that doesn't have a strdup function. – Some programmer dude

Answer 2

sizeof(uint8_t) is likely to be 1 byte. And that is not enough for instrumentStringsCount (so you are malloc-ing a too small memory zone, which will give you buffer overflow when using later instrumentStringsCount[i+1], a typical case of undefined behavior; you really should be very scared). You probably want to keep in another variable the allocated size (and you should have a convention to know the allocated size), and you should test against failure of malloc so code:

size_t instrumentStringSize = 24;
uint8_t *instrumentStringsCount = malloc(instrumentStringSize * sizeof(uint8_t));
if (!instrumentStringsCount) { perror("malloc"); exit(EXIT_FAILURE); };

You might want to also keep the used length of your buffer.

At some times in your program, you may want to grow your instrumentStringsCount memory zone. Since you don't want to call realloc or malloc at every round, you probably should grow the size with e.g. an affine function:

size_t newsize = 4*instrumentStringSize/3+ 10;
uint8_t* newStringsCount = malloc(newsize * sizeof(uint8_t));

etc (e.g. test against failure of malloc and copy using memcpy the old memory zone into the new one, etc...).

At last, you should use snprintf (and give the actual size of the buffer) instead of sprintf (because you really want to avoid buffer overflow and other undefined behavior).

If on Linux, compile with all warnings & debug info (gcc -Wall -Wextra -g). The instrumentation options of gcc like -fsanitize=address and other sanitizers would also be helpful. Then use the gdb debugger & valgrind.