Ich habe von C++ leider nur Grundkenntnisse, also verzeiht mir bitte, falls meine Fragen trivial erscheinen. Ich plane gerade ein kleines Programm, für das 4 Dinge nötig wären, von denen ich nicht weiß, wie ich sie verwirklichen kann.

1. ich habe eine Klasse mit 16 Instanzen. Jede dieser Instanzen hat einige Variablen und Funktionen. Diese Funktionen müssten aber auch die jeweiligen Variablen der anderen Instanzen einsehen und ggf. verändern können.

Sprich: eine Funktion will zum Beispiel alle Variablen a aus allen Instanzen einlesen, zusammenrechnen und dann in die Variable b einer bestimmten Instanz schreiben. Ist das möglich und vielleicht sogar automatisierbar, so dass ich nicht jede einzelne Variable einzeln reinschreiben muss?

2. gibt es ein Befehl dafür eine bestimmte Funktion aus allen Instanzen gleichzeitig aufzurufen?

3. wie kann ich aus 16 int-Variablen am besten die mit dem höchsten Wert herausfinden?

4. was ist die beste Möglichkeit um einen Zufallswert zu generieren - also tumb Beispiel eine ganze Zahl zwischen 1 und 5?

Ich würde mich sehr über eure Hilfe freuen - gerne auch mit Links zu Tutorials, falls etwas ein bisschen schwieriger zu erklären ist.

LG,

Mike

#include <array>

std::array<int, 16> a;

Einen Zufallswert zwischen 1 und 5 generiert man so:

#include <iostream>
#include <random>

int main()
{
  std::random_device seeder;
  std::default_random_engine e(seeder()); // Oder mit irgendetwas anderem "seeden"
  std::uniform_int_distribution<unsigned> d(1, 5);

  for (unsigned i = 10; i-- != 0; )
    std::cout << d(e) << '\n';
}

Arrays eigentlich schon, aber bisher nicht im Bezug auf die Variablen verschiedener Klassen

Hä? Ich dachte du hast mehrere Instanzen einer Klasse? -

Likemike schrieb:

sondern eben lediglich als "Liste" verschiedener globalen Variablen.

Was haben globale Variablen jetzt damit zu tun?

Hi Cooky und vielen Dank für deine Antwort. Containerklassen kenne ich tatsächlich nicht. Arrays eigentlich schon, aber bisher nicht im Bezug auf die Variablen verschiedener Klassen - sondern eben lediglich als "Liste" verschiedener globalen Variablen. Da werde ich mich hier wohl nochmal genauer in die Materie einlesen. Hast du einen guten Tipp für ein tolles Tutorial? Sonst werde ich schon irgendwo eines finden...

Hallo Likemike,
1. Ein Tipp für ein Tutorial wird dir hier niemand geben. Nicht weil wir nicht wollen, sondern weil es keine guten Tutorials gibt. Hier werden nur Buchempfehlungen gegeben (siehe FAQ).
2. Streng genommen solltest du ein Array nicht als eine Liste von Etwas betrachten. Eine Liste kann beliebig viele Einträge haben. Die Anzahl Einträge eines Arrays ist stets fest.

Likemike schrieb:

Arrays eigentlich schon, aber bisher nicht im Bezug auf die Variablen verschiedener Klassen

Hä? Ich dachte du hast mehrere Instanzen einer Klasse? -

Likemike schrieb:

sondern eben lediglich als "Liste" verschiedener globalen Variablen.

Was haben globale Variablen jetzt damit zu tun?

Ah, tut mir leid, hab mich falsch ausgedrückt. Natürlich geht es um verschiedene Instanzen einer Klasse. Wie du siehst kenne ich mich mit Arrays nicht wirklich gut aus. Ich habe sie zumindest noch nie in so einer Weise verwendet und weiß auch auf Anhieb nicht wie - da muss ich mich jetzt halt erstmal ein bißchen reinlesen.

Was mir nur noch nicht so ganz klar ist: wie rufe ich denn eine Funktion in allen Instanzen gleichzeitig aus? Funktionen kann ich ja nicht in ein Array packen, oder?

