privat Problem

chewbo

Hiho.
Folgendes Problem. meine Abgeleitete Klasse kann nicht auf das Private zeug zugreifen. Dabei muesste ich doch, nachdem ich sie abgeleitet habe auf die private variablen der oberen klasse genauso zugreifen können wie auf die neu hinzugekommenen.
Das Programm:

#include<iostream>
#include<fstream>
#include <string>

using namespace std;

class A{
private:
  string something;
public:
  A(string s):something(s){}
virtual ostream&  print(ostream& os){
  return os<<something;
}

friend  bool operator<<(ostream& os,A& klasse){
    return klasse.print(os);
  }
};

class B: public A{
private:
  int a;
public:
  B(int ia,string s):a(ia),A(s){}
ostream&  print(ostream& os){
  return os<<something<<a;
}
};

int main(){
  A a("Hallo");
  B b(5,"Hallolo");

  ofstream of("t.txt");

  cout <<a;
  cout<<b;

  of<<a;
  of<<b;

  return 0;
}

Der Kompiler Error:

ab.cc: In member function `virtual std::ostream& B::print(std::ostream&)':
ab.cc:9: Fehler: »std::string A::something« ist privat
ab.cc:27: Fehler: in diesem Zusammenhang

hmm wo ist der Fehler.
Brat mir einer nen :xmas2: ich komm nicht drauf
MFG
chewbo

privat bedeutet das nur genau die Klasse darauf zugrifen kann.
Was Du willst nennt sich protected.

chewbo

Ahh cool. Hab ich das auchmal verstanden. Danke. Das heisst also wenn ich was in protected schreibe ist es private nur das die abgeleitete Klasse auch darauf zugreifen kann?

Ja. Sind halt drei Zugriffs-Stufen:

privat: Nur die klasse selbst hat Zugriff.

protected: Abgeleitete Klassen haben auch Zugriff.

public: Auch andere Klassen haben Zugriff.

David_pb

Lass es lieber private und such dir eine andere Lösung. Auch protected verletzt die Kapselung deiner Objekteigenschaften. Ein Beispiel:

class Base
{
private:
	std::string foo;

public:
	Base( const std::string& foo_ )
		: foo( foo_ )
	{}

	// ...

	virtual std::ostream& print( std::ostream& stream ) const
	{
		return stream << foo;
	}
};

class Derived
	: public Base
{
private:
	int value;

public:
	Derived( const std::string& foo_, int value_ )
		: Base( foo_ ), value( value_ )
	{}

	// ...

	virtual std::ostream& print( std::ostream& stream ) const
	{
		return Base::print( stream ) << value;
	}
};