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

Fehlermeldung: B' nicht bekannt....

Eigentlich ist das ja logisch: Aber ich muss leider auf B' zugreifen, weil es sonst extrem umständlich werden würde. Und es ist doch eigentlich der Sinn von OOP, dass man mit Objekten arbeitet, die untereinander kommunizieren etc.

Jetzt: Wie könnte ich jetzt da sinnvollerweise vorgehen um dieses Problem zu lösen?
Der Hintergrund wäre: Eine Klasse, die Einstellungen beherbergt und deren Änderungsanforderungen bearbeitet und viele andere Klassen, die über Methoden Einstellungen erhalten bzw. ändern wollen.

Ergänzung:
Es gäbe ja die Möglichkeit eine Variable anzulegen, welche einen Zeiger auf B' enthält und diese dann abfragen und damit dann auf das Objekt zugreifen.
Aber gibt es noch andere sinnvolle Vorgehensweisen, die Problematik zu lösen?

Es gäbe ja die Möglichkeit eine Variable anzulegen, welche einen Zeiger auf B' enthält und diese dann abfragen und damit dann auf das Objekt zugreifen.
Aber gibt es noch andere sinnvolle Vorgehensweisen, die Problematik zu lösen?

Sprichst du hier von einer globalen Variable? Im Regelfall: blöde Idee!
Oder meinst du als Member von A'? Kann man so machen.

Du kannst natürlich auch der Methode zugriff einen Parameter verpassen und beim Aufruf eine Referenz auf B' übergeben.

Naja ich hatte an eine fast-globale Variable gedacht: direkt in der Main Funktion, da ja fast sämtliche Objekte darauf zugreifen können sollen.

Wie soll das gehen?

Und weil sich das Objekt zwischendurch ändern kann, finde ich es persönlich einfacher über eine Variable zu gehen statt über einen Parameter.

Weil sich etwas ändert kannst du keinen Parameter nehmen? Ich glaube, du hast Parameter nicht verstanden.

Über Membervariablen muss ich mich erst informieren, dass kenn ich noch gar nicht.

Vielleicht solltest du erst mal ein gutes Buch durcharbeiten.

Wegen den Membervariablen: mir war der Begriff nicht so geläufig. Aber ist ja noch umständlicher...

Warum soll sie denn nur scheinbar einfach sein?
Ich verstehe halt in diesem Fall nicht den Vorteil wieso ich über Parameter vorgehen sollte, wenn ich in diesem trotzdem eine Variable erstellen müsste, die den Namen des richtigen Objekt enthält, von welchem ich anschließend wiederum die Adresse abfragen muss.
Da sehe ich es als einfacher einfach die Adresse in der Variable zu speichern und dann darauf über die Methoden der Klassen lesend zuzugreifen.
Wenn es nur scheinbar einfacher ist. Erklär mir bitte wieso...

Ich bin mir nicht sicher ob ich das verstanden habe...

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.

Daran ist was kompliziert?

#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

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!)

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

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.

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();
}

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.

Wo liegt das Problem?

Dir fehlt grundlegendes Verständnis.

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.

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

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