Kein Zugriff auf Basisklassenelement trotz friend

cbk18

Hallo!

Ich hab folgendes Problem:
Hab zwei Klassen geschrieben, wobei die eine von der anderen erbt.
Die erbende Klasse ist friend der Basis-klasse, damit die erbende
Klasse auf privat und protected-Werte der Basisklasse zugreifen kann.
Aber irgendwie funktioniert das nicht so, wie ich dachte.

Hab da mal so beispielhaft die Klasse beschrieben, damit mein Problem
leicher zu verstehen ist.
Also ich will auf die Variable z1 in einer Funktion der Klasse ab1
zugreifen können.

Warum geht das nicht und wie kann ich dem Abhilfe schaffen, ohne
die Elemente der Basisklasse puplic zu machen.

class basis
{
protected:
    int z1;
[...]

friend class ab1;

[...]
}

class ab1 : public basis
{
  void ausgabe(basis testobj)
  {
  cout << testobj.z1; // kann auf z1 nicht zugreifen, weil protected
  } 
}

Danke an die Helfenden!

ChrisM

Als abgeleitete Klasse hat abl doch schon automatisch Zugriff auf protected-Elemente der Basisklasse, auch ohne friend!

ChrisM

DrGreenthumb

Warum geht das nicht und wie kann ich dem Abhilfe schaffen, ohne
die Elemente der Basisklasse puplic zu machen.

Doch das geht mit friend. Weiß nicht was du falsch gemacht hast.

Aber irgendwie ist das ganze nicht so das wahre.. Was hast du denn vor?

@ChrisM
Man hat zugriff auf die eigenen Elemente, also die, die man geerbt hat. Aber in void ausgabe(basis testobj); ist testobj ein anderes Objekt.

phlox81

Wofür gibt es get und set funktionen ?

Devil

cbk18

Hi!

Die Basisklasse enthält allgemein Elemente in einer verketteten Liste.
Die abgeleitete Klasse soll ebenfalls Elemente enthalten, allerdings sollen diese sortiert gehalten werden. d.h. ich lassen die einfach erben, so dass die Variablen, z.B. Zeiger auf ersten Knoten usw auch in der abgeleiteten Klasse stehen.

Nun soll aber eine Konversion möglich sein,
ich bilde über die operator+(...)-Funktion nun die Schnittmenge. Die operator+ Funktion soll auf alle 4 möglichen Kombinationen zwischen Basisklasse und abgeleiteter Klasse möglich sein, daher steht sie in der Abgeleiteten Klasse.

Allerdings muss diese Oper.+-Funktion ja dann auf den Anfangszeiger der Basisklasse zugreifen können.
Das habe ich versucht zu lösen. Geht nicht

Geht das irgendwie eleganter?

thx

cbk18

@devil

Ich darf keine weiteren get- und setfunktionen einfügen.

Muss das Programm in der Schule schreiben und unser Dozent ist da sehr pingelig. Also zusätzliche Funktionen sieht der gar nicht gerne.

DrGreenthumb

Dein Beispiel wird bei mir anstandslos compiliert (bis auf das zwei Semikolons fehlen).

cbk18

Ich kann ja hier einfach mal die konkreten Teile einbinden, vielleicht ist da auche in Denkfehler meinerseits drin:

Basisklasse:

#ifndef SET_H
#define SET_H

struct ErrorMsg {};

class Set
{
protected:

  class Lnode
    {
    public:

    int val;
    Lnode *next;
    friend class Set;
    };

   int Size;
   Lnode *pstart;

 public:
    Set();
    Set(int val);
    ~Set();
    Set(const Set &m);

    int size();

    int insert(int val);
    int remove(int val);
    int empty();
    int element(int val) const;
    void print() const;
    Set &operator=(const Set &menge);

    friend Set operator+(const Set &menge1, const Set &menge2);
    friend Set operator*(const Set &menge1, const Set &menge2);
    friend int operator<=(const Set &menge1, const Set &menge2);
    friend int operator==(const Set &menge1, const Set &menge2);

    friend class SetS;
    /* andernfalls kann SetS &operator=(const Set &menge)
       nicht auf die protected-Elemente zugreifen */
};

inline int Set::size()
{
return Size;
}

#endif

Abgeleitete Klasse:

#ifndef SETS_H
#define SETS_H

#include "set.h"

class SetS : public Set
{
public:
    SetS();
    SetS(int val);
    ~SetS();

    int insert(int val);

    int &operator[](int index); 
    SetS &operator=(const Set &menge);

    void sortSetS();

    friend SetS operator+(const SetS &menge1, const Set &menge2);
    //friend Set operator*(const Set &menge1, const Set &menge2);
    //friend int operator<=(const Set &menge1, const Set &menge2);
    //friend int operator==(const Set &menge1, const Set &menge2);

};
#endif

Und die Problemdatei mit den Implementierungen:
(nur die eine Problemfunktion davon)

SetS operator+(const SetS &menge1, const Set &menge2)
{
SetS unionSet;

SetS::Lnode *psortSet = menge1.pstart;
Set::Lnode *punsortSet = menge2.pstart; // HIER FEHLER!!! KEIN ZUGRIFF WEIL //PROTECTED

}