Klassen: Hilfestellung bei Interaktion von verschiedenen Objekten

#include "B.h"
A::zugriff( B& aB){
   aB.ausführen();
}

int main()
{
  A aA;
  B b1;
  B b2;

  aA.zugriff(b1);
  aA.zugriff(b2);

Daran ist was kompliziert?

irreal++

beim Methodenaufruf selbst ist nicht bekannt, ob jetzt b1 oder b2 aufgerufen werden soll.

DocShoe

Du solltest sämtlich Variablen so lokal wie möglich anlegen und bei Bedarf als Parameter in Funktionsaufrufen zur Verfügung stellen.
In deinem Fall könnte das so aussehen:

#include <iostream>

#include "Tamagotchi.h>

using namespace std;

void gehe_arbeiten( Tamagotchi& Tama )
{
   ...
   Tama.Geld += 3;
   ...
}

void experimentier_mit_magie( Tamagotchi& Tama )
{
   if( Tama.Geld > 2 ) Tama.Geld -= 3;
   else cout << "Zu wenig Geld zum Experimentieren!";
}

int main()
{
   Tamagotchi theTamagotchi;

   if( ... ) gehe_arbeiten( theTamagotchi );
   else if( ... ) experimentier_mit_magie( theTamagotchi );
}

rofl. Hab da zwei Threads miteinander verwechselt, daher das etwas seltsame Beispiel

Skym0sh0

irreal++ schrieb:

OK, nochmal von vorne:

Objekte von verschiedenen Klassen, die auf verschiedene Objekte (immer nur eines gleichzeitig) einer bestimmten Klasse B zugreifen wollen. Weil das ja nicht ohne weiteres geh (siehe Eingangspost), muss ja irgendwie die Adresse in die Methode kommen.
Die Frage ist jetzt: Wie setzt man des nun am Besten um?
Ich hätte jetzt an eine Variable gedacht, auf die alle Klassen bzw. Objekte zugreifen können, in welcher die aktuelle Adresse gespeichert wird.

Wenn es eurer Meinung nach bessere Lösungen gibt, bitte ich euch sie mir begründet darzulegen.

Du meinst sowas hier? (Bedenke, dass das nicht schön ist!)

Skym0sh0

irreal++ schrieb:

beim Methodenaufruf selbst ist nicht bekannt, ob jetzt b1 oder b2 aufgerufen werden soll.

Hä?

Um das mal weiter zu spinnen: Beim Funktiosnaufruf ist nicht bekannt welche der vielen (vielleicht sogar tausende oder millionen) Variablen benutzt werden soll?
Dann machst du was grundlegendes falsch

irreal++

Um das mal weiter zu spinnen: Beim Funktiosnaufruf ist nicht bekannt welche der vielen (vielleicht sogar tausende oder millionen) Variablen benutzt werden soll?
Dann machst du was grundlegendes falsch

Ersetze Variable durch Objekt. Die Anzahl wird erst während der Laufzeit bestimmt.

Es gibt verschiedene Einstellungesobjekte, die abhängig vom Benutzer erstellt werden. Aber es gibt immer nur eine aktives Objekt, auf welches gerade zugegriffen werden soll.
Zum Zeitpunkt des Programmierens weiß ich aber nicht auf welches Objekt zugegriffen werden soll. Ich weiß weder die Anzahl noch die Namen dieser.
Und um das Problem zu lösen würde ich eine Variable erstellen, die entweder den Namen des Objekts oder die Adresse enthält und ich direkt in die Methode einbauen würde.

irreal++

Hier der Code, wie ich mir das in etwa vorstelle:

config.h:

#ifndef CONFIG_H
#define CONFIG_H

class CONFIG {
public: 
   changeConfig(int kind);
};

#endif

exampleKlasse.h:

#ifndef EXAMPLEKLASSE_H
#define EXAMPLEKLASSE_H

class ExampleKlasse{
public: 
   sendchange();
};

#endif

exampleKlasse.cpp:

#include "exampleKlasse.h"
#include "config.h"

ExampleKlasse::change(){
   // Änderungen vornhemen
   *adresseDerAktivenConfig.changeConfig(3); //Mitteilen der Änderung an aktuelles config Objekt
}

#include "config.h"
#include "exampleKlasse.h" // in der Realität würden mehrere Klassen existieren, die das selbe tun (im Sinne vom Zugreifen auf ein Config Objekt)

int main()
{
   CONFIG adresseDerAkivenConfig;
   //es werden sämtliche configs erstellt und die adresse der aktiven in der Variable gespeichert
   //darauf greift irgendeine beliebige Klasse, hier von der Klasse ExampleKlasse auf die aktuelle Config Klasse zu:
   ExampleKlasse Exam;
   Exam.change();
}

irreal++

Ich frage mich hier nun, wie man das optimieren kann, ohne, dass man jetzt die Möglichkeit verliert, dass verschiedene Config Objekte erstellt werden können, wobei nur eine aktiv ist.

Ich könnte auch die Objekte als Array erstellen, jedoch müsste ich dann in jedem Objekt noch eine bool Variable haben, ob es aktiv wäre oder nicht. Bei jedem derartigen Methodenaufruf müsste ich dann das ganze Array der Reihe nach demjenigen durchsuchen, welches aktiv ist.
Dann wäre keine solche Variable wie im Beispiel notwendig, würde doch aber nicht so effizient sein wie sonst.

irreal++

Wo liegt das Problem?

daddy_felix

irreal++ schrieb:

Wo liegt das Problem?

Dir fehlt grundlegendes Verständnis.

irreal++

Gehts genauer?
Die Aussage hilft mir jetzt nämlich genau 0 weiter...

hustbaer

OMG mach mal konkret.
Was sind das für Klassen, was machen die, was für Config, wann soll die "umgeschaltet" werden, wieso nicht beim Funktionsaufruf etc.

Dann kann dir evtl. jemand sagen wie man das als erfahrener Programmierer lösen würde. So abstrakt kann man es nicht beantworten. Das was du machen willst ist zwar fast sicher Unsinn, aber um zu sagen was die weniger unsinnige Lösung wäre braucht man einfach mehr Informationen.

irreal++

Die anderen Klassen nehmen Einstellungen vom Benutzer auf und die configs sollen die Einstellungen verwalten. Umgeschaltet werden soll, wenn der der Benutzer andere Einstellungen verwenden möchte. Also ein Umschalten zwischen config1, config2 usw. und auf die umgeschaltete config soll dann auch von den anderen Klassen, die die Einstellungen vom Benutzer entgegen nehmen, aufnehmen und verarbeiten.

Wenn ich es direkt in den Funktionsaufruf einbauen würde, würde ich mich ja auf eine bestimmte config festlegen, statt, dass automatisch die aktive config genommen wird. Welche aktiv ist, erfährt man ja von der Variable.

Und umschalten beim Funktionsaufruf macht ja keinen Sinn, weil es ja unabhängig geschehen soll. Benutzer nimmt Einstellung vor != Benutzer möchte neue config verwenden/erstellen

irreal++

Immer noch nicht verständlich?

struct Config { ... };
struct ConfigChooser
{
  std::vector<Config> configs;
  int current;
  ConfigChooser()
  { // init configs }
  void choose() { ... current = 42; ... }
  Config& currentConfig()
  {
    return configs[current];
  }
};

struct ConfigUser
{
  void useConfig( Config& config ) { config.function(); }
};

int main()
{
  ConfigChooser cc;
  ConfigUser cu;
   ...
  cu.useConfig( cc.currentConfig() );

irreal++

Okay, aber wieso ist das nun eine bessere Lösung? Hier würde doch viel mehr Ressourcen benötigt werden, oder?

Zudem, wieso ausgerechnet struct und nicht class? weil man dann public: nicht braucht?

irreal++ schrieb:

Okay, aber wieso ist das nun eine bessere Lösung? Hier würde doch viel mehr Ressourcen benötigt werden, oder?

Dann zeig mal, wie du es mit weniger machst.

Zudem, wieso ausgerechnet struct und nicht class? weil man dann public: nicht braucht?

Das kannst du halten wie ein Dachdecker, nur nicht so hoch.

Ja wie ich die ganze Zeit schon sage: eine (globale )Variable, die z.b. die Adresse enthält.

irreal+++ schrieb:

Ja wie ich die ganze Zeit schon sage: eine (globale )Variable, die z.b. die Adresse enthält.

Zeig die gesparten Resourcen!