Alle variablen einer struct auf 0 setzen

[ZeroM]

Ich möchte gerne alle variablen eine Struct (die nur aus int variablen besteht) auf 0 setzen, ohne so vorgehen zu müssen:

struct myStruct
{
	int a, b, c;
	int aa, bb, cc;
	// ...
} ms;

// ...

void Irgendwas(void)
{
	// ...
	if (aufNull == true)
	{
		ms.a = ms.b = ms.c = 0;
		// ...
	}
	// ...
}

also auf jeden wert einzeln zugreifen müssen... Wenn es dazu eine winapi o.ä. gibt, oder es nur mit windows funktioniert, dann bitte verschieben (programmiere unter windows)

[Kóyaánasqatsi]

Für den Initialwert einfach einen default-ctor und für die 0-Zuweisung einfach eine Methode anlegen...

[ZeroM]

dann muss ich ja wieder auf jedes einzelne element zugreifen... das kann bei 200 und mehr elementen schon mühsam sein und den code aufblähen

[804000]

struct myStruct
{
    int a, b, c;
    int aa, bb, cc;
    // ...
}; 

int main()
{
	myStruct ms = {0};
}

[memsetter]

Bei POD-Typen kannst du einfach memset verwenden.

[drakon]

ZeroM schrieb:

dann muss ich ja wieder auf jedes einzelne element zugreifen... das kann bei 200 und mehr elementen schon mühsam sein und den code aufblähen

Wenn der Konstruktor alles auf 0 setzt, dann kannst du ja auch einfach die Zuweisung eines neuen, leeren Objektes benutzen.

Allerdings nehme ich mal an, dass das eher eine C artige (also POD) Struktur ist und daher kannst du memset benutzen. Wenn es allerdings kein POD ist, dann musst du das alles von Hand machen ja.

Was soll das überhaupt? Wenn es eine anständige Klasse ist, dann erreicht der Konstruktor die Invariante und somit brauchst du so ein "auf-0-setzen" gar nicht. Und wenn du dann auch noch einen Kopierkonstruktor hättest, kannst du ein Objekt auch ganz einfach auf seinen Anfangszustand zurücksetzen.

[Badestrand_]

ZeroM schrieb:

das kann bei 200 und mehr elementen schon mühsam sein

Arrays kennst du aber schon? Was sind das denn alles für Variablen?

[camper]

memset hilft nur bedingt und macht den Code unnötig komplex.

int main()
{
    T x1 = {0};     // (1)
    T x2 = {};      // (2)
    T x3 = T();     // (3)
    T* p = new T(); // (4)
}

(1) ist der Standardweg in C (sofern der Programmierer sich nicht schon "aus Geschwindigkeitsgründen" auf memset eingeschossen hat...).
(2) ist nur in C++ möglich und dort allgemeiner als (1), weil es auch mit leeren Aggregaten zurecht kommt oder solchen, deren erstes Element nicht per konstantem 0 initialisiert werden kann (beides gibt es in C nicht).
(3) funktioniert, falls T POD ist, oder einen entsprechend definierten Defaultkonstuktor besitzt.
(4) dito; im Falle von Arrays, falls (4) für die Elemente gilt.

[Burkhi]

Das kannst du ganz einfach so schreiben:

struct myStruct
{
    int a, b, c;
    int aa, bb, cc;
    // ...
} ms={};

Kein Tippfehler, zwischen den {} muss tatsächlich nix stehen.

[krümelkacker]

memsetter schrieb:

Bei POD-Typen kannst du einfach memset verwenden.

Das funktioniert auch so auf X64 oder X86. Auf anderen Platformen könnte das auch mal schiefgehen. Ich glaube, dass das nicht vom C++ Standard so garantiert wird. Zum Beispiel ist nicht gesagt, dass ein Nullzeiger durch eine Folge von Null-Bytes repräsentiert werden muss. Wenn Du eine Folge von Null-Bytes als Zeiger reinterpretierst, muss dass auch kein Nullzeiger sein. Bei Ganzzahlen aber erhältst Du durch das Löschen aller Bits der Repräsentierung auch wirklich die 0 als Wert.

