C program: Use an array outside the scope it was defined in

Question

I have some code in which an array of strings is defined in a conditional statement. The array is out of scope where I need it. So I defined another pointer in the outer scope. In the conditional statement I assign the array address to the outer scope pointer. The code compiles without warnings for dangling pointers and such, but the code is not correct.

I produced a (correctly compiling) MRE below. The function does not make any sense. Essential is that:

• The array of strings cmd_str is defined inside a condition
• The number of strings is variable
• The length of the strings is variable
• The strings are either constants or null terminated strings
• The last string only contains NULL
• I use the resulting strings array outside the condition

int noCmd(int *opt) {

    int             local_opt;
    const char**    cmd = NULL;

        local_opt = *opt; // Make sure the compiler cannot know this value to avoid optimization.
        if (local_opt == 1) {
            const char* cmd_str[] = {"foo", "bar", NULL};
            cmd = cmd_str;
        } else {
            const char* cmd_str[] = {"flop", "blah", NULL};
            cmd = cmd_str;
        }
    // Dummy statement to force referencing cmd
    // actually I need the contents of cmd here
    return sizeof(cmd);
}

The main problem is that cmd doesn’t have any value in the return statement. This is confirmed by the assembly listing where cmd does not get a value assigned:

    Dump of assembler code for function noCmd:
    0x00007ffff7fb9e80 <+0>:     mov    $0x8,%eax
    0x00007ffff7fb9e85 <+5>:     ret
    End of assembler dump.

My reasoning is that cmd_str goes out of scope. Since it is not a valid pointer anymore, it is not allowed to be used. And the compiler optimizes all code out, because the nothing is used inside the scope and must not be used outside the scope.

The actual code is obviously much more complicated that this MRE. But the problem (conditional char** assignment) and the need for the strings outside the scope is the same.

How do I solve this?

I cannot do a memcpy from cmd_str into cmd, because I don't know the size. I might loop through each string in cmd_str, find the size of the string and then copy each string into cmd one by one, but that is very inelegant.

I cannot declare cmd_str in the outer scope, because

const char* cmd_str[]

is invalid.

Neither can I declare

const char** cmd_str

because it would be impossible to assign a number of strings to cmd_str[].

Isn't there a better way to define an array of strings inside a condition and use it outside the condition? The string to be assigned are either constants or null terminated strings. The last string gets the NULL value.

Answer 1

I have some code in which an array of strings is defined in a conditional statement. The array is out of scope where I need it. So I defined another pointer in the outer scope. In the conditional statement I assign the array address to the outer scope pointer. The code compiles without warnings for dangling pointers and such, but the code is not correct.

Code such as you describe is not incorrect, but it becomes incorrect (in the sense of having undefined behavior) as soon as you dereference that outer pointer, or use its value in any other way before assigning a new one. This is because the lifetime of the array declared inside the conditional ends as soon as execution of the innermost containing block does, where "block" in this case means any containing statement, not just one delimited by braces. In your case, it is whichever clause of the conditional is executed.

Essential is that:

• The array of strings (cmd_str) is defined inside a condition

[...]

• I use the resulting strings array outside the condition

If that's truly essential then you are out of luck. If you define an array anywhere inside a conditional statement, then its lifetime is over by the time execution of the conditional terminates. Outside the conditional, there is no longer any array to access. Assigning a pointer to point to it while it is still alive doesn't change that.

How do I solve this.

