Warum funktioniert dieser code nicht [C]

[Da M. (da_m)]

Guten Abend,
ich bin in C leider totaler Anfänger und wollte daher fragen ob 
eventuell einer der erfahrerern Benutzer mir bei meinem Code das Problem 
erklären kann, was sehr nett wäre :)

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

int *splitToDigits(int inputvalue)
{
    char buffer[64];
    int size, i, *outpointer;

    size = (int) sprintf(buffer, "%d", inputvalue);
    outpointer = (int *) malloc((size + 1) * sizeof(int));

    for (i=0;i<size;i++)
        outpointer[i] = atoi(buffer[i]);

    return outpointer;
}

int main()
{
    int testvalue  = 8392, *pointer , size = 4, i;

    pointer = splitToDigits(testvalue);

    for (i=0;i<size;i++)
        printf("%d", pointer[i]);
}

Folgene Fehlermeldungen entstehen

[test1.c 2020-08-11 19:12:35.303]
,,test1.c: In Funktion »splitToDigits«:
test1.c:14:36: Warnung: Übergabe des Arguments 1 von »atoi« wandelt eine Zahl in einen Zeiger um, ohne explizite Typkonvertierung [-Wint-conversion]
   14 |         outpointer[i] = atoi(buffer[i]);
      |                              ~~~~~~^~~
      |                                    |
      |                                    char
In Datei, eingebunden von test1.c:3:
/usr/include/stdlib.h:104:30: Anmerkung: »const char *« erwartet, aber Argument hat Typ »char«
  104 | extern int atoi (const char *__nptr)
      |                  ~~~~~~~~~~~~^~~~~~

Vielen Dank im vorraus, und schönen Abend noch :)

[P. S. (namnyef)]

Na, im Prinzip steht es doch schon da: atoi will einen Pointer auf einen 
char und keinen char. Also brauchst du nicht den Inhalt von buffer[i], 
sondern die Adresse von buffer[i]:

atoi(&(buffer[i]));

Ob das so schon das tut was du willst, weiß ich nicht. Ich habe mir 
jetzt nur die eine Stelle angeschaut.

[Da M. (da_m)]

Danke für die schnelle Antwort, ne tut nich das was ich will. Habe grade 
eine andere Lösung gefunden.

Statt

outpointer[i] = atoi(&buffer[i]);

Benutze ich jetzt:

outpointer[i] = (int) buffer[i] - 48;

Hätte ich Idiot einfach mal 5 Minuten länger überlegt bevor ich meine 
fragen ins Internet stelle :/

[Jim (Gast)]

Da M. schrieb:
> outpointer = (int *) malloc((size + 1) * sizeof(int));

das +1 brauchst du nicht. Üblicherweise macht man so eine Zerlegung 
übrigens über Ganzzahldivision und Modulo-Operator. Die Rückgabe des 
Pointers ist auch keine gute Lösung, weil du außerhalb der Funktion 
nicht weißt, wie viele Elemente das erzeugte Array hat. Üblicherweise 
würde man als Rückgabewert die Anzahl der Stellen haben und das Array 
über einen doppelten Pointer als Parameter zurückgeben.

[Da M. (da_m)]

Danke für die Tipps :)

[A. H. (ah8)]

Noch ein Tipp: Solltest Du auf den Zwischenspeicher verzichten wollen, 
so ist auch eine rekursive Variante möglich:

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

int splitToDigits(int **outpointer, int inputvalue, int size)
{
        int total, next = inputvalue / 10, newsize = size + 1;
        if ( next )
                total = splitToDigits(outpointer, next, newsize);
        else
                *outpointer = (int*) malloc((total = newsize) * sizeof(int));
        (*outpointer)[total-newsize] = inputvalue - next * 10;
        return total;
}

int main()
{
        int testvalue = 8392, *pointer, size = splitToDigits(&pointer, testvalue, 0), i;

        for ( i=0; i < size; ++i)
                printf("%d\n", pointer[i]);
}

Als Zwischenspeicher dient hier quasi der Stack. Ist allerdings mit 
einem gewissen Laufzeit-Overhead verbunden, also nicht unbedingt etwas 
für High-Performance Anwendungen. :-)

PS: Eigentlich sollte man an allen Stellen statt int besser *unsigned 
int* verwenden.

[zu lang (Gast)]

Da M. schrieb:
> size = (int) sprintf(buffer, "%d", inputvalue);

geht bei negativen Zahlen schief.

[? DPA ? (Gast)]

Ich hab mir zum Spass mal eine overengineerte Lösung ausgedacht, in C, 
aber lose Inspiriert von JS Generator Funktionen.

Erschaudert in Anbetracht meiner C Macromagie, Muhahahaha!