Die public Methoden meiner Klasse sollen auf weitere Methoden zugreifen, die vom Klienten veraendert werden koennen bei Bedarf. Diese veraenderbaren Methoden benoetigen Zugriff auf einige Member der Klasse. Ich habe das momentan mit dem template method pattern geloest:

class P {
public:
  void foo() {bar1(); bar2(); bar3();}
  virtual ~P() {}
protected:
  virtual void bar1() {i1 = 3;}
  virtual void bar2() {i2 = 4;}
  virtual void bar3() {i3 = 5;}

  int i1, i2, i3;
};

Der Klient kann so von der Klasse ableiten, die bar-Methoden bei Bedarf ueberschreiben und alles ist schoen - bis auf den uneingeschraenkten Zugriff aller ableitenden Klassen auf i1, i2, i3.

Gibt es eine Moeglichkeit, den Zugriff auf die bar-Methoden der ableitenden Klassen zu beschraenken?

class T : public P {
protected:
  virtual void bar1() {i1 = 15;} //FEHLER: i1 ist private member von P udn in T nicht zugaenglich
};

obiges sollte aber moeglich sein. Andererseits will ich folgendes verhindern:

class U: public P {
public:
  void meep() {i1 = 24;}  //ist erlaubt, da i1 protected member von P
};

Wie gesagt, auf i1, i2, i3 soll in abgeleiteten KLassen zugegriffen werdne koennen, allerdings NUR innerhalb der bar() methoden

class P
{ 
public: 
  void foo()
  {
    access = true;
    bar1();
    bar2();
    bar3();
    access = false;
  }

  virtual ~P() {}

protected:
  void SetI1(int i)
  {
    if (access)
      i1 = i;
  }

  void SetI2(int i)
  {
    if (access)
      i2 = i;
  }

  void SetI3(int i)
  {
    if (access)
      i3 = i;
  }

  virtual void bar1()
  {
    SetI1(3);
  }

  virtual void bar2()
  {
    SetI2(4);
  }

  virtual void bar3()
  {
    SetI3(5);
  }

private:
  bool access;
  int i1, i2, i3; 
};

Ich denke mal, das ist (so in etwa) was du wolltest.

Gruß,
DeSoVoDaMu

die Regel ist doch ganz einfach: Felder immer privat. Dann definierst Du Dir in der Basisklasse protected-Setter-Methoden für die Felder, die Dir den Zugriff regulieren.

Frage: Dürfen die bar()-Methoden der abgeleiteten Klassen deine Member beliebig ändern? Oder nur innerhalb der Möglichkeiten, die du vorgesehen hast?
(und aus persönlichem Interesse: Was ist der Sinn dieser Klasse?)

TPlot.h:

#ifndef TPlot_h
#define TPlot_h
#include <memory>

#ifndef __CINT__
typedef double Double_t;
#endif

class TH1;     //Histogramm-Klasse
class TAxis;   //Histogramm-Achsen
class TCanvas; //Zeichenfeld
class TString;
class TLegend; //Legende fuer Zeichnungen

class TPlot {
private:
  //hide copies
  TPlot& operator= (TPlot const&);
  TPlot(TPlot const&);
  //============

  /* Viel privates... */

public:
  TPlot(TH1* data, TH1* direct, TH1* resolved, bool log_b = true, bool lin_b = true);
  virtual ~TPlot();

  void ShowLinear(bool);
  void ShowLog(bool);

#ifdef __CINT__  
  void ShowLegends(unsigned char flags = 3 );
#else //CINT kommt mit den Shiftoperatoren nicht klar
  void ShowLegends(unsigned char flags = 1<<0 | 1<<1 );
#endif

  void Plot();
  void Print(TString const& psname);

  class BadInstantiated {};

protected:
  std::auto_ptr<TH1> data_;
  std::auto_ptr<TH1> direct_;
  std::auto_ptr<TH1> resolved_;
  std::auto_ptr<TH1> mcall_;

  virtual void SetGlobalStyles() const;
  virtual void SetXaxisStyles(TAxis* xaxis);
  virtual void SetYaxisStyles(TAxis* yaxis);
  virtual void SetHistoStyles();
  virtual void SetPadStyles();
  virtual void SetLegendStyles(TLegend* legend);
};

#endif

TPlot.cxx

/* andere Methoden */
void TPlot::Plot()
{
  if (plotgood()) return;
  if(!lin && !log) {
    cerr << "Error in <TPlot::Plot()>: Both linear and logarithmic set to false - nothing to plot.\n";
    return;
  }

  TH1* const maxhist = 
    (mcall_->GetMaximum() > data_->GetMaximum()) ? mcall_.get() : data_.get();

  //Set plot styles
  SetGlobalStyles();                     //AUFRUF 
  SetXaxisStyles(maxhist->GetXaxis());   // DER
  SetYaxisStyles(maxhist->GetYaxis());   //VIRTUELLEN
  SetHistoStyles();                      //FUNKTIONEN

  //make canvas
  const int nxpads = lin&&log ? 2 : 1;
  const int canvwidth = 500*nxpads;
  const int canvheight = 300;
  canvas_.reset(new TCanvas);
  canvas_->SetCanvasSize(canvwidth, canvheight);
  canvas_->SetWindowSize(canvwidth+50, canvheight+50);
  canvas_->Divide(nxpads, 1);

  //draw pads
  for (int i=1; i <= nxpads; ++i) {
    bool islog = (!lin || i==2);
    canvas_->cd(i);
    SetPadStyles();                //NOCH EINE VIRTUAL
    if(islog) gPad->SetLogy(); 
    maxhist->Draw("AXIS");
    data_->Draw("P SAME");
    resolved_->Draw("SAME");
    direct_->Draw("SAME");
    mcall_->Draw("SAME");
    //legends
    if(!islog && legendlin) linleg_.reset(MakeLegend(xlegendlin, ylegendlin));
    if(islog && legendlog) logleg_.reset(MakeLegend(xlegendlog, ylegendlog));
  }
}

void TPlot::SetHistoStyles() {  //ZUGRIFF AUF DIE PROTECTED MEMBER
  //set plot styles for data
  data_->SetMarkerStyle(19);
  data_->SetMarkerSize(1);

  //set plot styles for mcdir
  direct_->SetLineStyle(2);

  //set plot styles for mcres
  resolved_->SetLineStyle(3);

  //set plot styles for combined mcres & mcdir
}

void TPlot::Plot() {
  /* ... */
  SetHistoStyles(data_.get(), direct_.get(), resolved_.get(), mcall_.get());
  /* ... */ 
}

void TPlot::SetHistoStyles(TH1* data, TH1* direct, TH1* resolved, TH1* mcall) {  //ZUGRIFF AUF DIE PROTECTED MEMBER
  //set plot styles for data
  data->SetMarkerStyle(19);
  data->SetMarkerSize(1);

  //set plot styles for mcdir
  direct->SetLineStyle(2);

  //set plot styles for mcres
  resolved->SetLineStyle(3);

  //set plot styles for combined mcres & mcdir
}

Mach P doch einfach zum friend, oder leite P private von T ab, oder verwende using um die Sichtbarkeit der Integerlis aus T in P auf private zu verändern.