[C++] Classi: metodi privati e pubblici

[ing82]

Scusate se la domanda è banale, ma non trovo niente che mi risolva questo dubbio.

Ho implementato un classe nel seguente modo

class Classe
{
  public:

    //costruttore, distruttore, ecc

    tipo3 setMembro3(const tipo1& parametro1, const tipo2& parametro2);

  private:
    
    void setMembro3();
    
    tipo1 mMembro1;//dato membro num 1
    tipo2 mMembro2;//dato membro num 2
    tipo3 mMembro3;//dato membro num 3
}

I due metodi setMembro3 svolgono il medesimo compito/operazioni, l'unica differenza è che il metodo pubblico lavora sui parametri che gli vengono passati e restituisce un dato che ha lo stesso significato di mMembro3, mentre il metodo privato non necessita di parametri in quanto parametro1 e parametro2 in questo caso sono rispettivamente mMembro1 e mMembro2 (se dovessi fare un esempio pratico, potrebbe essere la classe una sezione rettangolare, membro 1 la base, membro 2 l'altezza, membro3 l'area).
Con qualche riga di codice forse è più chiaro:

tipo3 Classe::setMembro3(const tipo1& parametro1, const tipo2& parametro2)
{
  tipo3 temp;
  temp=/*operazioni coi parametri 1 e 2*/;
  return temp;
}

void Classe::setMembro3()
{
  mMembro3=/*operazioni con mMembro1 e mMembro2*/;
}

Ho pensato di fare le due implementazioni in modo da avere a disposizione un metodo pubblico da poter usare anche quando l'istanza della classe non dovesse essere ncessariamente creata, per qualsiasi motivo, mentre il metodo privato da usare ad esempio nel costruttore della classe in cui vengono passati i parametri 1 e 2, assegnati ai rispettivi dati membro, e quindi richiamato il metodo setMembro3().

All'inizio mi sembrava una bella pensata, ma dopo aver fatto una cosa del genere, mi chiedo se duplicare i metodi abbia senso, se l'unico vantaggio è quello di evitare questa scrittura

mMembro3=setMembro3(mMembro1, mMembro2);

In qualche caso questo approccio può tornare vantaggioso, o in fase di manutenzione crea solo confusione e maggior probabilità di errore, quindi mi tengo un solo metodo, quello pubblico, e uso sempre e solo quello?

Ne approfitto per un'ulteriore domanda: come linea generale, anche se un metodo viene implementato come private, perchè non servirà mai all'esterno, e gli unici parametri che ha bisogno sono i dati membro della classe, è meglio che il prototipo sia

metodo();

in cui non passo parametri in quanto può accedere ai dati membro della classe

oppure

metodo(parametro1, parametro2,...);

e quando richiamo il metodo gli passo i dati membro,

metodo(mMembro1, mMembro2);

col vantaggio di poter specificare che i parametri sono const nel caso non debbano essere modificati e passati anche by reference?

Grazie

[shodan]

Ho pensato di fare le due implementazioni in modo da avere a disposizione un metodo pubblico da poter usare anche quando l'istanza della classe non dovesse essere ncessariamente creata, per qualsiasi motivo,

E' necessaria una funzione static per questo, che comunque non può accedere a dati membro non static a prescindere dall'esistenza di una istanza di classe. Di fatto è poco più di una free function.

mentre il metodo privato da usare ad esempio nel costruttore della classe in cui vengono passati i parametri 1 e 2, assegnati ai rispettivi dati membro, e quindi richiamato il metodo setMembro3().

Ti sei risposto da solo

quindi mi tengo un solo metodo, quello pubblico, e uso sempre e solo quello

come linea generale, anche se un metodo viene implementato come private...

Se operi esclusivamente su dati membro i due sistemi sono sostanzialmente equivalenti.

[cisco87]

Da Clean Code, se piu' metodi di una classe hanno bisogno dello stesso valore di variabile, allora quella variabile deve diventare una proprieta' della classe. Se un metodo e' chiamato soltanto da altri metodi della classe allora e' private. I metodi statici vanno evitati.

[ing82]

E' necessaria una funzione static per questo

Pensavo bastasse fare Classe::setMembro3(....); .....

