Variable für mehere Klassen zugänglich machen

GPC

Jo, also besser wären schon getter, aber wenn du es für angebracht hältst, wäre es auch möglich, dass du die zweite Klasse zum friend der ersten machst. So kannst du das Attribut private lassen und die andere Klasse hat trotzdem Schreibzugriff (was ja beim reinen getter normalerweise nicht der Fall ist).

Ozzy

Sorry, von getter und setter habe ich noch nie etwas gehört... Und von friend auch nicht...
Könnt Ihr mir vielleicht kurz erklären, wie das mit getter und setter funktioniert?

MfG, Ozzy

GPC

Jo, also getter und setter:

#include <iostream>

//Konstruktoren usw. spar ich mir jetzt mal...
class Foo {
  int value;

public:
  //setter, man beachte das if, welches nur Werte größer 0 zulässt
  void set(int i) {
    if (i > 0)
      value = i;
  }

  //getter
  int get() const { return value; }

  //Wir machen Klasse bar zum Freund dieser Klasse, das heißt Bar darf auf private Elemente schreibend zugreifen.
  friend class Bar;
};

class Bar {

public:
  void fun(Foo &f) { f.value = -1; }  //uh ah
};

int main() {
  Foo f;
  f.set(7);

  Bar b;
  b.fun(f);
  std::cout<<f.get()<<std::endl;

  return 0;
}

Wie du siehst, kann man mit friend ziemlich böse Sachen machen. So wurde in dem Fall die if - Prüfung von Foo.set einfach übergangen, weil ich direkt auf Foo.value schreiben konnte.

MfG

GPC

Ozzy

Sorry, aber so ganz habe ich das dann doch nicht verstanden.
Angenommen, ich hätte in einer Klasse einen Vektor definiert;

vector<int> vektor;

Wie kann ich dann aus der anderen Klasse darauf zugreifen? Also ohne get und set am liebsten???
Bei mir kann er schon mit dem

Ram RAM

nicht umgehen (also Ram ist Klassenname). Muss ich denn die Header der Dateien noch irgendwie besonders includen in der anderen Datei?

MfG, Ozzy

CStoll

Bist du dir überhaupt klar, was du vorhast? Eine Member-Variable gehört immer zu einem bestimmten Exemplar deiner Klasse (ausgenommen statische Member, die gehören der gesamten Klasse). Und diese Exemplare kannst du überall anlegen, wo du es brauchst.

class C1
{
private:
  vector<int> data;
  static int global;
  friend class C2;//hiermit bekommt C2 vollen Zugriff auf C1's private Elemente
  ...
};

class C2
{
public:
  void fill(C1& user)//bekommt ein C1 Objekt übergeben
  {
    int val = ...;
    user.data.push_back(val);//Zugriff auf normalen Klassen-Member
    C1::global=val;          //Zugriff auf statischen Member
  }
  ...
};

Ozzy

Hi,

also was ich vorhabe, ist mit klar; nur eben nicht wie!

Um noch einmal genau zu schreiben, was ich möchte:
Ich habe 6 Dateien:
mac.h
mac.cc
ram.h
ram.cc
dis.h
dis.cc

in der ram.h habe ich einen Vektor RAM definiert, auf den dann die Funktionen aus mac und dis zugreifen sollen; lesend und schreibend. Und das bekomme ich eben nicht hin, irgendwie auch nicht mit dem fried class...

MfG, Ozzy

CStoll

Wo genau steht denn dieser Vektor?
Innnerhalb der Klasse "ram"? - da brauchst du ein Objekt, über den du zugreifen kannst
Global? - da wäre sicher eine extern-Definition das richtige?
...

(oder kurz: mit deinen Angaben verwirrst du alle Anwesenden - zeig doch einfach etwas Code, wie du das Programm bisher aufgebaut hat (inklusive möglicher Fehlermeldungen))

Ozzy

Hi,

also ehrlich gesagt ist es mir egal, wo der Vektor steht...
Das ganze handelt sich qausi um eine Simulation, weshalb ich diese "Umgebung" aufrecht erhalten muss.
Wichtig ist eben nur, dass mac und dis auf den Vektor in ram zugreifen können.

Code gibt es bisher kaum; das war so gut wie mein Anfang...

MfG, Ozzy

CStoll

Da hast du prinzipiell drei Möglichkeiten, das Problem anzugehen:

als normale Membervariable der Klasse ram
(in dem Fall hat jedes Objekt dieser Klasse seinen eigenen Vektor und du kannst über normalen Member-Zugriff daran gelangen)

//ram.h
class ram
{
public:
  vector<int> data;
};

//irgendwo in einer der anderen Klassen:
#incude "ram.h"
...
ram my_ram;
int datalen = my_ram.data.size();
...

als statische Membervariable der Klasse ram
(das heißt es gibt einen Vektor für alle Objekte der Klasse)

//ram.h
class ram
{
public:
  static vector<int> data;
};

//ram.cc
#include "ram.h"
vector<int> ram::data;

//irgendwo anders
#include "ram.h"
...
int datalen=ram::data.size();//der Zugriff wie in Beispiel (a) ist auch möglich

als globale Variable
(die ist dann unabhängig von einer der Klassen verfügbar

//ram.h
extern vector<int> data;

class ram{...};

//ram.cc
#include "ram.h"
vector<int> data;

//irgendwo anders
#include "ram.h"
...
int datalen=data.size();

Such dir die Variante aus, die am geeignetsten ist

PS: Im Fall a und b würde ich vermutlich die Variable privat definieren und nur über definierte (normale bzw. statische) Methoden auf ihren Inhalt zugreifen.

Ozzy

Hi,

vielen, vielen Dank für Deine super ausführliche Antwort!!! Ich habe auch das Richtige für mich gefunden!!!

Vielen Dank noch einmal, Ozzy