c++ variable in 2 Klassen aktualisieren

Du kannst ja den beiden Klassen eine Referenz oder einen Pointer auf die Variable übergeben, wenn du ein Objekt davon erstellst.

Kannst du bitte folgende 2 Dinge tun:

1. Dein Code ist nicht C++. Mach ihn dazu.
2. Ich verstehe deine Frage nicht ganz. Du willst, dass sich die Variable in beiden Klassen B und C updated, wenn du sie in einer der beiden änderst? Dazu brauchst du irgendeine Art von Verbindung zwischen den beiden Klassen. Mangels echtem Code kann man dir aber so nicht weiterhelfen.

suchst du sowas wie das observer pattern?

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

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

int x;

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;

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

Zitat von Vevusio

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

Aber wenn du sowieso nur 1 Variable hast, ändert sich die automatisch für alle Clients, egal woher sie geändert wird!

mäh... na schön ich formuiere es mal um:

"du hast eine klasse mit einer variabel und du hast 2 weitere klassen die kopien oder referenzen auf diese variable haben und möchtest dass wenn sich eine der kopien oder referenzen verändert sich die variable in beiden klassen ändert"

ich nehme das mal so an weil er geschrieben hat er hat ptcDetector in A und 2 variablen ptcDetector_ in B und C

aber obwohl es so mit den pointern geht würde man es ganz sicher nicht so lösen sondern wie sauzachn gesagt hat, die variable in klasse A einfach nur ein mal abspeichern, B und C hätten eine referenz auf A und über A.Get/SetPtcDetector() greifen beide auf ptcDetector zu anstatt dass sie jeweils eine ptcDetector_ variable haben

alternativ wenn du keine referenz auf A in B und C haben willst kannst du ptcDetector in A static machen und über A::Get/SetPtcDetector() darauf zugreifen

Zitat von KITT

also das prinzip scheint klar. aber wie mache ich das in der main methode mit
int** detector = new int*;
falls detector eine map < unsigned short, pair < unsigned short, bool > >
ist?
map<...>** detector = new map<...>*
?

Nein, so direkt geht das nicht. Ein ** ist ein Zeiger auf einen Zeiger. Du musst zuerst eine normale Zeigervariable anlegen und dann erst einen Zeiger auf diese Variable machen. In Langform:

map<blabla>* m = new map<blabla>(...);
map<blabla>** mm = &m;

Früher (und mit manchen Compilern wohl heute noch) ging auch:

map<blabla>** m = &(new map<blabla>(...));

Das ist aber kein gültiges C++ (wurde im GCC AFAIR erst eher spät als Fehler ausgegeben).