Die Größe des hexadezimalen Char-Arrays in C von PROGMEM finden

Question

Ich arbeite an einem AT90-Mikrocontroller und arbeite daran, verschiedene Schriftarten auf dem Bildschirm anzuzeigen. Als Teil meiner Schriftdefinition habe ich unten ein char-Array von hexadezimalen Zeichen. Zum Zweck dieser Frage habe ich das Char-Array verkürzt, um nur 4 Zeichen darzustellen.

const char font5x7[] PROGMEM = { 
    0x00, 0x00, 0x00, 0x00, 0x00, // SPACE 
    0x00, 0x00, 0x5F, 0x00, 0x00, // ! 
    0x00, 0x03, 0x00, 0x03, 0x00, // " 
    0x14, 0x3E, 0x14, 0x3E, 0x14 // # 
} 

Nun, wenn ich sizeof(font5x7) laufen, es gibt mir die richtige Antwort gibt, die 20. Allerdings ist, wenn ich meine wirklichen font5x7 ausführen, gibt es 475 statt der richtigen Anzahl 225. Hier ist die echte:

const char font5x7[] PROGMEM = { 
    0x00, 0x00, 0x00, 0x00, 0x00, // SPACE 
    0x00, 0x00, 0x5F, 0x00, 0x00, // ! 
    0x00, 0x03, 0x00, 0x03, 0x00, // " 
    0x14, 0x3E, 0x14, 0x3E, 0x14, // # 
    0x24, 0x2A, 0x7F, 0x2A, 0x12, // $ 
    0x43, 0x33, 0x08, 0x66, 0x61, // % 
    0x36, 0x49, 0x55, 0x22, 0x50, // & 
    0x00, 0x05, 0x03, 0x00, 0x00, // ' 
    0x00, 0x1C, 0x22, 0x41, 0x00, // (
    0x00, 0x41, 0x22, 0x1C, 0x00, //) 
    0x14, 0x08, 0x3E, 0x08, 0x14, // * 
    0x08, 0x08, 0x3E, 0x08, 0x08, // + 
    0x00, 0x50, 0x30, 0x00, 0x00, // , 
    0x08, 0x08, 0x08, 0x08, 0x08, // - 
    0x00, 0x60, 0x60, 0x00, 0x00, // . 
    0x20, 0x10, 0x08, 0x04, 0x02, ///
    0x3E, 0x51, 0x49, 0x45, 0x3E, // 0 
    0x00, 0x04, 0x02, 0x7F, 0x00, // 1 
    0x42, 0x61, 0x51, 0x49, 0x46, // 2 
    0x22, 0x41, 0x49, 0x49, 0x36, // 3 
    0x18, 0x14, 0x12, 0x7F, 0x10, // 4 
    0x27, 0x45, 0x45, 0x45, 0x39, // 5 
    0x3E, 0x49, 0x49, 0x49, 0x32, // 6 
    0x01, 0x01, 0x71, 0x09, 0x07, // 7 
    0x36, 0x49, 0x49, 0x49, 0x36, // 8 
    0x26, 0x49, 0x49, 0x49, 0x3E, // 9 
    0x00, 0x36, 0x36, 0x00, 0x00, // : 
    0x00, 0x56, 0x36, 0x00, 0x00, // ; 
    0x08, 0x14, 0x22, 0x41, 0x00, // < 
    0x14, 0x14, 0x14, 0x14, 0x14, // = 
    0x00, 0x41, 0x22, 0x14, 0x08, // > 
    0x02, 0x01, 0x51, 0x09, 0x06, // ? 
    0x3E, 0x41, 0x59, 0x55, 0x5E, // @ 
    0x7E, 0x09, 0x09, 0x09, 0x7E, // A 
    0x7F, 0x49, 0x49, 0x49, 0x36, // B 
    0x3E, 0x41, 0x41, 0x41, 0x22, // C 
    0x7F, 0x41, 0x41, 0x41, 0x3E, // D 
    0x7F, 0x49, 0x49, 0x49, 0x41, // E 
    0x7F, 0x09, 0x09, 0x09, 0x01, // F 
    0x3E, 0x41, 0x41, 0x49, 0x3A, // G 
    0x7F, 0x08, 0x08, 0x08, 0x7F, // H 
    0x00, 0x41, 0x7F, 0x41, 0x00, // I 
    0x30, 0x40, 0x40, 0x40, 0x3F, // J 
    0x7F, 0x08, 0x14, 0x22, 0x41, // K 
    0x7F, 0x40, 0x40, 0x40, 0x40, // L 
    0x7F, 0x02, 0x0C, 0x02, 0x7F, // M 
    0x7F, 0x02, 0x04, 0x08, 0x7F, // N 
    0x3E, 0x41, 0x41, 0x41, 0x3E, // O 
    0x7F, 0x09, 0x09, 0x09, 0x06, // P 
    0x1E, 0x21, 0x21, 0x21, 0x5E, // Q 
    0x7F, 0x09, 0x09, 0x09, 0x76, // R 
    0x26, 0x49, 0x49, 0x49, 0x32, // S 
    0x01, 0x01, 0x7F, 0x01, 0x01, // T 
    0x3F, 0x40, 0x40, 0x40, 0x3F, // U 
    0x1F, 0x20, 0x40, 0x20, 0x1F, // V 
    0x7F, 0x20, 0x10, 0x20, 0x7F, // W 
    0x41, 0x22, 0x1C, 0x22, 0x41, // X 
    0x07, 0x08, 0x70, 0x08, 0x07, // Y 
    0x61, 0x51, 0x49, 0x45, 0x43, // Z 
    0x00, 0x7F, 0x41, 0x00, 0x00, // [ 
    0x02, 0x04, 0x08, 0x10, 0x20, // slash 
    0x00, 0x00, 0x41, 0x7F, 0x00, // ] 
    0x04, 0x02, 0x01, 0x02, 0x04, //^
    0x40, 0x40, 0x40, 0x40, 0x40, // _ 
    0x00, 0x01, 0x02, 0x04, 0x00, // ` 
    0x20, 0x54, 0x54, 0x54, 0x78, // a 
    0x7F, 0x44, 0x44, 0x44, 0x38, // b 
    0x38, 0x44, 0x44, 0x44, 0x44, // c 
    0x38, 0x44, 0x44, 0x44, 0x7F, // d 
    0x38, 0x54, 0x54, 0x54, 0x18, // e 
    0x04, 0x04, 0x7E, 0x05, 0x05, // f 
    0x08, 0x54, 0x54, 0x54, 0x3C, // g 
    0x7F, 0x08, 0x04, 0x04, 0x78, // h 
    0x00, 0x44, 0x7D, 0x40, 0x00, // i 
    0x20, 0x40, 0x44, 0x3D, 0x00, // j 
    0x7F, 0x10, 0x28, 0x44, 0x00, // k 
    0x00, 0x41, 0x7F, 0x40, 0x00, // l 
    0x7C, 0x04, 0x78, 0x04, 0x78, // m 
    0x7C, 0x08, 0x04, 0x04, 0x78, // n 
    0x38, 0x44, 0x44, 0x44, 0x38, // o 
    0x7C, 0x14, 0x14, 0x14, 0x08, // p 
    0x08, 0x14, 0x14, 0x14, 0x7C, // q 
    0x00, 0x7C, 0x08, 0x04, 0x04, // r 
    0x48, 0x54, 0x54, 0x54, 0x20, // s 
    0x04, 0x04, 0x3F, 0x44, 0x44, // t 
    0x3C, 0x40, 0x40, 0x20, 0x7C, // u 
    0x1C, 0x20, 0x40, 0x20, 0x1C, // v 
    0x3C, 0x40, 0x30, 0x40, 0x3C, // w 
    0x44, 0x28, 0x10, 0x28, 0x44, // x 
    0x0C, 0x50, 0x50, 0x50, 0x3C, // y 
    0x44, 0x64, 0x54, 0x4C, 0x44, // z 
    0x00, 0x08, 0x36, 0x41, 0x41, // { 
    0x00, 0x00, 0x7F, 0x00, 0x00, // | 
    0x41, 0x41, 0x36, 0x08, 0x00, // } 
    0x02, 0x01, 0x02, 0x04, 0x02};// ~ 

