Zugreifen auf private Mitglieder über den Referenz-Accessor

Question

Welcher Art ist der Zugriff auf private Mitglieder einer referenzierten Klasseninstanz? Zum Beispiel Zugriff auf die initialNumberOfColumns von einer Instanz Cookie? Dann muss dieser Wert in einer anderen Klassenmemberfunktion verwendet werden, beispielsweise Game::Game(), nachdem der Referenz-Accessor das Element der Cookie-Klasse abgerufen hat.

first.h:

class Cookie { 
    public: 
     Cookie(); 
     ~Cookie(); 
     void takeABite (int column, int row); 
     int getNumberOfRows(); 
     int getNumberOfRows(int colNum); 
     int getNumberOfColumns(); 
     int getNumberOfColumns(int rowNum); 
     void display (std::ostream& output); 

    private: 
     int initialNumberOfRows; 
     int numberOfRows; 
     int numberOfColumns 
     int* cookie; 
}; 

second.h:

class Game { 
    public: 
     Game(); 
     bool gameEnded(); 
     bool biteIsLegal (int column, int row); 
     Cookie& getCookie(); 

    private: 
     Cookie cookie; 
}; 

second.cpp ist, wo ich schwer habe. Ich weiß, ich brauche Cookie& Game::getCookie() zu verwenden, aber ich bin nicht sicher, wie die privaten Mitglieder der Cookie Klasse so zurückzukehren, dass sie in der Member-Funktion Game() unten .:

Cookie& Game::getCookie() { 
    return //not sure how to access; 
} 

Game::Game() { 
    initialNumberOfRows = numberOfRows = 4 + rand() % (MAXROWS - 4); 
    numberOfColumns = numberOfRows; 

    while (numberOfColumns == numberOfRows) { 
     numberOfColumns = 4 + rand() % (MAXROWS - 4); 
    } 

    cout << "The cookie has " << numberOfRows << " rows of " 
     << numberOfColumns << " columns" << endl; 

    for (int row = 0; row < numberOfRows; ++row) { 
     cookie[row] = numberOfColumns; 
    } 
} 

Answer 1

Die Game Klasse ein cookie Mitglied hat zugegriffen werden kann . Das ist, was die Game::getCookie() Methode zurückgeben soll:

Cookie& Game::getCookie() { 
    return cookie; 
} 

nun innerhalb des Game Konstruktor Sie direkten Zugang zum cookie Mitglied haben, so müssen Sie getCookie() nicht verwenden, um darauf zuzugreifen. Und die Cookie Klasse öffentliche Methoden für Lesen die meisten der Werte, die Sie verwenden möchten, aber es bietet keinen Zugriff auf gesetzt diese Elementwerte oder über den Zugang zu seinem privateninitialNumberOfRows Mitglied überhaupt.

Die Dinge, die Sie versuchen, in der Game Konstruktor tun sollten stattdessen in den Cookie Konstruktor erfolgen:

Cookie::Cookie() { 
    initialNumberOfRows = numberOfRows = 4 + rand() % (MAXROWS - 4); 

    numberOfColumns = numberOfRows; 
    while (numberOfColumns == numberOfRows) { 
     numberOfColumns = 4 + rand() % (MAXROWS - 4); 
    } 

    cookie = new int[numberofRows]; 

    for (int row = 0; row < numberOfRows; ++row) { 
     cookie[row] = numberOfColumns; 
    } 
} 

Dann wird der Game Konstruktor die Werte je nach Bedarf anmelden können:

Game::Game() { 
    cout << "The cookie has " << cookie.getNumberOfRows() << " rows of " 
     << cookie.getNumberOfColumns() << " columns" << endl; 
} 

Jetzt , das heißt, die Cookie Klasse verletzt die Rule of Three. Es braucht einen Copykonstruktor und Kopie Zuweisungsoperator zu implementieren die Integrität seines int *cookie Bereich sicherzustellen:

class Cookie { 
public: 
    Cookie(); 
    Cookie(const Cookie &src); 
    ~Cookie(); 

    Cookie& operator=(const Cookie &rhs); 
    void swap(Cookie &other); 

    ... 

private: 
    int initialNumberOfRows; 
    int numberOfRows; 
    int numberOfColumns 
    int* cookie; 
}; 

#include <algorithm> 

Cookie::Cookie() { 
    initialNumberOfRows = numberOfRows = 4 + rand() % (MAXROWS - 4); 

    numberOfColumns = numberOfRows; 
    while (numberOfColumns == numberOfRows) { 
     numberOfColumns = 4 + rand() % (MAXROWS - 4); 
    } 

    cookie = new int[numberOfRows]; 
    std::fill(cookie, cookie + numberOfRows, numberOfColumns); 
} 

Cookie::Cookie(const Cookie &src) : 
    initialNumberOfRows(src.initialNumberOfRows), 
    numberOfRows(src.numberOfRows), 
    numberOfColumns(src.numberOfColumns), 
    cookie(new int[numberOfRows]) 
{ 
    std::copy(src.cookie, src.cookie + numberOfRows, cookie); 
} 

Cookie::~Cookie() 
{ 
    delete[] cookie; 
} 

Cookie& Cookie::operator=(const Cookie &rhs) 
{ 
    if (this != &rhs) 
     Cookie(rhs).swap(*this); 
    return *this; 
} 

void Cookie::swap(Cookie &other) 
{ 
    std::swap(initialNumberOfRows, other.initialNumberOfRows); 
    std::swap(numberOfRows, other.numberOfRows); 
    std::swap(numberOfColumns, other.numberOfColumns); 
    std::swap(cookie, other.cookie); 
} 

Andernfalls ändern Sie das int *cookie Element auf ein std::vector statt, und Lassen Sie den Compiler und die STL die harte Arbeit der Speicherverwaltung für Sie übernehmen:

#include <vector> 

class Cookie { 
public: 
    Cookie(); 

    ... 

private: 
    int initialNumberOfRows; 
    int numberOfRows; 
    int numberOfColumns 
    std::vector<int> cookie; 
}; 

Cookie::Cookie() { 
    initialNumberOfRows = numberOfRows = 4 + rand() % (MAXROWS - 4); 

    numberOfColumns = numberOfRows; 
    while (numberOfColumns == numberOfRows) { 
     numberOfColumns = 4 + rand() % (MAXROWS - 4); 
    } 

    cookie.resize(numberOfRows); 
    std::fill(cookie.begin(), cookie.end(), numberOfColumns); 
}