Was mir nur noch nicht so ganz klar ist: wie rufe ich denn eine Funktion in allen Instanzen gleichzeitig aus? Funktionen kann ich ja nicht in ein Array packen, oder?

Hat cooky451 eigentlich schon gezeigt:

class A
{
public:
	void Funktion()
	{
	}
};

int main()
{
	std::array<A,16> ar; // Falls du std::array nicht verwenden kannst, nimmst du std::vector.

	for(int i=0; i<ar.size(); ++i)
	{
		ar[i].Funktion();
	}
}

Wenn ich das richtig verstehe, dann erstellst du hier ein Array der Größe 16 Namens ar, in dem die 16 Instanzen der Klasse sind. Mit der for Schleife springst du von einer Instanz nur nächsten und führst da jeweils die Funktion aus.

Ich habe das gerade bei mir versucht, allerdings nicht mit Funktionen, sondern mit int Variablen. Sprich:

array<A,10> ar;

    for(int i=0; i<ar.size(); ++i)
    {

		if (ar[i].flag=="b")
			result=result+ar[i].number;

    }

Das scheint aber so nicht zu funktionieren - muss ich die Variable innerhalb der Instanz anders ansprechen, oder habe ich insgesamt einen Denkfehler?

Wenn ich das richtig verstehe, dann erstellst du hier ein Array der Größe 16 Namens ar, in dem die 16 Instanzen der Klasse sind. Mit der for Schleife springst du von einer Instanz nur nächsten und führst da jeweils die Funktion aus.

Perfekt erklärt.

Zeig mal die Definition deiner Klasse.

Ist doch gut, dass es nicht funktioniert, denn, wenn man private-Member (ich hoffe, du hast number und flag private gemacht) ansprechen könnte, wären Klassen nutzlos. Mach dir entweder eine Funktion, mit der du den Wert von number ändern kannst oder nimm direkt eine struct, wenn es dir tatsächlich nur um die Zusammenfassung von Daten geht.

Sprich, eigentlich würde ich gerne die verschiedenen number Variablen aus allen Instanzen der Klasse A zusammenrechnen, deren flag Variable "b" ist.

class A
{	
public:
	string flag;
	int number;
};

int main()

A One;

One.flag="b";
One.number=4;

A Two;

Two.flag="a";
Two.number=2;

A Three;

Three.flag="b";
Three.number=8;

A Four;

Four.flag="a";
Four.number=5;

Ah, vielen Dank! So funktionierts... ich wusste nicht, dass ich die einzelnen Instanzen selbst reinpacken muss, aber eigentlich macht das auch Sinn!

Geld musst du auch selbst in deinen Geldbeutel tun, das fliegt auch net von selbst rein.

So, nächstes kleines Problem: jetzt möchte ich gerne eine Variable in der Instanz der Klasse verändern - und dafür verwende ich eine Funktion in der Klasse:

class A
{   
public:
    string flag;
    int number;
int apple;
int banana;
int gesamt;

void Funktion();
	{gesamt=apple + banana;
	}
};