Answer 1

Dieser Code druckt "Array len: 20" auf meinem System.

#include <stdio.h> 

#define PROGMEM 

const char font5x7[] PROGMEM = { 
    0x00, 0x00, 0x00, 0x00, 0x00, // SPACE 
    0x00, 0x00, 0x5F, 0x00, 0x00, // ! 
    0x00, 0x03, 0x00, 0x03, 0x00, // " 
    0x14, 0x3E, 0x14, 0x3E, 0x14 // # 
}; 

#define ARRAY_LEN(a) (sizeof(a)/sizeof((a)[0])) 

const font5x7_len = ARRAY_LEN(font5x7); 
int main(void) { 
    printf("Array len: %d\n", font5x7_len); 
} 

Answer 2

In C-Programmierung sind Arrays wenig mehr als Zeiger. Während Sie sich noch in dem Bereich befinden, in dem Sie das Array deklariert haben, können Sie sizeof (font5x7)/sizeof (char) verwenden, um die Länge des Arrays zu bestimmen.

Wenn jedoch ein Array an eine Funktion übergeben wird, zerfällt es in einen Zeiger. Pointer haben keine assoziierte Länge, daher müssen Sie eine andere Variable angeben, die beschreibt, wie lange das Array ist.

Mit anderen Worten, die Funktion, die Sie wollen, ist ohne eine Art von Sentinel-Wert unmöglich. Wenn Sie beispielsweise garantieren könnten, dass Ihr Font-Array niemals 0xff enthält, können Sie jedes Array mit 0xff beenden. Ihre Funktion würde dann das Array durchsuchen, bis es diesen Wert findet und die Länge zurückgibt.