Es gibt bereits eine Klasse cPlayer:

#ifndef CPLAYER_H
#define CPLAYER_H
#include <vector>
#include "ccard.h"

class cPlayer
{
public:
    cPlayer();
    cPlayer(std::string, long, int, int);
    virtual ~cPlayer();

    // set
    void addCard(cCard);
    void setName(std::string);
    void setAggression(int);
    void setBluff(int);
    void setIsWinner(bool);
    void setIsOut(bool);
    void setIsInRound(bool);
    void modifyChips(long);
    void modifyWins(unsigned int);

    //get
    std::string getName();
    int getAggression();
    int getBluff();
    unsigned int getWins();
    long getChips();
    cCard getCard(int);
    std::vector<cCard> getCards();
    bool getIsWinner();
    bool getIsOut();
    bool getIsInRound();
    //del
    void delCards();
protected:
    bool bIsInRound;
    bool bIsOut;
    bool bIsWinner;
    std::string sName;
    long iChips;
    int iAggression;
    int iBluff;
    unsigned int iWins;
    std::vector<cCard> Cards;
private:
};

#endif // CPLAYER_H

In der Klasse cPoker habe ich einen Vektor von cPlayer. Nun möchte ich aber eine neue Klasse cBot erstellen.

Diese Klasse soll von der Klasse cPlayer vererbt werden. Allerdings soll sie nur Zugriff auf die getter haben, nicht auf die Setter. Die eigentlichen Variablen sollen weiterhin in der cPlayer bleiben und cPoker muss weiterhin auf cPlayer zugreifen können (wie bis jetzt).

Wie kann ich nun vermeiden, die ganze cPoker Klasse als friend der cPoker Klasse zu deklarieren und trotzdem diesen unterschiedlichen Zugriff hinbekommen?

Also der Bot soll nur seine Karten, seine Position am Tisch, Chipanzahl usw. lesen können und dann eine Action ausführen.
In der Klasse cPoker muss natürlich die Position, Chipanzahl immer verändert werden .. wie stelle ich das an? Bin am Ende von meinem Latein. Muss ich komplett anders an die Sache herangehen?

Nun das zweite Problem, im Moment noch nicht wichtig. Wie kann ich dann realisieren, dass es verschiedene Bots gibt, die natürlich auch immer verschieden agieren? Muss ich da verschiedene Klassen erstellen?

Viele Grüße und vielen Dank schonmal
CsT

EDIT:
Habe gerade nochmal ein bisschen nachgedacht und nachgelesen ..
Kann ich es irgendwie anstellen, dass für cBot die ganzen Variablen const sind, also die setter nicht aufgerufen werden können? Dann hätte ich ja auch das bewerkstelligt, was ich möchte.

cPoker{
    public:  //was anderes geht natürlich auch
    cPlayer Player1;
    cPlayer Player2;
};

So kannst du dann Player1 und Player2 voneinander unabhänig nutzen ohne eine neue Klasse zu schreiben.

Ich hoffe, dass ich dir helfen konnte dein Problem zu lösen.

Viele Grüße und besten Dank nochmal
CsT

Ich hoffe, ich konnte dir klar machen, was ich sagen wollte.

Wichtiger ist mein erstes Problem .. und ich stehe immer noch auf dem Schlauch. Der Bot darf halt selber nur read-only auf die ganzen Daten zugreifen, das Poker-Game hingegen auf alles. Aber möglichst ohne als friend deklariert zu sein, weil es ja dann auch auf die Variablen an sich zugreifen kann ..

Vielen Dank nochmal
CsT

Vielleicht solltest du eine gemeinsame Basisklasse "Player" machen, die die set Methoden nicht hat (und alle anderen Methoden pure virtual), und dann Bot und HumanPlayer von dieser erben lassen, wobei du HumanPlayer dann die get Methoden gibst. Würde mir jetzt mal am logischsten erscheinen, weil: ein Bot ist ein Spieler, aber kein menschlicher Spieler. Ergo sollte er auch nicht von einem menschlichen Spieler erben. Und umgekehrt genauso, ein menschlicher Spieler ist ein Spieler, aber kein Bot.

Wie gesagt, ich bin selbst noch Anfänger, also keine Garantie.

So weit ich weiß, wenn du eine Funktion als private deklarierst, wird sie nicht vererbt.

Alle Methoden werden vererbt - aber private Methoden kann die Kind-Klasse nicht direkt aufrufen.

Zu deinem Ansatz: Wieso sollte der menschliche Spieler mehr Möglichkeiten haben als ein Bot-Spieler? (die ganzen Methoden, die du vor dem Bot verstecken willst, haben in der Spieler-Klasse überhaupt nichts zu suchen, sondern gehören sollten eher in die Spiel-Klasse gehören)

class cPoker
{
  vector<cSpieler*> teilnehmer;
  int sieger;
  ...
public:
  void eintreten(cSpieler* neu) {teilnehmer.push_back(neu);}
  void austreten(cSpieler* alt)
  {
    vector<cSpieler*>::iterator pos=find(teilnehmer.begin(),teilnehmer.end(),alt);
    if(pos!=teilnehmer.end()) teilnehmer.erase(pos);
  }
  ...
};