C-> Größe eines Array in einem Union initalisieren?!

OP #5838591
Lesenswert?
• ▲
▼
Moin,

ist es möglich, ohne das ich jetzt die ganzen Bytes zählen muss, die 
Größe von dem Array zu bestimmen beim übersetzen?

1
union __flash 
2
{
3
  const uint8_t fontData[] =
4
  {
5
    0x0E, 0xF9, // size
6
    0x11, // width
7
    0x18, // height
8
    0x30, // first char
9
    0x0B, // char count
10
    
11
    // char widths
12
    0x10, 0x0D, 0x0F, 0x0F, 0x11, 0x0F, 0x10, 0x10, 0x10, 0x10,
13
    0x04,
14
    
15
    // font data
16
    0x80, 0xF0, 0xFC, 0x7E, 0x0E, 0x0F, 0x07, 0x07, 0x07, 0x07, 0x0F, 0x1E,
17
    0x7E, 0xFC, 0xF0, 0x80, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00,
18
    0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x01, 0x0F, 0x3F, 0x7E,
19
    0x70, 0xF0, 0xE0, 0xE0, 0xE0, 0xE0, 0xF0, 0x70, 0x7E, 0x3F, 0x0F, 0x01, //48 '0'
20
    
21
    0x38, 0x38, 0x38, 0x38, 0x3C, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,
22
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00,
23
    0x00, 0x00, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xFF, 0xFF, 0xFF, 0xE0, 0xE0,
24
    0xE0, 0xE0, 0xE0,                                                        // 49 '1'
25
    
26
    0x00, 0x1E, 0x0E, 0x0E, 0x07, 0x07, 0x07, 0x07, 0x07, 0x0F, 0x1E, 0xFE,
27
    0xFC, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xC0, 0xE0, 0xF0,
28
    0x78, 0x3E, 0x1F, 0x07, 0x01, 0x00, 0xF0, 0xF8, 0xFC, 0xFE, 0xEF, 0xE7,
29
    0xE3, 0xE1, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0,                    // 50 '2'
30
    
31
    0x00, 0x1E, 0x0E, 0x0E, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x0F, 0x1E,
32
    0xFE, 0xFC, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x1C, 0x1C, 0x1C,
33
    0x1E, 0x36, 0x77, 0xF3, 0xE1, 0xC0, 0x78, 0x70, 0x70, 0xF0, 0xE0, 0xE0,
34
    0xE0, 0xE0, 0xE0, 0xF0, 0x70, 0x78, 0x3F, 0x1F, 0x0F,                   // 51 '3'
35
    
36
    0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xC0, 0xF0, 0xF8, 0x7C, 0x1E, 0xFF,
37
    0xFF, 0xFF, 0x00, 0x00, 0x00, 0xE0, 0xF0, 0xFC, 0xFE, 0xDF, 0xC7, 0xC3,
38
    0xC1, 0xC0, 0xC0, 0xC0, 0xFF, 0xFF, 0xFF, 0xC0, 0xC0, 0xC0, 0x01, 0x01,
39
    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0xFF, 0xFF, 0xFF,
40
    0x01, 0x01, 0x01,                                                       // 52 '4'
41
    
42
    0x00, 0xFF, 0xFF, 0xFF, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
43
    0x07, 0x07, 0x07, 0x00, 0x1F, 0x1F, 0x0F, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E,
44
    0x1E, 0x1C, 0x3C, 0xF8, 0xF8, 0xE0, 0x78, 0x70, 0x70, 0xF0, 0xE0, 0xE0,
45
    0xE0, 0xE0, 0xE0, 0xF0, 0x70, 0x7C, 0x3F, 0x1F, 0x07,                    // 53 '5'
46
    
47
    0x00, 0xC0, 0xF0, 0xF8, 0x3C, 0x1E, 0x0E, 0x0E, 0x07, 0x07, 0x07, 0x07,
48
    0x07, 0x0F, 0x00, 0x00, 0xFE, 0xFF, 0xFF, 0x1C, 0x1C, 0x0E, 0x0E, 0x0E,
49
    0x0E, 0x0E, 0x0E, 0x1E, 0x3C, 0xF8, 0xF8, 0xE0, 0x03, 0x0F, 0x3F, 0x7C,
50
    0x78, 0xF0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0x70, 0x78, 0x3F, 0x1F, 0x07, //54 '6'
51
    
52
    0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x87,
53
    0xE7, 0xFF, 0x7F, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0,
54
    0xF0, 0xFC, 0x3F, 0x0F, 0x07, 0x01, 0x00, 0x00, 0x00, 0x00, 0x80, 0xE0,
55
    0xF8, 0xFC, 0x3F, 0x0F, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //55 '7'
56
    
57
    0x00, 0xF0, 0xFC, 0xFE, 0x0E, 0x0F, 0x07, 0x07, 0x07, 0x07, 0x0F, 0x1E,
58
    0xFE, 0xFC, 0xF8, 0x00, 0x80, 0xE0, 0xF3, 0x77, 0x1F, 0x0E, 0x0E, 0x0C,
59
    0x1C, 0x1C, 0x1C, 0x3E, 0x77, 0xF3, 0xE0, 0x80, 0x0F, 0x1F, 0x3F, 0x78,
60
    0x70, 0xF0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0x70, 0x78, 0x3F, 0x1F, 0x0F, //56 '8'
61
    
62
    0xE0, 0xF8, 0xFC, 0x1E, 0x0E, 0x07, 0x07, 0x07, 0x07, 0x07, 0x0F, 0x1E,
63
    0x3E, 0xFC, 0xF0, 0xC0, 0x07, 0x1F, 0x1F, 0x3C, 0x78, 0x70, 0x70, 0x70,
64
    0x70, 0x70, 0x70, 0x38, 0x38, 0xFF, 0xFF, 0x7F, 0x00, 0x00, 0xF0, 0xE0,
65
    0xE0, 0xE0, 0xE0, 0xE0, 0x70, 0x70, 0x78, 0x3C, 0x1F, 0x0F, 0x03, 0x00, //57 '9'
66
    
67
    0xC0, 0xC0, 0xC0, 0xC0, 0x03, 0x03, 0x03, 0x03, 0xF0, 0xF0, 0xF0, 0xF0 // 58 ':'
68
    
69
  };
70
    
71
  struct
72
  {
73
    uint16_t _size;
74
    uint8_t _width;
75
    uint8_t _height;
76
    uint8_t _firstChar;
77
    uint8_t _charCount;
78
      
79
    uint8_t _widths[11];
80
    uint8_t _fontData[sizeof(fontData)];
81
  };
82
};
Gast #5838626
Lesenswert?
• ▲
▼
Jan H. schrieb:
> uint16_t _size;
>     uint8_t _width;
>     uint8_t _height;
>     uint8_t _firstChar;
>     uint8_t _charCount;
>
>     uint8_t _widths[11];

