also so wie ich das verstehe
du hast eine klasse mit einer variabel und du hast 2 weitere klassen die diese variable verändern
du möchtest wenn sich die variable in einer der 2 klassen verändert sie sich auch in der anderen ändert
hier mal ein kleines beispiel wie man es machen kann, die erklärung dazu schreibe ich darunter
//classes.h
#ifndef CLASSES_H
#define CLASSES_H
#include <iostream>
using std::cout;
class Manager
{
//Variables
private:
int m_detector;
//Get & Set
public:
int GetDetector()
{
return m_detector;
}
//Constructors & Destructors
public:
Manager()
{
m_detector = 0;
}
~Manager()
{
}
//Methods
public:
void AssociateDetector(int** p2DetectorAssociation)
{
*p2DetectorAssociation = &m_detector;
}
};
/*abstract*/ class Visualizer
{
//Constructors & Destructors
public:
Visualizer()=0;
//Methods
public:
static void Visualize(int value)
{
cout << "Integer value: " << value << std::endl;
}
};
class ProcessorA
{
//Variables
private:
int* m_pDetector;
//Get & Set
public:
void SetPDetector(int* pDetector)
{
m_pDetector = pDetector;
}
//Constructors & Destructors
public:
ProcessorA()
{
m_pDetector = NULL;
}
~ProcessorA()
{
}
//Methods
public:
void ChangeValue(int newValue)
{
*m_pDetector = newValue * newValue;
}
};
class ProcessorB
{
//Variables
private:
int* m_pDetector;
//Get & Set
public:
void SetPDetector(int* pDetector)
{
m_pDetector = pDetector;
}
//Constructors & Destructors
public:
ProcessorB()
{
m_pDetector = NULL;
}
~ProcessorB()
{
}
//Methods
public:
void ChangeValue(int newValue)
{
*m_pDetector = newValue + newValue;
}
};
#endif
////////////////////////////////////////////////////////////////////////////
//main.cpp
#include "classes.h"
void main()
{
int** detector = new int*;
Manager manager;
ProcessorA processorA;
ProcessorB processorB;
manager.AssociateDetector(detector);
processorA.SetPDetector(*detector);
processorB.SetPDetector(*detector);
processorA.ChangeValue(5);
Visualizer::Visualize(manager.GetDetector());
}
Alles anzeigen
erstmals, wegen der übersicht hab ich nicht jede klasse in eine h und cpp datei unterteilt und nichtmal die implementierung von der deklarierung getrennt sondern alle funktionen sind gleich in den methodendeklarationen der klassen auch definiert, aber das spielt jetzt keine rolle
anstatt die klassen ABC.. zu nennen hab ich es halt logisch gemacht dass deine A klasse Manager heißt, da sie die variable detector enthält
dann gibt es B und C welche durch ProcessorA und ProcessorB repräsentiert werden und deine klasse D habe ich als eine abstrakte klasse Visualizer implementiert, bevor ich mit der erklärung anfange, ich schätze das wird schon so verwirrend genug für dich sein, also habe ich auf die verwendung von referenzen verzichtet und nur pointer benutzt, was referenzen sind hat man eh sofort kapiert wenn man das pointer konzept mal richtig begriffen hat also würden sie jetzt nur alles komplizierter machen
das ganze sieht jetzt so aus, die Manager klasse hat einfach eine int variable
ich weiß nicht ob du überhaupt schon mit pointern vertraut bist also versuche ich es von 0 weg zu erklären
wenn ich
schreibe erstelle ich eine variable x vom typ integer, verändere ich x zb mit x = 4 dann nimmt x den wert 4 an, klar
ein pointer ist wie der name schon sagt nichts anderes als ein zeiger auf eine variable, ein pointer wird mit * gekennzeichnet
es kommen zwei neue operatoren hinzu wenn man mit pointern arbeitet und zwar * und &
wobei * der dereferenzierungsoperator ist und & (ich hab ehrlich gesagt ka wie der operator heißt) operator holt dir die adresse/referenz/pointer von einer variable
also
//ich erstelle einen integer x
int x = 5;
//ich erstelle ein pointer auf einen integer
int* pointerToX;
//da der pointer die adresse auf einen integer enthält hole ich mir mit &
//die adresse auf x und weise sie pointerToX zu
pointerToX = &x;
//das würde mir die adresse von x ausgeben also irgend so
//ne zahl wie 6362732
cout << pointerToX;
//wenn ich aber den wert von x will muss ich den pointer dereferenzieren
//das gibt mir jetzt den wert 5 aus
cout << *pointerToX;
Alles anzeigen
diese pointer sind deswegen da weil wenn ich einen pointerToX1 habe und einen pointerToX2 und beide zeigen auf x und ich x ändere (entweder über x = 4; oder über *pointerToX1 = 4; oder *pointerToX2 = 4) dann naja.. ändere ich halt x und weil die beiden pointer auf x zeigen ändert sie sich demnach für beide pointer
und so machen wir das
die manager klasse hat ne detector variable, processora und processorb haben jeweils einen pointer auf die detector variable der manager klasse
alles was jetzt noch zu tun ist, ist den beiden pointern die adresse der detector variable zuzuteilen, weil data encapsulation ein grundprinzip der oop ist das nicht verletzt werden sollte machen wir die variablen also nicht public sondern erstellen get und set methoden und das ganze läuft jetzt so ab
die manager klasse hat eine associate funktion die einen pointer auf einen pointer bekommt... also ein zeiger auf einen zeiger auf einen integer (ich schreibe pointer im code immer mit einem p davor, ein pointer auf einen pointer mit p2, pointer auf pointer auf pointer mit p3 usw...)
dieser pointer auf den pointer auf den integer wird dereferenziert
also wenn wir int** dereferenzieren bekommen wir ein int* und diesem int* weisen wir jetzt die adresse von detector zu über &detector
aber wieso zur hölle wird ein int** übergeben? die antwort darauf ist: damit ich den pointer verändern kann.... wenn ich blos einen int* übergeben würde als parameter, wir erinnern uns ein parameter wird als value type übergeben und somit das objekt kopiert, und dann weise ich int* etwas zu dann hätte ich blos die kopie des parameters geändert
so ähnlich als wenn ich habe
int x;
fkt(int x)
x = 4;
und ich rufe fkt auf und gebe nach dem aufruf x aus dann ist es nicht 4, weil in der funktion eine kopie von x angefertigt wurde lediglich
wenn ich also x verändern will müsste ich einen pointer auf x übergeben und den dereferenzierten wert von x ändern dann wäre x auch nach dem funktionsaufruf 4
int x;
fkt(int* x)
*x = 4;
genauso ist es mit pointern, wenn ich den pointer selbst ändern will muss ich einen pointer auf den intpointer übergeben und diesen dereferenzieren und den intpointer ändern... naja das muss man mal verdauen um es zu verstehen
jedenfalls erstellen wir in der main einen int** detector, assoziieren den intpointer über die associate methode der manager klasse und dann weisen wir den pointer processora und processorb zu
das war auch die ganze zauberei dahinter (als wenn das nicht genug wäre *g*).. jedenfalls wenn jetzt detector entweder in manager oder processorA oder processorB geändert wird wird er halt überall geändert
und ja.. diese visualisierungsklasse hat einfach eine statische methode um ihn auszugeben und nur die manager klasse hat eine get funktion für detector, aber natürlich kannst du detector jetzt einfach in processora oder processorb verwenden, du musst ihn nur einmal dereferenzieren so wie in der changevalue methode
*m_pDetector = newValue * newValue;
das ist genauso wie mit dem *x = 4;.. am ja und.. lass dich jetzt nicht von dem * zwischen den newValues verwirren das ist einfach nur ein mal zeichen, processorA tut bei change value das quadrat von der überegeben zahl detector zuweisen und processorb 2 * die übergeben zahl