Struct per Pointerzugriff befüllen

[Ben Banane (Gast)]

Hi, ich möchte in einem Struct alle Bits setzen. Es sollen also nachher 
alle uint8_t auf 255 und uint16_t auf 65535 stehen. Mehr Datentypen 
gibt's da auch nicht. Also keine Gefahr wegen Vorzeichen, etc.
Jetzt könnte ich die Variablen natürlich alle einzeln setzen. Ich muss 
aber Platz sparen. Leider ist memset auch zu groß. Deswegen habe ich 
folgendes geschrieben:

for (i = 0; i < sizeof(Data); i++) *(uint8_t *)(&Data+i) = 255;

Ist das korrekt so??? Die Größe wäre ok! Geht's "noch" schöner? Ist ein 
attiny.

[Peter II (Gast)]

Ben Banane schrieb:
> Geht's "noch" schöner?

memset( &Data, 255, sizeof( sizeof(Data) );

[eagle user (Gast)]

Ben Banane schrieb:

> Leider ist memset auch zu groß.

In dem Fall würde ich ein eigenes memset() bauen, also deine Schleife in 
eine Funktion packen -- rein zwecks der Schönheit. Als Bonus spart das 
auch Platz, sobald du es mehr als einmal brauchst.

[Rufus Τ. F. (rufus)]

Peter II schrieb:
> memset( &Data, 255, sizeof( sizeof(Data) );

Ein sizeof weniger.

struct irgendwas
{
  uint8_t etwas;
  uint8_t nochwas;
  uint16_t wasanderes;
  uint16_t nochwasanderes;
} Data;

memset(&Data, 255, sizeof (Data));

[edit]

memset soll zu groß sein?

Dann so:

struct irgendwas
{
  uint8_t etwas;
  uint8_t nochwas;
  uint16_t wasanderes;
  uint16_t nochwasanderes;
} Data;

uint16_t i;

for (i = 0; i < sizeof (Data); i++)
  ((uint8_t *) &Data)[i] = 255;

Das entspricht fast dem Vorschlag des Threadstarters, bis auf das 
Detail, daß der Index erst nach dem Typecast auf uint8_t* angewandt 
wird. Und das ist wichtig.

[Ben Banane (Gast)]

Wie gesagt, memset scheidet aus.

Also ist meine Schleife so korrekt? Ich könnte mit der Größe leben, 
störe mich momentan eigentlich nur an der Operation "+i", die Zweifel 
weckt, ob es noch kleiner ginge.

[Torsten R. (Firma: Torrox.de) (torstenrobitzki)]

Ben Banane schrieb:

> Also ist meine Schleife so korrekt?

Nein, Du solltest den nach uint8_t gecasteten Zeiger inkrementieren, 
nicht &Data

for ( i = 0; i < sizeof(Data); ++i ) 
    *( ( (uint8_t *)&Data ) + i) = 0xff;

mfg Torsten

[B. S. (bestucki)]

Ben Banane schrieb:
> Ich könnte mit der Größe leben,
> störe mich momentan eigentlich nur an der Operation "+i", die Zweifel
> weckt, ob es noch kleiner ginge.

Schon mal geschaut, was der Compiler daraus macht?

Anderer Vorschlag:

uint8_t * Actual = (uint8_t *)&Data;
const uint8_t * const End = (const uint8_t *)(&Data + 1); // zeigt auf die erste Speicherstelle hinter Data
while(Actual != End){
  *Actual = 0xFF;
  Actual++;
}

Um zu prüfen, welche Variante weniger Speicher belegt, muss du das 
ASM-Listing anschauen. Rechne damit, dass es bei der nächsten 
Compilerversion wieder anders sein kann.

[Peter II (Gast)]

Ben Banane schrieb:
> Wie gesagt, memset scheidet aus.

warum? hast du es mal gestestet (auch mit Optimierung)? Ich würde 
erwarten das der Compiler es inline als Schleife baut.

[Ben Banane (Gast)]

Die (korrigierte) Schleife ist kleiner als memset und passt! 
Optimierungen sind natürlich an. Die Standardfunktionen sind halt nicht 
immer das Optimum.

[Johann L. (gjlayde)]

Peter II schrieb:
> Ich würde erwarten das der Compiler es inline als Schleife baut.

Avr-gcc macht das bis dato (6.0) nur falls der Speicher gelöscht wird, 
d.h. wenn das 2. Argument 0 ist und falls die Anzahl der zu löschenden 
Bytes zur Compilezeit bekannt ist.