int main()
{
    A One;

    One.flag="b";
    One.number=4;
One.apple=2;
One.banana=3;
One.gesamt=0;

    A Two;

    Two.flag="a";
    Two.number=2;
Two.apple=5;
Two.banana=8;
Two.gesamt=0;

array<A,2> ar = {One,Two};
    for(int i=0; i<ar.size(); ++i)
    {
        ar[i].Funktion(); 
		}

cout << One.gesamt << endl << Two.gesamt

Die Funktion wird zwar korrekt ausgeführt, nur die Variable der einzelnen Instanzen wird nicht verändert - woran liegt das?

array<A,2> ar = {One,Two};

Die Funktion wird zwar korrekt ausgeführt, nur die Variable der einzelnen Instanzen wird nicht verändert - woran liegt das?

= macht eine Kopie. Sprich One und Two werden kopiert, sprich ar[0] und ar[1] haben nichts mehr mit One und Two am Hut. Sprich du musst dann schon ar[0].gesamt ausgeben.

array<A,2> ar = {One,Two};
    for(int i=0; i<ar.size(); ++i)
    {
        ar[i].Funktion();
One.gesamt=ar[0].gesamt;
Two.gesamt=ar[1].gesamt;
        }

Ah, ok, das wusste ich nicht. Ist es denn auch möglich die Variable in der Originalinstanz zu verändern.

Ne. Container können keine Referenzen aufnehmen. D.h. du müsstest Zeiger auf One und Two speichern.

Likemike schrieb:

array<A,2> ar = {One,Two};
    for(int i=0; i<ar.size(); ++i)
    {
        ar[i].Funktion();
One.gesamt=ar[0].gesamt;
Two.gesamt=ar[1].gesamt;
        }

So gehts natürlich auch, allerdings ändert das nichts daran, dass die Elemente des Arrays und die beiden Objekte unabhängig voneinander sind.

Likemike schrieb:

Ah, ok, das wusste ich nicht. Ist es denn auch möglich die Variable in der Originalinstanz zu verändern.

Ne. Container können keine Referenzen aufnehmen. D.h. du müsstest Zeiger auf One und Two speichern.

http://en.cppreference.com/w/cpp/utility/functional/reference_wrapper

Ich wollte gerade mal das Programm ein bißchen aufräumen und Funktionen, die nicht Teil einer Klasse sind in einer Header Datei auslagern... wie bekomme ich es denn hin, dass er die in der main Funktion erst definierten Klassen und Werte in der Funktion übernimmt? Also zum Beispiel das hier in die Header Datei packt:

void apfelzaehler()
{
   for(int i=0; i<ar.size(); ++i)
    {
        allapples=One.apple+Two.apple;
        }
}

Und ich diese Funktion in der mein Funktion aufrufen kann (natürlich erst nachdem das Array ar und die beiden Instanzen One und Two definiert wurden)? Ist das überhaupt möglich, oder muss solche Funktionen in der main Funktion lassen?

Oder kann ich vielleicht sogar die Instanzen der Klasse direkt irgendwie in der Header-Datei erstellen?

Also ich würde gerne eine Funktion in der Header-Datei konfigurieren, die auf das Klassen-Array aus der int main() zugreift. Dafür muss ich ja, soweit ich weiß, einfach das Klassen-Array an die Funktion übergeben. Nur wie genau definiere ich das?

void apfelzaehler(Klasse ar[])

{...}

Hätte ich jetzt gedacht - also in der Klammer einmal den Namen der Klasse und dahinter einen von mir gewählten Begriff, wie das Array in der Funktion heißen soll, und die beiden [] um zu zeigen, dass es ein Array ist. Soweit noch alles richtig, oder habe ich hier schon einen Fehler gemacht? Ich habe auch schon versucht, die Größe des Arrays in die [] zu schreiben, aber das hat auch nicht geholfen.

Vielleicht ist aber auch mein Fehler erst beim Aufrufen. Um diese Funktion in meiner Main aufzurufen habe ich einfach:

apfelzaehler(ar);

geschrieben (ar heißt auch das Array in der Main).

Kann mir jemand vielleicht helfen und sagen, wo genau mein Fehler liegt?

Danke schon mal!

Mike

Kurz gesagt, ich habs grad selbst rausgefunden - mein Fehler war:

void apfelzaehler(Klasse ar[]) - ist falsch
void apfelzaehler(array<Klasse, 16> ar) -ist richtig.

Was ich allerdings nicht bedacht habe - ich übergebe ja so nur die Werte an die Funktion - in meinem Array in der Main verändert sich dadurch natürlich nichts. Also muss ich wohl etwas zurückgeben. Nur wie gebe ich das so zurück, dass praktisch dass Array in der Funktion, das Array in der Main überschreibt (bzw. nur die Werte, die sich in der Funktion verändert haben)?

ich übergebe das Array an die Funktion, und zwar bisher so:

apfelzaehler(ar);

Ist daran schon etwas falsch? Wie gesagt, in der Funktion wird auch alles richtig berechnet, nur das ändert eben nichts an dem array in der Main - wie gesagt, ich muss die Werte wohl zurückgeben, damit sie im Ursprungsarray überschrieben werden - nur weiß ich leider nicht wie.

Edit: Fehler im Code verbessert...