One way would be to dynamically allocate memory inside the conditional, once you know how much you need. You then assign or copy whatever value you need into the dynamically allocated space, and set the pointer to point to it. The dynamically allocated object lives until it is explicitly deallocated (so don't forget to deallocate it when you no longer need it).

Example:

    const char **cmd;

    if (local_opt == 1) {
        const char* cmd_str[] = {"foo", "bar", NULL};
        cmd = malloc(sizeof cmd_str);
        // ... abort if null ...

        memcpy(cmd, cmd_str, sizeof cmd_str);
    } else {
        // ...
    }

There are other ways to work the details.

Note well that the usage of string literals in the above is not problematic, because these represent objects having static storage duration. Their lifetime is the entire execution of the program. It's unclear what you mean, however, when you say the array elements may include (pointers to) null-terminated strings. The string literals satisfy that description, but if you mean anything else by that then there are lifetime considerations surrounding those, too.

If you don't need to be able to modify the array once produced, then another alternative that would be suitable at least for the example given would be to declare the inner arrays static, so that their lifetimes are not bounded by the execution of the conditional:

    const char * const *cmd;

    if (local_opt == 1) {
        static const char * const cmd_str[] = {"foo", "bar", NULL};
        cmd = cmd_str;
    } else {
        // ...
    }

The additional const qualification is not essential, but it helps protect against the array being modified. This is important because any changes will persist indefinitely, through the end of the program's execution, across any number of calls to the function containing that code.

Answer 2

By far the easiest solution is to simply move the initialized definitions above the conditional.

    const char* cmd_str_opt1[] = {"foo", "bar", nullptr};
    const char* cmd_str_notopt[] = {"flop", "blah", nullptr};
    cmd = (local_opt == 1)? cmd_str_opt1: cmd_str_notopt;
    cmd_size = (local_opt == 1)? (sizeof cmd_str_opt1): (sizeof cmd_str_notopt);

It wastes memory for handful of extra pointers, and only until the end of the next enclosing scope (such as your function). The memory for the actual string contents (literals) is used for the entire duration of the program anyway.

If some of the strings can only be produced inside the conditional, you can overwrite elements selectively.

Answer 3

You can dynamically allocate space for cmd and then use memcpy to copy the contents of cmd_str.

const char *cmd_str[] = {"foo", "bar", NULL};
cmd = malloc(sizeof cmd_str);
memcpy(cmd, cmd_str, sizeof cmd_str);

Just make sure to free(cmd) when you're done.

Answer 4

As written, the code in the question is neither incorrect nor does it have undefined behavior if opt is a valid pointer, yet it would invoke undefined behavior if the value of cmd (as opposed to just its size) was used after leaving the scope where the array it points to is defined.

Since this is the intent and given the additional constraints for the arrays, the easy solution to this problem is to make the arrays static, preferably static and const.

Here is a modified example:

int noCmd(int *opt) {
    const char * const *cmd = NULL;

    switch (*opt) {
      case 0: {
        static const char * const cmd_str[] = { "foo", "bar", NULL };
        cmd = cmd_str;
        break;
      }
#ifdef FOOBAR_ID
      case FOOBAR_ID: {
        static const char * const cmd_str[] = { "foobar", NULL };
        cmd = cmd_str;
        break;
      }
#endif
      // [...] this can be extended at will.
      // cmd_str stays local to the #ifdef block for readability
    }

    // example use: return the number of strings in the array
    int i = -1;
    if (cmd) {
        for (i = 0; cmd[i]; i++)
            continue;
    }
    return i;
}

Answer 5

Assuming *opt is restricted to a continguous (or at least a dense subset of an) interval of integers, you really have a ragged array of string literals, which you can index by *opt. The below assumes the interval [1,n], where n as an integer than fits in an int . Note that another interval can be sent to this one with simple arithmetic.

int noCmd(int *opt) {

    const char **cmd = NULL,
               **cmd_strs[] = {
                   {"flop", "blah", NULL},  /* cmd_str[] for the else clause */
                   {"foo", "bar", NULL},
                       /* ... more cmd_str[]s */
                   NULL,   /* for rows which can't be a value of *opt */
                       /* ... more cmd_str[]s */
               };

    /*  Compute the maximum index from the table, because a separate constant 
     *  will always be out of sync with the list of cmd_strs.
     */
    maxOpt = sizeof(cmd_strs) / sizeof(cmd_strs[0]);

    if (1 <= *opt <= maxOpt) {
        cmd = cmd_strs[*opt];
    } else {
        cmd = cmd_strs[0];
    }
    /*  more readable for some readers:
     *      cmd = cmd_strs[(1 <= *opt <= maxOpt) ? *opt : 0];
     */
}

Answer 6

Another possibility is to exploit the fact that when arrays are struct members, they are naturally "value-copied" like all other members of structs. That makes (together with compound literals) the following compact code possible:

struct ArrayHolder { const char *mArr[3]; };

struct ArrayHolder noCmd(int opt) 
{
  return opt == 1 ? (struct ArrayHolder) { { "foo",  "bar",  NULL } }
                  : (struct ArrayHolder) { { "flop", "blah", NULL } };
  }
}

The struct containing the array is returned by value which seems extravagant until you remember that memcpy is also a hidden, crude "return by value".

Note that as with all other solutions which do not copy the strings but only their addresses, this only works for strings with static life time (which string literals are).

If the strings are are non-static but have a maximum length you can define an array with actual char arrays as members; this will make the data mutable, and copying that will be a deep copy. Interestingly, the initialization looks almost the same, even though the strings are copied, except that NULL does not work:

#define MAX_STR_LEN 20

struct MatrixHolder
{
  char mArr[3][MAX_STR_LEN+1];
};

struct MatrixHolder noCmdMatrix(int opt)
{
  // imagine the data source to be something else than static strings...
  return opt == 1 ? (struct MatrixHolder) { { "mfoo",  "mbar",                 "" } }
                  : (struct MatrixHolder) { { "mflop", "12345678901234567890", "" } };
}

Of course, returning an entire matrix by value is even more extravagant; depending on the matrix size and frequency of calls it may well be prohibitive. But in an initialization routine that's just called once it would hardly matter and makes the code very clean. (Of course everyone is yearning for C++'s movable containers here.)

Usage of both could look like this (note how the caller is free to write into the character matrix at the end of main()):

int main()
{
  {
    struct ArrayHolder ah = noCmd(0);
    printf("%s %s\n", ah.mArr[0], ah.mArr[1]);
    ah = noCmd(1);
    printf("%s %s\n", ah.mArr[0], ah.mArr[1]);
  }
  
  {
    struct MatrixHolder mh = noCmdMatrix(0);
    printf("%s %s\n", mh.mArr[0], mh.mArr[1]);
    mh = noCmdMatrix(1);
    printf("%s %s\n", mh.mArr[0], mh.mArr[1]);
    mh.mArr[0][0] = 'X';
    printf("%s\n", mh.mArr[0]);
  }
}