Aber hier hast du doch schon gerechnet.

X = die größe gesamten Arrays
y = sizeof(_width)+sizeof(_height)+....+sizeof(-widths)

dann (X-Y) / sizeof(uint8_t)

Vielleich so?
#5838643
Lesenswert?
• ▲
▼
Wenn Dein Compiler nicht allzu sehr am Alignment herumfummelt, sollte 
eine Konstante, direkt hinter "fontData" gehen.
Du subtrahierst dann einfach die Adresse von fontData von der der 
Hilfskonstanten hast Du den Salat. Natürlich nur zur Laufzeit.

Ich glaube aber nicht, dass Du mit Deinem Ansatz glücklich werden wirst, 
da Du ja kein homogenes Array produzierst.
Die 0 hat 48 Bytes;
die 1 macht Kurzarbeit; und
die 4 sogar Überstunden; für
den Doppelpunkt lohnt es sich kaum aufzustehen.

Um auf die Punktmuster zugreifen zu können, musst Du sowieso irgendwo 
die "Anfänge" der einzelnen Punktmuster (als Konstante) ablegen. Zu 
diesen Konstanten noch die Länge des Doppelpunktes hinzuzurechnen sollte 
aber machbar sein.

Übrigens: Sollten die Konstanten "char widhts" irgendwie mit der 
Blockgröße zusammenhängen, so definiere sie doch einfach mittels 
"define". Dann kann der Compiler sie addieren und Du brauchst nur noch 
die Länge des Doppelpunktes im Auge behalten.
Persönliche Seite #5839027
Lesenswert?
• ▲
▼
Eine Möglichkeit ist ein Codegenerator, der die Zusatzdaten / 
Informationen konsistent erzeugt, was aber extra Programm für den PC 
erfordert.

Oder indem man die Größe direkt aus den Daten bestimmt — nicht 
sonderlich schön — nach dem Muster:
1
#define DATA 1, 2, 3,
2

3
typedef struct
4
{
5
    int data[sizeof ((int[]) { DATA })];
6
} font_t;
7

8
const font_t font = 
9
{
10
    .data = { DATA }
11
};
Man könnte die Daten aus DATA auch in eine Datei auslagern und includen 
wo gebraucht; auch nicht wirklich hipp:
1
typedef struct
2
{
3
    int data[sizeof ((int[])
4
    {
5
#include "data.def"
6
    })];
7
} font_t;
8

9
const font_t font = 
10
{
11
    .data =
12
    {
13
#include "data.def"
14
    }};



g457 schrieb:
>> ist es möglich, ohne das ich jetzt die ganzen Bytes zählen muss, die
>> Größe von dem Array zu bestimmen beim übersetzen?
>
> Natürlich. Und man kann Quellcode sogar anhängen.
> const uint8_t* pFontData;

Was aber eine andere Datenstruktur ist; ein Zeiger ist kein Array.

Antwort schreiben

Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt. Bitte hier nur auf die ursprüngliche Frage antworten, für neue Fragen einen neuen Beitrag erstellen.

Formatierung
  • [c]C-Code[/c]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] – Link zu einem Artikel
  • Verweis auf einen anderen Beitrag: Rechtsklick auf dessen Beitrags-ID (#8078628), „Adresse kopieren“, in den Text einfügen

Mehr zur Formatierung

Längeren Sourcecode als Anhang, nicht in den Text. JPG nur für Fotos und Scans; Zeichnungen und Screenshots als PNG oder GIF. Siehe Bildformate.

Schon registriert? Anmelden

Wird nicht angezeigt. Wir schicken dir einen Link; sobald du damit bestätigst, erscheint dein Beitrag.

Mit dem Abschicken legst du einen kostenlosen Account an und erkennst die Nutzungsbedingungen und die Datenschutzerklärung an.