Strukturvariable über Schleife Werte zuweisen

[OnkelSepp]

Hallo,

ich glaube ich habe gerade einen ziemlichen Denkfehler...

Wie kann ich (oder geht das überhaupt) einer Struktur variablen Werte durch eine Schleife zuweisen?



Ich würde jetzt gerne "variable[x]" feste Werte zuweisen.
Meine Überlegung bis jetzt :

#include <iostream>
using namespace std;

struct meineStruktur
{
     int a;
     int b;
     int c;
};

meineStruktur meineFunktion (int nummer)
{
     
}

int main()
{
meineStruktur meineVariable[10];

for (int zaehler = 0; zaehler < 10; zaehler++)
{
meineVariable[zaehler] = meineFunktion(0);   // um z.B. "0" zuzuweisen...
}

return 0;
}

Ist der Ansatz richtig oder bin ich total auf dem falschen Weg.
Komme absolut nicht weiter...

 

[vfl_freak]

Moin,

hmm, siehst seltsam aus ... ;-)

Siehe folgende Kommentare:

#include <iostream>
using namespace std;

// keine Klasse ? ? ?

struct meineStruktur
{
  int a;
  int b;
  int c;
};

// da "meineStruktur" keine Klasse ist, geht es so nicht !!
meineStruktur meineFunktion (int nummer)
{ }

// "main" von was ? ? ?
int main()
{
  meineStruktur meineVariable[10];
  for (int zaehler = 0; zaehler < 10; zaehler++)
  {
  // würde natürlich allen 10 Werten "0" zuweisen...
  meineVariable[zaehler] = meineFunktion(0);
  }
  return 0;
}

Gruß
Klaus

 

[OnkelSepp]

#include <iostream>
using namespace std;
// keine Klasse ? ? ? 
struct meineStruktur
{
  int a;
  int b;
  int c;
};
// da "meineStruktur" keine Klasse ist, geht es so nicht !!
meineStruktur meineFunktion (int nummer)
{ }
// "main" von was ? ? ?
int main()
{
  meineStruktur meineVariable[10];
  for (int zaehler = 0; zaehler < 10; zaehler++)
  {
  // würde natürlich allen 10 Werten "0" zuweisen...
  meineVariable[zaehler] = meineFunktion(0);
  }
  return 0;
}

Hi,
danke schon mal für die Antwort.
Also:

Ich will das ohne Klasse lösen, da ich mich damit noch nicht beschäftigt habe.
Das allen Positionen der We "0" zugewiesen wird will ich ja erreichen.

Zur Erklärung vielleicht noch, da ich das oben vergessen habe, sorry:

ich möchte gerne die Positionen der Variablen mit Werten füllen, aber nur die die nicht bereits einen Wert haben.
Also alle Werte ausser "0" überspringen. Damit eine bereits belegte Position nicht überschrieben werden kann.
Dazu würde ich gerne die Werte zu Anfang alle auf "0" setzen.

 

[deepthroat]

Moin,

hmm, siehst seltsam aus ... ;-)

Vor allem deine Kommentare sehen seltsam aus...

Siehe folgende Kommentare:

#include <iostream>
using namespace std;

// keine Klasse ? ? ?
/**** macht nix ****/

struct meineStruktur
{
  int a;
  int b;
  int c;
};

// da "meineStruktur" keine Klasse ist, geht es so nicht !!
/**** Falsch. Faktisch gibt es kaum einen Unterschied zwischen stuct und class ****/
meineStruktur meineFunktion (int nummer)
{ }

// "main" von was ? ? ?
/**** vom Programm? Was soll die Frage? Bist du sicher, das du schonmal C++ gemacht hast? :p ***/
int main()
{
  meineStruktur meineVariable[10];
  for (int zaehler = 0; zaehler < 10; zaehler++)
  {
  // würde natürlich allen 10 Werten "0" zuweisen...
  meineVariable[zaehler] = meineFunktion(0);
  }
  return 0;
}

Feste Werte kann man ziemlich einfach mit Initialisierungsblöcken zuweisen:

meineStruktur meineVariable[10] = {
  { 0, 0, 0},
  { 0, 0, 0},
  ...
};

 

[cwriter]

Hallo

@vfl_freak
Das ist halt C und nicht C++. In diesem Zusammenhang ist der Code, wie deepthroat schon gesagt hat, völlig korrekt (Mal davon abgesehen, dass "MeineFunktion" nichts zurückgibt und damit ungültig ist).
@OnkelSepp
Auf 0 setzen: Entweder händisch

MeineStruktur ms;
ms.a = 0;
ms.b = 0;
ms.c = 0;

oder dann ein bisschen lustiger:

MeineStruktur init()
{
MeineStruktur* tmp = calloc(1,sizeof(MeineStruktur)); //Setzt den Speicher gleich auf 0
//auf NULL testen
MeineStruktur ret = *tmp;
free(tmp);
return ret;
}

Vorteil: Ist lustig, relativ schnell, wenn man ohnehin mit Pointern arbeiten will, hübsch.
Nachteil: Vergleichsweise langsam in diesem Beispiel.
Alternativ natürlich mit der initalizer_list, wie deepthroat schon angemerkt hatte.
Wenn du ohnehin sehr oft auf die einzelnen Werte zugreifen musst, könntest du dir auch eine Zerlegung in ints überlegen:

MeineStruktur ms;
ms.a = 15;
ms.b = 34;
ms.c = 12;
int* MSArray = calloc(3,sizeof(int));
//NULL und so...
memcpy_s(MSArray, sizeof(MeineStruktur), &ms, sizeof(MeineStruktur));
//MSArray[0] == a == 15
//MSArray[1] == b == 34
//MSArray[2] == c == 12
//Wieder freigeben

Oder entsprechend typedefs und casts verwenden. Diese Variante ist vor allem bei grösseren structs hilfreich, da man einfach durchiterieren kann.

Alle Codes ungetestet.
Gruss
cwriter

/EDIT: Wenn man vor lauter Bäumen den Wald nicht sieht...
memset()!

MeineStruktur ms;
memset(&ms, 0, sizeof(MeineStruktur));

Das ist der perfekte C-Weg.