Fino ad ora una cosa simile l'ho usata con le enum dichiarate public in un'altra classe (AltraClasse::enum_xxx), per i metodi pensavo valesse la stessa cosa.

Non so se è solo un complicarsi la vita, ma allora potrei definire static il metodo public (a me serve poterlo richiamare senza istanziare la classe in certi casi), cambiare il prototipo in

static tipo3 calcMembro3(const double& parametro1, const double& parametro2);

e lasciare anche il metodo private

void setMembro3();

che sarà implementato come segue:

void setMembro3()
{
mMembro3=calcMembro3(mMembro1, mMembro2);
}

in questo modo, se è corretto, dovrei avere un unico punto da modificare in caso di necessità, che è calcMembro3.

Di fatto è poco più di una free function.

Con un po' di Google adesso vediamo di scoprire anche questa...

Da Clean Code, se piu' metodi di una classe hanno bisogno dello stesso valore di variabile, allora quella variabile deve diventare una proprieta' della classe. Se un metodo e' chiamato soltanto da altri metodi della classe allora e' private. I metodi statici vanno evitati.

Se ci fosse una sezione per principianti, quella sarebbe la mia: scusa, ma dall'alto della mia ignoranza non capisco cosa significa quanto scritto. In parole più semplici, ma soprattutto, con un esempio, magari mi risulterebbe più digeribile.

Grazie

[shodan]

Pensavo bastasse fare Classe::setMembro3(....); .....
Fino ad ora una cosa simile l'ho usata con le enum dichiarate public in un'altra classe (AltraClasse::enum_xxx), per i metodi pensavo valesse la stessa cosa.

Le enum sono delle costanti per cui è lecito. Per le funzioni e i dati è diverso, in più per i dati è necessaria una inizializzazione.

class HaveStatic {
    public:
        HaveStatic() : data(0) {}
        static int something(int param);
        int other();

        static int sData;
        int data;
};

// nel file .cpp
// inizializzazione dato statico.
int HaveStatic::sData = 0; // definizione obbligatoria.

int HaveStatic::something(int param) {
     return sData * param;
}

int HaveStatic:: other() {
    return data + 100;
}

// in main.cpp

int res = HaveStatic::something(20); // ok la funzione è static.
HaveStatic::sData = 10; // ok, sData è static.
res = HaveStatic::something(30); 

// res = HaveStatic:: other(); No!, la funzione non è static, serve un'istanza della classe.
HaveStatic hs;
res = hs.other();

Non so se è solo un complicarsi la vita, ma allora potrei definire static il metodo public (a me serve poterlo richiamare senza istanziare la classe in certi casi), cambiare il prototipo in
static tipo3 calcMembro3(const double& parametro1, const double& parametro2);
e lasciare anche il metodo private
void setMembro3();

Di per se non è una complicazione, ma perdi in genericità. Magari più avanti scopri che tale funzione vuoi applicarla anche a, che so, Classe1, Classe2. E' questione di scelte che solo tu puoi conoscere. Comunque non hai accesso a membri non statici della classe.
Per quanto riguarda il metodo privato, francamente così è inutile. Più utile sarebbe renderlo pubblico e passargli come parametro il tipo3.

void Classe::setMembro3(tipo3 dato) {
    mMembro3 = dato;
}

In modo che sia possibile in ogni momento cambiarne il valore.
Se questo non è previsto, allora imposta direttamente il dato dove ti serve.

Se ci fosse una sezione per principianti, quella sarebbe la mia:

Hai un testo di riferimento?

[ing82]

Hai un testo di riferimento?

Ne ho uno cartaceo, qualcosa del tipo C e C++ Programming (non lo ho sottomano ora), in italiano.
Quello però che mi ha dato più spunti di riflessione e miglioramento è questo pdf,

C++, Manuale di stile reloaded, di Carlo Pescio.

Per il resto, Google, la guida di HTML.it, e poi il forum...

Si accettano consigli a riguardo

Grazie

[shodan]

Per altri testi puoi guardare qui:
http://www.ioprogrammo.it/index.php?...14308#msg14308
in più aggiungerei i testi di Scott Meyers
http://www.aristeia.com/books.html alla lista.