C 4stellige Zahl aufsplitten

Durch sukzessive Modulo / Division.
z.B.:

unsigned char stelle[4];
unsigned int wert;

for(i = 0; i < 4; i++)
{
    stelle[i] = wert % 10;
    wert /= 10;
}

Dann stehen in stelle[0...3] die einzelnen Dezimalstellen, und zwar die
Einser in stelle[0], die Zehner in stelle[1] usw...

ja ich glaube damit lässt sich was anfangen. danke euch. werde es mal
sofort ausprobieren.

Eine andere Möglich keit ist die Zahl in einen buffer zu sprinten,
und die jeweilge Zahl aus dem String zu nutzen

zahl = 123;
buffer[46];
sprintf(buffer,"%i",zahl);

stelle = buffer[x]-0x30

Naja, ein sprintf ist aber in dem Zusammenhang echt mit Kanonen auf
Spatzen geschossen. Da kann man noch eher itoa nehmen. Das bläht das
Programm nicht so auf und das Ergebnis ist das selbe...

@Walter:
Nur als kleines Beispiel: Aus dem hier

unsigned char string[6];
unsigned int wert = 12345;
sprintf(string, "%i", wert);

macht der AVR-GCC-C-Compiler satte 1922 Bytes Code (Optimierung -Os).

Das hier

unsigned char string[6];
unsigned int wert = 12345;
itoa(wert, string, 10);

gibt kompakte 312 Bytes. Ich glaub, da fiele die Wahl nicht schwer,
gell?

Aber die ganz oben genannten Methoden sind sicher noch kleiner...

290 Bytes Code.
Zahl ist in 4 ASCII Zeichen umgewandelt.
Wenn du kein ASCII haben willst, ziehe 30hex von jeder ab.

unsigned char lookup [17] = "0123456789ABCDEF";
unsigned char buffer[5];

int main(void)
{
 unsigned int zahl;

 buffer[0] = lookup[(zahl)      & 0x000F];
 buffer[1] = lookup[(zahl >>4 ) & 0x000F];
 buffer[2] = lookup[(zahl >>8 ) & 0x000F];
 buffer[3] = lookup[(zahl >>12) & 0x000F];

return 0;
}

Oops, der Zahl fehlt noch dein Beispielwert.

unsigned char lookup [17] = "0123456789ABCDEF";
unsigned char buffer[5];

int main(void)
{
 unsigned int zahl = 9847;

 buffer[3] = lookup[(zahl)      & 0x000F];
 buffer[2] = lookup[(zahl >>4 ) & 0x000F];
 buffer[1] = lookup[(zahl >>8 ) & 0x000F];
 buffer[0] = lookup[(zahl >>12) & 0x000F];

 return 0;
}

Genau, in dem Beispiel würde nicht 9847 ausgegeben, sondern das
Hexadezimal-Äquivalent 2677. Und das ist ein klitzekleiner Unterschied.
Genau das ist ja das Problem, wenn man von einem Prozessor
Dezimalstellen bekommen will: Die Division durch 10 ist eben nicht so
schön einfach durch Bitschubsereien machbar und macht deshalb mehr Code
erforderlich.

Ich tendiere zur ersten Version.

Die Benutzung der Funktion div() hat halt den Vorteil, daß die
Divisionen nicht alle doppelt gemacht werden müssen. Das spart eine
Menge Zeit.

> daß die Divisionen nicht alle doppelt gemacht werden müssen.

Was glaubst Du denn, was die Funktion div() macht? Du musst die
Division und das Modulo vielleicht nicht explizit hinschreiben, aber
div() macht intern mit Sicherheit auch nix anderes... Vom
Programmieraufwand ist das glaub ich kein wirklicher Unterschied.

@Jörg:
Hast natürlich recht. Mit Programmieraufwand meinte ich aber eigentlich
den Schreibaufwand im Programm. Dass der Code dann größer und evtl.
langsamer wird ist die andere Sache...