Verbung und Variablen

Hallo zusammen.

Ich stehe gerade vor einem großen Problem, wo ich mir nicht weiterhelfen kann.

class XX{
   protected:
     int a;
};

class YY : public XX{
};

Dies soll mal als Beispiel dienen.

Ich möchte nun mit den Funktionen aus YY auf die Variable a zugreifen. Soweit kein Problem. Nur würde ich gerne nicht eine neue Instanz der Variable anlegen, sondern mit dem gleichen Inhalt weiterarbeiten, da Funktionen aus der Basis-und der Abgeleiteten Klasse den Inhalt verändern und brauchen.

Spontan fällt mir natürlich irgendetwas mit Zeigern ein, doch ich weiß leider nicht weiter.

Stefan

BorisDieKlinge

d.h. du willst ein und die selbe variable aller instanzen der klasse verwenden?
wenn ja musst du sie mit "static" deklarieren.... dann igbt es die variable nur einmale für alle instanzen der klasse

muffmolch

ups, falsch verstanden...

was mein vorredner meint ist:

class XX{
   protected:
   static int a;
};

class YY : public XX{
};

somit ist XX::a nur ein einziges mal im system vorhanden bzw. in dem prozess.

BorisDieKlinge

hää??? und was ist nun?? hmm gut hab wohl recht ...

Wenn ich die Variable mit Static deklariere bekomme ich haufenweise Linker Error, wegen unaufgelösten Verweisen. Veilleicht liegt es daran, dass es bei mir eine ganze Struktur ist?

class XX{
   protected:
   static struct direntries{
       queue<string> aBilder, copy_aBilder;
       int count;
   }direntries;
};

class YY : public XX{
};

Aber wie greif ich nun darauf zu, ohne die unaufgelösten Verweise zu bekommen?

CStoll

Der Zugriff ist schon richtig über "XX::direntries", allerdings mußt du die Variable noch definieren:

//an einer zentralen Stelle im Programm:
struct XX::direntries XX:direntries;

(übrigens ist es eine sehr schlechte Idee, für den struct-Typ und die Variable den selben Namen zu verwenden)

Leider funktioniert das alles irgendwie nicht richtig. Ich hab jetzt deshalb mal ein kleines Beipielprogramm geschrieben. Villeicht /Hoffentlich kann mir jemand sagen, wo der Fehler liegt.

//////////
//main.cpp

#include <iostream>
#include "k.cpp"

int main()
{
   KLASSE1 kl1;
   KLASSE2 kl2;

   kl1.t1();
   kl2.t2();

   return 0;
}

//////////
//k.h

class KLASSE1{

   public:
      void t1(void);

  protected:
     static struct alpha{
        char* a;
        char* b;
     };

};

class KLASSE2 : public KLASSE{

   public:
   void t2(void);

};

//////////
//k.cpp

#include <iostream>

using namespace std;

#include "k.h"

void KLASSE1::t1(void)
{
   KLASSE1::alpha.a = "erstens";
   KLASSE1::alpha.b = "zweitens";
}

void KLASSE2::t2(void)
{
   cout << KLASSE1::alpha.a<< "\n" << KLASSE1::alpha.b;
}

Ich bekomme folgende Fehlermeldungen:
In file included from k.cpp:5,
from main.cpp:2:
k.h:10: error: static' can only be specified for objects and functions k.h:15: error: expected class-name before '{' token In file included from main.cpp:2: k.cpp: In member functionvoid KLASSE1::t1()':
k.cpp:9: error: expected primary-expression before '.' token
k.cpp:10: error: expected primary-expression before '.' token
k.h: In member function void KLASSE2::t2()': k.h:7: error:struct KLASSE1::alpha' is protected
k.cpp:15: error: within this context
k.cpp:15: error: expected primary-expression before '.' token
k.h:7: error: `struct KLASSE1::alpha' is protected
k.cpp:15: error: within this context
k.cpp:15: error: expected primary-expression before '.' token

/edit

Wenn ich das struct in public lege, verschwinden schon mal die "is protected" Fehler. Der Rest bleibt. btw müsste ich aber doch auf protected Zugriff haben?

CStoll

Erstens: .cpp's solltest du nicht per #include einbinden - in der main.cpp reicht ein #include "k.h"

Zweitens: Du hast dort einen statischen Untertyp definiert - sowas mag C++ nicht. Besser sieht es so aus:

class Klasse1
{
  ...
protected:
  struct alpha_t
  { char*a,*b;}
  static alpha_t alpha;
};

Drittens: Ich wurde vor einer Weile belehrt, daß abgeleitete Klassen nur die "eigene" Instanz von protected-Membern verwenden dürfen. Und innerhalb der Klassen ist es auch eindeutig, welche Variable gemeint ist, also kannst du dort das "Klasse1::" weglassen.

Viertens: Und in der k.cpp fehlt noch ein Eintrag:

Klasse1::alpha_t Klasse1::alpha;

Soweit hab ich alles verstanden und ist auch klar. Wenn ich allerdings in der main ein #include "k.h" setze, bekomme ich unaufgelöste Verweise zu den Funktion.

Könntest du mal bitte den kompletten richtigen Code posten?

CStoll

Du mußt die beiden CPP-Files auch getrennt compilieren und dann vom Linker zusammenführen lassen (welchen Compiler verwendest du? davon hängt es ab, wie du das machen mußt).

Ich benutze g++.

Alles klar, vielen Dank.
Habs hinbekommen.