[ZeroM]

Burkhi schrieb:

Das kannst du ganz einfach so schreiben:

struct myStruct
{
    int a, b, c;
    int aa, bb, cc;
    // ...
} ms={};

Kein Tippfehler, zwischen den {} muss tatsächlich nix stehen.

ich glaube ihr versteht mich falsch, ich möchte sie nicht von anfang an auf 0 haben, sondern beim aufruf von irgendwas...

arrays kenne ich schon, doch jede variable hat nen anderen namen und dann kenn ich mich mit arrays nicht mehr aus...

struct aaa
{
	int a, b;
} aA = {};

<-- das klappt

struct aaa
{
	int a, b;
} aA;

void aaaa()
{
	aA = {};
}

<-- das jedoch nicht :S

[Work0r]

Ja, wiegesagt, memset() wenn POD, ansonsten manuell.

[camper]

aA = aaa();

[Tachyon]

krümelkacker schrieb:

[...]Auf anderen Platformen könnte das auch mal schiefgehen. Ich glaube, dass das nicht vom C++ Standard so garantiert wird. Zum Beispiel ist nicht gesagt, dass ein Nullzeiger durch eine Folge von Null-Bytes repräsentiert werden muss.[...]

ISO/IEC 14882:2003 §4.10 schrieb:

A null pointer constant is an integral constant expression (5.19) rvalue of integer type that evaluates to zero. A null pointer constant can be converted to a pointer type; the result is the null pointer value of that type and is distinguishable from every other value of pointer to object or pointer to function type[...]

[Sebastian Pizer]

Tachyon schrieb:

krümelkacker schrieb:

[...]Auf anderen Platformen könnte das auch mal schiefgehen. Ich glaube, dass das nicht vom C++ Standard so garantiert wird. Zum Beispiel ist nicht gesagt, dass ein Nullzeiger durch eine Folge von Null-Bytes repräsentiert werden muss.[...]

ISO/IEC 14882:2003 §4.10 schrieb:

A null pointer constant is an integral constant expression (5.19) rvalue of integer type that evaluates to zero. A null pointer constant can be converted to a pointer type; the result is the null pointer value of that type and is distinguishable from every other value of pointer to object or pointer to function type[...]

Soll da jetzt ein Widerspruch zu sehen sein? Das Zitat aus dem Standard sagt nicht, dass ein "null pointer value" durch eine Folge von Null-Bytes repräsentiert werden muss. Es sagt lediglich, dass ein konstanter Ausdruck mit Wert 0 zu einem "null pointer value" konvertiert werden kann -- wie auch immer man ein "null pointer value" repräsentiert. Genausowenig wird garantiert, dass eine Folge von Null-Bytes als double-Wert interpretiert 0 ergibt.

void*  zeiger;
double fkzahl;
memset(&zeiger,0,sizeof(zeiger));
memset(&fkzahl,0,sizeof(fkzahl));
assert(zeiger==0); // <-- ist nicht garantiert
assert(fkzahl==0); // <-- ist nicht garantiert

zeiger = 0;
fkzahl = 0;
unsigend char zbyte = *reinterpret_cast<unsigned char const*>(&zeiger);
unsigend char fbyte = *reinterpret_cast<unsigned char const*>(&fkzahl);
assert(zbyte == 0u); // <-- ist nicht garantiert
assert(fbyte == 0u); // <-- ist nicht garantiert

...weil die Repräsentierung von Zeigerwerten und Fließkommawerten nicht vorgeschrieben ist -- auch nicht, wie ein Nullzeiger oder der double-Wert 0.0 im Speicher liegt.

Wenn Du im Standard dazu etwas findest und dies widerlegen kannst, lass ich mich gerne belehren.

Gruß,
SP

[Gast]

Da der OP ja bereits gesagt hat, dass das Ding nur aus int besteht ist die Sache doch hinfällig...