Instanz einer Klasse in einer anderen Klasse nutzen

TauCeti

Hallo,

ich will auf eine Instanz einer Klasse in einer anderen Klasse zugreifen.
Wie genau kann man dies mit Pointer/Referenzen ohne Setter/Getter lösen?

Beispiel unten:
Die Instanz der Klasse A wird im main erzeugt.
In Klasse A soll eine Funktion von Klasse B aufgerufen werden (evtl. A* a, a->function() ?)
In dieser aufgerufenen Funktion B:function sollen Variablen der Instanz classe A benutzt und beschrieben werden.

Verhält sich die Lösung anders, wenn B eine abgeleitete Klasse von A ist?

Vielen Dank für die Hilfe.

fileClasseC.cpp:

class A
{

	float m_variablen;

};

A:function()
{
  hier Aufruf von b:function

}

fileClassB.cpp:

class B
{

};

B:function()
{
  nutzen und beschreiben von m_variablen 

}

main.cpp:

int main(int argc, char *argv[])
{

	A start;

}

Von welcher B-Instanz soll eine Funktion aufgerufen werden?

also am einfachsten wäre es, die entsprechende methode in b als static zu deklarieren und dann einen float-wert zurück zu geben.

Belli

class A
{

    float m_variablen;

};

A:function()
{
  B objekt; // erst Mal ein Objekt erstellen
  hier Aufruf von b:function -->
  objekt.function(m_variablen); // m_variablen übergeben

}

fileClassB.cpp:

class B
{

};

B:function(float &x) //Referenz auf Float-Variable annehmen
{
  nutzen und beschreiben von m_variablen
  cout << x; //nutzen von m_variablen
  x = 3.14;  //beschreiben von m_variablen

}

TauCeti

Danke.

Das Problem ist allerdings, dass ich nicht auf eine einzige Variable zugreifen will, sondern auf mehrere Variablen und structs von Class A.

objekt.function(m_variablen);

Die kann ich ja nicht alle übergeben.

Du könntest ja this übergeben. Allerdings frage ich mich, ob es nicht ggf. einen einfacheren, nicht so stark gekoppelten Weg geben würde. Das ist aber ohne genauere Problembeschreibung schwer zu sagen.

es hört sich ein bisschen so an, als würdest du den unterschied zwischen klasse und instanz nicht genau kennen.

in der funktion aus klasse A brauchst du ein objekt vom typ B. wenn du das hast, kein problem; die frage, die du dir stellen musst: wer erzeugt objekt a vom typ A, wer erzeugt objekt b vom typ B? alles in main?

schließlich musst du einfach "nur" sicherstellen, dass die deklaration der beiden klassen (typischerweise in header-dateien) keine instanzen der jeweils anderen klasse verwenden (nur zeiger oder referenzen).

zum "übergeben" der einzelnen instanzen reichen dann referenzen, je nachdem, was du tun willst const oder nicht.

#include "A.h"
#include "B.h"

int main () { //kümmert sich um erzeugung/vernichtung von allem
   B b;
   A a{b}; //*irgendwie* muss a erfahren, dass es b gibt ("setter"), außer A erzeugt seine eigenen Bs
   a.function();
}

//A.h
struct B; //vorwärtsdeklaration *ist nötig*

struct A {
   B const& b;
   A (B const& b) : b{b} {}

   void function(); //NICHT im header definieren, weil B verwendet wird

   void print_result() { /* ... */ } //keine klassendefinition von B nötig, weil B hier nicht verwendet wird
};

//B.h
struct A; //vorwärtsdeklaration *reicht aus*

struct B {
  void calculate(A&) const; 
};

//A.cpp
#include "A.h"
#include "B.h" //jetzt erst ist zugriff auf die klassendefinition nötig

void A::function() {
  b.calculate(*this);
}

//B.cpp
#include "B.h"
#include "A.h" //jetzt erst ist zugriff auf die klassendefinition nötig.

void B::calculate(A& a) const {
   a.print_result();
}

wenn B von A erbt, ändert sich im header B.h, dass hier nun A.h eingebunden werden muss. eine vorwärtsdeklaration reicht dann nicht mehr aus.

ps nicht auf include guards bzw. pragma once vergessen.