How do I modify a char** in another function

Question

This is what I expect my string array s to be after the program is run: {"#0", "#1", "2"}.
This is what I am getting: {"#2", "#2", "2"}.
How do I modify this code so that I can get {"#0", "#1", "#2"} in the main after the function is executed? What am I doing wrong? Please help.

#include <stdio.h>

void func(char **s){
    for(int i=0; i<3; i++){
        char buf[10];
        snprintf(buf, 10, "#%d",i);
        s[i]=buf;
    }
}
int main()
{
    char *s[3];
    func(s);
    for(int i=0; i<3; i++){
        printf("%s", s[i]);
    }
    return 0;
}

Answer 1

First, you have every element in your array pointing to the same character array.

Second, they are all pointing to a local character array. This leads to undefined behavior.

Local variables in functions get allocated on the stack. When the function call is over, that memory may be overwritten with some other value.

Answer 2

Given two pointers p and q, the statement:

p = q;

doesn't copy the contents of the memory pointed to by q to the contents of the memory pointed to by p. It copies the pointer values, such that both p and q now point to the same memory, and any change to the memory via p is reflected when q is used.

That being said, the statement:

char buf[10];

declares buf to be an array of 10 chars. It has a lifetime corresponding to the execution of its block of definition. Once the function returns, it's destroyed and s is now indeterminate. Indeterminate pointers lead to undefined behaviour.

Possible Solutions:

• standard strcpy
• POSIX's strdup (which will be included in C23)

Note that the strdup() function returns a pointer to a new string which is a duplicate of the provided string. Memory for the new string is obtained with malloc, and must be freed by the calling process with free.

Answer 3

@Chris’s answer tells you what is wrong.

To fix it, you have options. The simplest is to make the argument array have strings (char arrays) that are big enough for your uses:

#define MAX_STR_LEN (9+1)  // Every string’s capacity is 9+1 characters

void func(size_t n, char array_of_string[][MAX_STR_LEN])
{
    for (size_t i=0;  i<n;  i++)
    {
        snprintf(array_of_string[i], MAX_STR_LEN, "#%d", (int)i);  // use the extant string
    }
}

int main(void)
{
    char array_of_string[3][MAX_STR_LEN] = {{0}};  // Array of 3 strings
    func(3, array_of_string);
    ...
    return 0;
}

If you want to play with dynamic char * strings, life gets only a little more complicated:

void func(size_t n, char *array_of_string[])
{
    for (size_t i=0;  i<n;  i++)
    {
        free(array_of_string[i]);              // free any pre-existing string
        array_of_string[i] = calloc( 10, 1 );  // allocate our new string
        if (!array_of_string[i]) fooey();      // always check for failure
        snprintf(array_of_string[i], 10, "#%d", (int)i);  // use the new string
    }
}

int main(void)
{
    char *array_of_string[3] = {NULL};  // Array of 3 dynamic strings, all initially NULL
    func(3, array_of_string);

    ...
    
    for (size_t i=0; i<3; i++)          // Don’t forget to clean up after yourself
        free(array_of_string[i]);
    return 0;
}

Ultimately the trick is to manage the size of your strings, remembering that a string is itself just an array of char. You must ensure that there is enough room in your character array to store all the characters you wish. (Good job on using snprintf()!

---

Also remember that in C any argument of the form array[] is the same as *array. So our functions could have been written:

void func(size_t n, char (*array_of_string)[MAX_STR_LEN])

or

void func(size_t n, char **array_of_string)

respectively. The first is an uglier (harder to read) syntax. The second is nicer, methinks, but YRMV.

Finally, if you are using C99 (or later) you can tell the compiler that those arguments are, actually, arrays:

void func(size_t n, char array_of_string[n][MAX_STR_LEN])

or

void func(size_t n, char *array_of_string[n])

MSVC does not support that syntax, though, and probably never will, alas.

Answer 4

{ // start of a new scope
    char buf[10]; // a variable with automatic storage duration
    // ...
} // end of scope - all automatic variables end their life

In your code, you make pointers point at buf which has seized to exist (3 times) at the } in the for loop. Dereferencing (reading from the memory those pointers point at) those pointers afterwards makes your program have undefined behavior (anything could happen).

• What you can do is to allocate and release memory dynamically using malloc and free.

When sending in a pointer to the first element in an array of elements to a function like you do, it's also customary to provide the length of the array (the number of elements in the array) to the function.

It could look like this:

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

// A macro to calculate the number of elements in an array
// sizeof (x)   - the number of bytes the whole array occupies
// sizeof *(x)  - the size of the first element in the array
//                (all elements have equal size)
// The result of the division is the number of elements in the array.
#define SIZE(x) (sizeof (x) / sizeof *(x))

void func(char *s[], size_t len) {
    for (size_t i = 0; i < len; i++) {
        // calculate the required length for this string
        size_t req = snprintf(NULL, 0, "#%zu", i) + 1; // +1 for '\0'
        // and allocate memory for it
        s[i] = malloc(req);
        if(s[i] == NULL) exit(1); // failed to allocate memory
        snprintf(s[i], req, "#%zu", i);
    } // dynamically allocated memory is _not_ released at the end of the scope
}

int main() {
    char *s[3];
    func(s, SIZE(s));
    for (size_t i = 0; i < SIZE(s); i++) {
        puts(s[i]);
        free(s[i]); // free what you've malloc'ed when you are done with it
    }
}

Note that with the use of the macro there is only one hardcoded 3 in the program. Even that could be made into a named constant (#define CHAR_PTRS (3) or enum { CHAR_PTRS = 3 };) to further the ease of reading and maintaining the code.

---

A non-idiomatic version only accepting a pointer to an array of a fixed (at compile time) size could look like like below. In this example you couldn't accidentally provide a pointer to an array with only 2 char* (which would cause the function to write out of bounds). Instead, it'd result in a compilation error.

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

// Here `s` is a pointer to an array of 3 char*
void func(char *(*s)[3]) { 
    for (int i = 0; i < 3; i++) {
        (*s)[i] = malloc(10);
        if((*s)[i] == NULL) exit(1);
        snprintf((*s)[i], 10, "#%d", i);
    }
}

int main() {
    char *s[3];
    func(&s);                      // &s is a char*(*)[3]
    for (int i = 0; i < 3; i++) {
        printf("%s\n", s[i]);
        free(s[i]);
    }
}

Answer 5

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

void func(char **s){
    for(int i=0; i<3; i++){
        s[i]=malloc(sizeof(char) * 100);
        char buf[10];
        snprintf(buf, 10, "#%d",i);
        strcpy(s[i], buf);
    }
}
int main()
{
    char *s[3];
    func(s);
    for(int i=0; i<3; i++){
        printf("%s", s[i]);
    }
    return 0;
}

This fixed my problem. My understanding is that I assigned memory and then copied the contents of buf to s to the now-present memory.