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)

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.

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

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

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.

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

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

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.

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

[...]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[...]

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