Nun soll ich ich einen neuen Datentyp erstellen der die 5 Pixelzeilen der Zeile einer Zahlendarstellung als Zeichenkette aufnehmen kann. Die einzelnen Pixel bestehen halt aus ' ' oder einem *chen ^^.

die zahl 12 liefere dann halt folgende 5 zeichenketten?

..*.|.**.   // Zeichenkette 1
.**.|*..*   // Zeichenkette 2
*.*.|..*.   // Zeichenkette 3
..*.|.*..   // Zeichenkette 4
..*.|****   // Zeichenkette 5

Die leeren Felder sind immoment durch einen "." ersetzt.

Berücksichtigungen:
- der neue Typ soll genug Platz bieten um die Pixeldarstellung aller Zahlen aus int (die max. anzahl darzustellender Ziffern/zeichen ergibt sich aus dem Wertebereich des typs int)
In dieser Berechnung soll berücksichtigt werden das zwischen den Ziffern eine Spalte '|' die jeweiligen Zeichen trennen. Demnach sind als breite 5 Spalten einzuplanen.

Zur Lösung hab ich mir da folgendes Überlegt:

bei mir ist in vc++ int mit long gleich gesetzt. Demnach ist die größt mögliche zahl mit die mit int darstellbar ist 2147483647 um eins erhöht würde er in den minus bereich springen.

um diese zahl darzustellen benötige ich 10*5 Spalten.

Könnte mein neuer Datentyp so aussehen?

struct new_array{
char c_array[50][5];
}

new_array = matrix;

Als nächstes benötige ich dazu noch eine Funktion die eine Int Zahl als ersten Parameter und einen zeiger auf die leere struktur enthält.

Als Rückgabewert soll die Anzahl der dargestellten Ziffern incl. '-' übergeben werden.

int fill_array(int zahl, *matrix)
{
    int counter;

   // Die Funktion soll den Speicher entsprechend füllen. 
   // Achtung: Nach der letzten darzustellenden Ziffer sollen die Zeichenketten 
   // der 5 enthaltenen Pixwlzeilen logisch enden.
   // damit die ausgabe nur bis '\0' gelesen wird...
   // sollte die vorhergehende zahl 6666 sein und die nächste nur 12, soll die
   //  ausgabe 1266 vermieden werden

    return counter;
}

Für Ideen die mich hier weiterbringen bin ich sehr dankbar^^

das bisherige Programm

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

# define WAIT for(;;)

char dots[11][5][4] = {
                            {
                                {' ', '*', '*', ' '},
                                {'*', ' ', ' ', '*'},
                                {'*', ' ', ' ', '*'},
                                {'*', ' ', ' ', '*'},
                                {' ', '*', '*', ' '}
                            },
                            {
                                {' ', ' ', '*', ' '},
                                {' ', '*', '*', ' '},
                                {'*', ' ', '*', ' '},
                                {' ', ' ', '*', ' '},
                                {' ', ' ', '*', ' '}
                            },
                            {
                                {' ', '*', '*', ' '},
                                {'*', ' ', ' ', '*'},
                                {' ', ' ', '*', ' '},
                                {' ', '*', ' ', ' '},
                                {'*', '*', '*', '*'}
                            },
                            {
                                {'*', '*', '*', ' '},
                                {' ', ' ', ' ', '*'},
                                {' ', '*', '*', ' '},
                                {' ', ' ', ' ', '*'},
                                {'*', '*', '*', ' '}
                            },
                            {
                                {' ', ' ', '*', ' '},
                                {' ', '*', ' ', ' '},
                                {'*', ' ', '*', ' '},
                                {'*', '*', '*', '*'},
                                {' ', ' ', '*', ' '}
                            },
                            {
                                {'*', '*', '*', '*'},
                                {'*', ' ', ' ', ' '},
                                {'*', '*', '*', ' '},
                                {' ', ' ', ' ', '*'},
                                {'*', '*', '*', ' '}
                            },
                            {
                                {' ', ' ', '*', '*'},
                                {' ', '*', ' ', ' '},
                                {' ', '*', '*', '*'},
                                {' ', '*', ' ', '*'},
                                {' ', '*', '*', '*'}
                            },
                            {
                                {'*', '*', '*', '*'},
                                {' ', ' ', ' ', '*'},
                                {' ', ' ', '*', ' '},
                                {' ', '*', ' ', ' '},
                                {' ', '*', ' ', ' '}
                            },
                            {
                                {' ', '*', '*', ' '},
                                {'*', ' ', ' ', '*'},
                                {' ', '*', '*', ' '},
                                {'*', ' ', ' ', '*'},
                                {' ', '*', '*', ' '}
                            },
                            {
                                {' ', '*', '*', '*'},
                                {' ', '*', ' ', '*'},
                                {' ', '*', '*', '*'},
                                {' ', ' ', ' ', '*'},
                                {' ', '*', '*', ' '}
                            },
{
                                {' ', ' ', ' ', ' '},
                                {' ', ' ', ' ', ' '},
                                {'*', '*', '*', '*'},
                                {' ', ' ', ' ', ' '},
                                {' ', ' ', ' ', ' '}
                            }
                        };

main()
    {
    unsigned char zahl[20];
    int zeile;
    int spalte;
    int index;

    printf( "Bitte Zahl eingeben: ");
    scanf( "%s", zahl);
    printf( "\n");

    for( zeile = 0; zeile < 5; zeile = zeile + 1)
        {
        for( index = 0; zahl[index] != 0; index = index + 1)
            {
            for( spalte = 0; spalte < 4; spalte = spalte + 1)
                 // hier entsteht gerade die Abfrage, 
                 // WENN zahl[index] das "-", dann  springe zu  
                 // dots[11][zeile][spalte]
                 printf( "%c", dots[zahl[index]-'0'][zeile][spalte]);

            printf( "  ");
            }
        printf( "\n");
        }
    WAIT;
    }

Hallo, das sieht übersichtlicher aus, das stimmt ...

Immoment habe ich ein 3d - Array, welches die ganzen Zahlen beinhaltet.

Nun soll folgendes passieren. Jede Zeile 0-4 soll in einen String gespeichert werden.
Wir gehen davon aus, der Benutzer hat eine 0 eingegeben so sehe der Inhalt wie folgt aus:

string strg0,strg1,strg2,strg3,strg4;

" ** "     // <- Inhalt von strg0
"*  *"     // <- Inhalt von strg1
"*  *"     // <- Inhalt von strg2
"*  *"     // <- Inhalt von strg3
" ** "     // <- Inhalt von strg4

Gibt nun der Benutzer die zahlen 10 ein soll der Inhalt anders aussehen:

"  * " " ** "    // <- Inhalt von strg0
" ** " "*  *"    // <- Inhalt von strg1
"* * " "*  *"    // <- Inhalt von strg2
"  * " "*  *"    // <- Inhalt von strg3
"  * " " ** "    // <- Inhalt von strg4
[code]

So wäre erstmal mein Ansatz. Jedoch wenn ich an der Stelle der Ausgabe
es in einen string einlesen will, klappt es noch nciht so ganz.

[code]
 if(zeile == 0)
   strg0[spalte] += dots[zahl[index]-'0'][zeile][spalte]);