Ergebnis 1 bis 18 von 18

Thema: Mit C anfangen > Header und Source

Hybrid-Darstellung

Vorheriger Beitrag Vorheriger Beitrag   Nächster Beitrag Nächster Beitrag
  1. #1
    Warum nimmst du überhaupt den SDCC-Compiler? Dieser wurde für die Intel MCS-51-Familie optimiert.
    Was soll diese Doppelpunkt-Angabe bei der Struct-Definition? Die ist mir nicht geläufig und ich finde auch darüber überhaupt nichts.

    Und ja, du kannst die Werte des Structs ganz einfach mit Ganzzahlen vergleichen.

  2. #2
    Zitat Zitat von Whiz-zarD Beitrag anzeigen
    Warum nimmst du überhaupt den SDCC-Compiler? Dieser wurde für die Intel MCS-51-Familie optimiert.
    Ich nutze eine andere Plattform und muss diesen Compiler nutzen, weils keinen anderen gibt.
    Zitat Zitat von Whiz-zarD
    Was soll diese Doppelpunkt-Angabe bei der Struct-Definition? Die ist mir nicht geläufig und ich finde auch darüber überhaupt nichts.
    Wie ich schrieb, ist das Struct ein Bitfeld. Die Zahl hinter dem Doppelpunkt gibt an, wieviele Bits die Variable nutzt.
    (Ich versuch so viel Platz zu sparen wie möglich. irgendwelche Flags würden immer ein ganzes Byte fressen. So kann ich mehrere Flags in ein Byte packen.)

    Zitat Zitat von Whiz-zarD
    Und ja, du kannst die Werte des Structs ganz einfach mit Ganzzahlen vergleichen.
    Das ist ja das Problem, meine Dokumentation für den Compiler gibt keine Informationen darüber preis. Ich kriege halt einen Fatal Error.
    Zitat Zitat
    Game.c(32):error *** FATAL Compiler Internal Error in file 'gen.c' line number '3758' : code generator internal error
    Ich bin mir aber sicher, dass der gesamte Block
    Code:
    if(flags.STATE == 1)        {
                [...]
            }else if(flags.STATE == 2)
            {
                [...]
            }else if(flags.STATE == 3)
            {
                [...]
            }else if(flags.STATE == 4)
            {
                [...]
            }
    gemeint ist.

    Geändert von Raildex (07.07.2014 um 17:43 Uhr)

  3. #3
    Hallöle, ich bins nochmal.

    Dieses Mal geht es um Pointer.

    Folgendes Setup:

    Code:
    typedef struct c { 
        UBYTE id; 
        UBYTE type; 
    }C; 
    typedef struct t 
    { 
        const UBYTE *array; 
        const C *arrayc; 
    }T;

    Code:
    const UBYTE main[] =
    {
      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
      0xFF,0xFF,0xC0,0x80,0xBF,0x80,0xBF,0x80,
      0xBF,0x80,0xBF,0x80,0xA0,0xDF,0xFF,0xFF,
      0xFF,0xFF,0xF1,0x03,0x0D,0x01,0xFD,0x01,
      0xF5,0x09,0xFD,0x01,0x8D,0x73,0xFF,0xFF,
      0xFF,0xFF,0xF1,0x03,0x0D,0x01,0xFD,0x01,
      0xF5,0x09,0xFD,0x01,0x3D,0xC3,0xFF,0xFF,
      0xFF,0xFF,0x80,0xC0,0xBF,0x80,0xBF,0x80,
      0xAF,0x90,0xBF,0x80,0xB0,0xCF,0xFF,0xFF,
      0xFF,0xFF,0xC1,0xFF,0x90,0xFF,0x80,0xFF,
      0x82,0xFF,0x80,0xFF,0xC0,0xFF,0xFF,0xFF,
      0xFF,0xFF,0x03,0xFF,0x01,0xFF,0x01,0xFF,
      0x21,0xFF,0x01,0xFF,0x03,0xFF,0xFF,0xFF,
      0xFF,0xFF,0x83,0xFF,0x01,0xFF,0x05,0xFF,
      0x01,0xFF,0x11,0xFF,0x03,0xFF,0xFF,0xFF,
      0xFF,0xFF,0xC0,0xFF,0x80,0xFF,0x88,0xFF,
      0x80,0xFF,0x80,0xFF,0xC0,0xFF,0xFF,0xFF,
      0xFF,0xFF,0x02,0xFF,0x7F,0xFF,0x7F,0xFF,
      0xFF,0xFF,0x7F,0xFF,0xFF,0xFF,0xFF,0xFF,
      0xFF,0xFF,0x86,0xFF,0xFE,0xFF,0xFE,0xFF,
      0xFE,0xFF,0xFE,0xFF,0xFF,0xFF,0xFF,0xFF,
      0xFF,0xFF,0x2F,0xFF,0xFF,0xFF,0xFF,0xFF,
      0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
      0xFF,0xFF,0xCB,0xFF,0xFF,0xFF,0xFF,0xFF,
      0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
      0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
      0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
      0xFF,0xFF,0x86,0xFF,0xFE,0xFF,0xFE,0xFF,
      0xFF,0xFF,0xFE,0xFF,0xFF,0xFF,0xFF,0xFF,
      0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
      0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
      0xFF,0xFF,0xCB,0xFF,0xFF,0xFF,0xFF,0xFF,
      0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
      0xFF,0xFF,0x01,0x01,0x38,0x00,0xFF,0x00,
      0xFF,0xFF,0xC4,0x3B,0x00,0xFF,0xFF,0xFF,
      0x91,0x7E,0x10,0xFF,0xFF,0xFF,0xF8,0x07,
      0x00,0xFF,0xFF,0xFF,0x93,0x7C,0x10,0xFF,
      0xFF,0xFF,0xC0,0xC0,0x14,0x00,0xFF,0x00,
      0xFF,0xFF,0x96,0xE9,0x80,0xFF,0xFF,0xFF,
      0xE5,0x1E,0x04,0xFF,0xFF,0xFF,0x9C,0xE3,
      0x80,0xFF,0xFF,0xFF,0x86,0x7D,0x04,0xFF,
      0xFF,0xFF,0x01,0x01,0x38,0x00,0xFF,0x00,
      0xFF,0xFF,0xC4,0x3B,0x00,0xFF,0xFF,0xFF,
      0x91,0x7E,0x10,0xFF,0xFF,0xFF,0xF8,0x07,
      0x00,0xFF,0xFF,0xFF,0x93,0x7C,0x10,0xFF,
      0xFF,0xFF,0xC1,0xC1,0x15,0x01,0xFF,0x01,
      0xFF,0xFF,0x97,0xE9,0x81,0xFF,0xFF,0xFF,
      0xE4,0x1C,0x04,0xFC,0xFF,0xFF,0x9D,0xE3,
      0x81,0xFF,0xFF,0xFF,0x84,0x7C,0x04,0xFC,
      0xFF,0xFF,0x81,0x81,0xB8,0x80,0xFF,0x80,
      0xFF,0xFF,0xC4,0xBB,0x80,0xFF,0xFF,0xFF,
      0x11,0x1E,0x10,0x1F,0xFF,0xFF,0xF8,0x87,
      0x80,0xFF,0xFF,0xFF,0x13,0x1C,0x10,0x1F,
      0xFF,0xFF,0xC0,0xC0,0x14,0x00,0xFF,0x00,
      0xFF,0xFF,0x96,0xE9,0x80,0xFF,0xFF,0xFF,
      0xE5,0x1E,0x04,0xFF,0xFF,0xFF,0x9C,0xE3,
      0x80,0xFF,0xFF,0xFF,0x86,0x7D,0x04,0xFF,
      0x5E,0x01,0x0C,0x03,0x2C,0x03,0x1C,0x03,
      0x2E,0x01,0x2A,0x05,0x1A,0x05,0x5C,0x03,
      0x4E,0x01,0x0E,0x01,0x5A,0x05,0x0A,0x05,
      0x28,0x07,0x2C,0x03,0x1E,0x01,0x5E,0x01,
      0x7A,0x80,0x30,0xC0,0x34,0xC0,0x38,0xC0,
      0x74,0x80,0x54,0xA0,0x58,0xA0,0x3A,0xC0,
      0x72,0x80,0x70,0x80,0x5A,0xA0,0x50,0xA0,
      0x14,0xE0,0x34,0xC0,0x78,0x80,0x7A,0x80,
      0x70,0x80,0x54,0xA0,0x5C,0xA0,0x18,0xE0,
      0x10,0xE0,0x31,0xC0,0x35,0xC0,0x75,0x80,
      0x54,0xA0,0x5C,0xA0,0x58,0xA0,0x18,0xE0,
      0x10,0xE0,0x34,0xC0,0x3D,0xC0,0x78,0x80,
      0x0E,0x01,0x8A,0x05,0xA8,0x07,0x3C,0x03,
      0x1C,0x03,0x0C,0x03,0x2E,0x01,0x3E,0x01,
      0xBA,0x05,0x9A,0x05,0x8A,0x05,0xA8,0x07,
      0x2C,0x03,0x3C,0x03,0x3C,0x03,0x9E,0x01,
      0x00,0x00,0x00,0x00,0x1D,0x00,0x33,0x08,
      0x73,0x08,0x6E,0x11,0xEE,0x11,0xEE,0x11,
      0x00,0x00,0x40,0x20,0xC0,0x00,0x8C,0x42,
      0x18,0x84,0x36,0x89,0xF5,0x0A,0xEA,0x14,
      0xFF,0x00,0xFF,0x00,0xFF,0x00,0xFF,0x00,
      0xFF,0x00,0xFF,0x00,0xFF,0x00,0xFF,0x00,
      0xFA,0x05,0xF2,0x0D,0xF4,0x0A,0xE4,0x1A,
      0x88,0x74,0x30,0xC8,0xC0,0x30,0x00,0xC0,
      0x7F,0x80,0x7F,0x80,0x3F,0x40,0x3F,0x40,
      0x1F,0x20,0x0F,0x10,0x03,0x0C,0x00,0x03,
      0x00,0x03,0x03,0x0C,0x0F,0x10,0x13,0x20,
      0x23,0x40,0x27,0x40,0x7F,0x80,0x7F,0x80,
      0x00,0xC0,0xC0,0x30,0xF0,0x08,0xF8,0x04,
      0xFC,0x02,0xFC,0x02,0xFE,0x01,0xFE,0x01,
      0x00,0xFF,0x00,0xFF,0x00,0xFF,0x00,0xFF,
      0x00,0xFF,0x00,0xFF,0x00,0xFF,0x00,0xFF,
      0xFA,0x05,0xF2,0x0D,0xF4,0x0B,0xE4,0x1B,
      0x88,0x77,0x30,0xCF,0xC0,0x3F,0x00,0xFF,
      0x7F,0x80,0x7F,0x80,0x3F,0xC0,0x3F,0xC0,
      0x1F,0xE0,0x0F,0xF0,0x03,0xFC,0x00,0xFF,
      0x00,0xFF,0x00,0xFF,0x04,0xFA,0x04,0xFA,
      0x08,0xF4,0x30,0xC8,0xC0,0x30,0x00,0xC0,
      0x00,0xFF,0x00,0xFF,0x00,0x7F,0x00,0x7F,
      0x00,0x3F,0x00,0x1F,0x00,0x0F,0x00,0x03,
      0x00,0xFF,0x04,0xFB,0x19,0xE6,0x33,0xCC,
      0x6F,0x90,0x5F,0xA0,0xDE,0x21,0xBD,0x42,
      0x00,0x00,0x04,0x00,0x19,0x00,0x33,0x08,
      0x6F,0x10,0x5F,0x20,0xDE,0x21,0xBD,0x42,
      0xBD,0x42,0xB9,0x46,0xBB,0x44,0xBB,0x44,
      0xBB,0x44,0xBB,0x44,0x7B,0x84,0xFF,0x00,
      0x22,0x00,0xCC,0x00,0x98,0x44,0xF0,0x08,
      0x51,0xA8,0x6A,0x91,0xE5,0x12,0xED,0x12,
      0xEB,0x14,0xE3,0x1C,0xDB,0x24,0xDF,0x20,
      0xDF,0x20,0xFF,0x00,0xFF,0x00,0xFF,0x00,
      0x22,0xDD,0xCC,0x33,0x98,0x67,0xF0,0x0F,
      0x51,0xAE,0x6A,0x95,0xE5,0x1A,0xED,0x12,
      0x00,0xFF,0x00,0x00,0xFF,0x00,0x39,0xC6,
      0xD4,0xEF,0x02,0xFF,0x29,0xDF,0x10,0xFF,
      0x82,0x7D,0x80,0x7F,0x22,0xDD,0xFF,0x00,
      0xDF,0x20,0xFF,0x00,0x7E,0x81,0x1C,0xE3,
      0x00,0xFF,0x00,0x00,0xFF,0x00,0xA7,0x58,
      0x56,0xF9,0x89,0xFF,0x24,0xFF,0x02,0xFF,
      0x00,0xFF,0x24,0xDB,0x6E,0x91,0xFF,0x00,
      0xFF,0x00,0xFF,0x00,0x7C,0x83,0x54,0xAB,
      0x00,0xF8,0x00,0x06,0xFC,0x01,0xA6,0x59,
      0x56,0xF9,0x89,0xFF,0x25,0xFF,0x03,0xFF,
      0x01,0xFF,0x59,0xA7,0x3F,0xC1,0xEF,0x11,
      0xFF,0x01,0xFF,0x01,0xDD,0x23,0x09,0xF7,
      0x00,0x7F,0x00,0x80,0x7F,0x80,0xB9,0xC6,
      0xD4,0xEF,0x82,0xFF,0xA9,0xDF,0x90,0xFF,
      0x82,0xFD,0x80,0xFF,0xA2,0xDD,0xFF,0x80,
      0xDF,0xA0,0xFF,0x80,0xFE,0x81,0x9C,0xE3,
      0xFF,0x00,0x00,0x00,0x00,0x00,0x00,0xC6,
      0x00,0xEF,0xC4,0x3B,0xE6,0x19,0xEF,0x10,
      0x7D,0x00,0x7F,0x00,0xDD,0x00,0x00,0x00,
      0x20,0x00,0x00,0x00,0x81,0x00,0xE3,0x00,
      0x00,0xFF,0x00,0x00,0xFF,0x00,0xA7,0x58,
      0x06,0xF9,0x50,0xAF,0xD9,0x26,0xFD,0x02,
      0xFF,0x00,0xDB,0x00,0x91,0x00,0x00,0x00,
      0x00,0x00,0x00,0x00,0x83,0x00,0xAB,0x00,
      0x00,0xF8,0x00,0x06,0xFC,0x01,0xA6,0x59,
      0x06,0xF9,0x50,0xAF,0xD8,0x27,0xFC,0x03,
      0xFE,0x01,0xA6,0x01,0xC0,0x01,0x10,0x01,
      0x00,0x01,0x00,0x01,0x22,0x01,0xF6,0x01,
      0x00,0x7F,0x00,0x80,0x7F,0x80,0x39,0xC6,
      0x10,0xEF,0x64,0x9B,0x46,0x99,0x6F,0x90,
      0x7D,0x80,0x7F,0x80,0x5D,0x80,0x00,0x80,
      0x20,0x80,0x00,0x80,0x01,0x80,0x63,0x80,
      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
    };
    
    
    const C coll[]=
    {
        {1,1},
        {2,1},
        {3,1},
        {4,1},
        {17,1},
        {18,1},
        {19,1},
        {20,1},
        {21,1},
        {22,1},
        {23,1},
        {24,1},
        {25,1},
        {26,1},
        {27,1},
        {28,1},
        {55,1},
        {56,1},
        {57,1},
        {58,1},
        {59,1},
        {60,1},
        {61,1},
        {62,1},
        {63,55},
        {65,55},
        {67,55},
        {69,55}
    };
    
    
    const T g =
    {
        (const UBYTE *)main,
        (const C *)coll
    };
    meine Frage ist nun: Da Coll und main beides Arrays sind, wie greife ich auf die einzelnen Elemente zu (Es sind ja Pointer zu Arrays)?

    Geändert von Raildex (04.08.2014 um 16:59 Uhr)

  4. #4
    Wenn man einen Array in einen Pointer castet, erhält man einen Zeiger auf die erste Zelle des Arrays (nicht auf "den ganzen Array").
    (const UBYTE *)main ist also ein Pointer auf eine Speicherstelle der Größe einer UBYTE-Variable, nämlich auf den ersten Wert im Array.
    Dieser Pointer ist in deiner Struktur als g.array verfügbar, und *(g.array) wäre der Wert in der ersten Arrayzelle.
    Auf Zelle i lässt sich mit *(g.array + i) oder g.array[i] zugreifen. Letzteres ist nur eine andere Schreibweise für Ersteres.
    Arrays und Pointer sind in C (fast) das Gleiche, der einzige Unterscheid ist im Prinzip, dass du mit einem Array nicht umspringen darfst, wie mit einer Variable (also z.B. wäre es sinnlos, einen Array zu inkrementieren).

    Geändert von dasDull (04.08.2014 um 19:24 Uhr)

  5. #5
    das hab ich mir schon gedacht,
    allerdings zeigt
    Code:
    g.array[i]
    immer 0 an. Egal, was für einen Index ich angebe.

    ich kriege keine Fehlermeldung.

    Geändert von Raildex (04.08.2014 um 19:28 Uhr)

  6. #6
    Ich hab mir das mal bei mir lokal angeschaut. (Linux PC)
    GCC mag scheinbar UBYTE nicht, ich hab das bei mir mit unsigned char ersetzt und den Code laufen lassen.

    Die Einträge von main[] (den Namen lässt gcc btw nicht zu, ist global wohl für die Main-Funktion reserviert, die kann ja als pointer referenziert werden)
    werden korrekt ausgegeben. Die ersten 10 oder 20 sind ja genau "0x00", probier mal den ersten Pointer zu verändern, und schau ob dann g.array[0] nicht auch die neue Zahl anzeigt.

  7. #7
    der Variablenname is natürlich nur provisorisch und is selbstverständlich anders.
    Array[0] zeigt immer 0.
    Komischerweise ist sizeof(g.array) = 2.

  8. #8
    Zitat Zitat von Raildex Beitrag anzeigen
    der Variablenname is natürlich nur provisorisch und is selbstverständlich anders.
    Array[0] zeigt immer 0.
    Ich darf also annehmenn, dass du probiert hast den ersten Eintrag von main[] zu ändern? Bei mir lokal funktioniert das erwartungsgemäß.
    Welches System benutzt du und welchen Compiler?

    Das sizeof(g.array) gibt dir in Byte die Größe von UBYTE * zurück. Das muss eigentlich 4 sein, wenn es 32-Bit Pointer sind.

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •