DISCLAIMER: it's just a piece of the whole algorithm, but since I encountered a lot of errors, I've decided to divide and conquer, therefore, I start with the following code. (goal of the following code: create a string with the remainders of the division by 10 (n). for now, it's not reversed, I haven't done it yet, because I wanted to check this code first).

(i'm working in C, in visual studio environment).

I have to implement a function like atoi (that works from a string to a number), but I want to do the opposite (from a number to a string). but I have a problem:

the debugger pointed out that in the lines with the malloc, I should have initialized the string first (initialization requires a brace-enclosed initializer list),

but I have done it, I have initialized the string to a constant (in the 2nd line, I've written "this is the test seed")(because I need to work with a string, so I initialized, and then I malloc it to write the values of (unsigned int n) ).

this is how my program is supposed to work:

(1) the function takes an unsigned int constant (n),

(2) the function creates a "prototype" of the array (the zero-terminated string),

(3) then, I've created a for-loop without a check condition because I added it inside the loop body,

(4) now, the basic idea is that: each step, the loop uses the i to allocate 1 sizeof(char) (so 1 position) to store the i-th remainder of the n/10 division. n takes different values every steps ( n/=10; // so n assumes the value of the division). and if n/10 is equal to zero, that means I have reached the end of the loop because each remainder is in the string). Therefore, I put a break statement, in order to go outside the for-loop.

finally, the function is supposed to return the pointer to the 0-th position of the string.

so, to sum up: my main question is:

• why do I have " "s": initialization requires a brace-enclosed initializer list"? (debugger repeated it twice). that's not how string is supposed to be initialized (with curly braces "{}"). String is initialized with " " instead, am I wrong?

 char* convert(unsigned int n) {
   char s[] = "this is the test seed";
     for (unsigned int i = 0; ; i  ) {
         if (i == 0) {
             char s[] = malloc (1 * sizeof(char));
         }
         if (i != 0) {
             char s[] = malloc(i * sizeof(char));
         }
         if ((n / 10) == 0) {
             break;
        }
        s[i] = n % 10;
        n /= 10;
    }

    return s;
}

CodePudding user response：

char s[]is an array, and therefore needs a brace-enclosed initializer list (or a character string literal). In the C standard, see section 6.7.8 (with 6.7.8.14 being the additional special case of a literal string for an array of character type). char s[] = malloc(...); is neither a brace-enclosed initializer list or a literal string, and the compiler is correctly reporting that as an error.

The reason for this, is that char s[] = ...; declares an array, which means that the compiler needs to know the length of the array at compile-time.

Perhaps you want char *s = malloc(...) instead, since scalars (for example, pointers) can be initialized with an assignment statement (see section 6.7.8.11).

Unrelated to your actual question, the code you've written is flawed, since you're returning the value of a local array (the first s). To avoid memory problems when you're coding, avoid mixing stack-allocated memory, statically allocated strings (eg: literal strings), and malloc-ed memory. If you mix these together, you'll never know what you can or can't do with the memory (for example, you won't be sure if you need to free the memory or not).

A complete working example:

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

char *convert(unsigned n) {
    // Count digits of n (including edge-case when n=0).
    int len = 0;
    for (unsigned m=n; len == 0 || m; m /= 10) {
          len;
    }
    // Allocate and null-terminate the string.
    char *s = malloc(len 1);
    if (!s) return s;
    s[len] = '\0';
    // Assign digits to our memory, lowest on the right.
    while (len > 0) {
        s[--len] = '0'   n % 10;
        n /= 10;
    }
    return s;
}

int main(int argc, char **argv) {
    unsigned examples[] = {0, 1, 3, 9, 10, 100, 123, 1000000, 44465656, UINT_MAX};
    for (int i = 0; i < sizeof(examples) / sizeof(*examples);   i) {
        char *s = convert(examples[i]);
        if (!s) {
            return 2;
        }
        printf("example %d: %u -> %s\n", i, examples[i], s);
        free(s);
    }
    return 0;
}

It can be run like this (note the very useful -fsanitize options, which are invaluable especially if you're beginning programming in C).

$ gcc -fsanitize=address -fsanitize=leak -fsanitize=undefined -o convert -Wall convert.c && ./convert
example 0: 0 -> 0
example 1: 1 -> 1
example 2: 3 -> 3
example 3: 9 -> 9
example 4: 10 -> 10
example 5: 100 -> 100
example 6: 123 -> 123
example 7: 1000000 -> 1000000
example 8: 44465656 -> 44465656
example 9: 4294967295 -> 4294967295