Funzione costruttore

[franbisc]

Premesso che sto iniziando a studiare le classi,ho questa classe Bycicle definita nel file bycicle.h:

 class Bycicle{
public:
Bycicle();
Bycicle(int c,int g,int s);
// le varie funzioni che cambiano cadence,gear e speed
private:
int cadence;
int gear;
int speed;
}; 

Poi nell' implementazione della classe( bycicle.cpp):

Bycicle::Bycicle() {cadence=0;speed=0;gear=0}

Bycicle::Bycicle(int c,int g,int s)
{ cadence=c;speed=s;gear=g}
//definizione funzioni 

Non mi è chiaro perchè ha usato due costruttori,uno senza parametri,e l' altro con parametri i tre int c,g ed s.Vi prego,spiegatemelo il più elementarmente possibile

[apatriarca]

Principalmente perché può farlo ed è spesso comodo avere una costruttore di default (cioè senza parametri). Ci sono infatti situazione in cui è in effetti necessario. Un altro costruttore che è spesso utile è il costruttore di copia, ma immagino che tu non l'abbia ancora studiato.

[franbisc]

Ma cosa fanno di diverso i due costruttori?

[apatriarca]

Uno inizializza le variabili membro della classe a zero mentre l'altro ai valori che gli vengono passati.

[claudio862]

"Mifert4":Non mi è chiaro perchè ha usato due costruttori,uno senza parametri,e l' altro con parametri i tre int c,g ed s.Vi prego,spiegatemelo il più elementarmente possibile

Avere più costruttori ricade nella possibilità di sovraccaricare (overload) le funzioni membro: avere più funzioni con lo stesso nome che accettano parametri diversi. L'esempio più banale che si può fare è qualcosa del genere:

struct Punto
{
    int x;
    int y;
};

class Segmento
{
public:
    Segmento(int xa, int ya, int xb, int xb)
    {
        this->xa = xa;
        this->ya = ya;
        this->xb = xb;
        this->yb = yb;
    }
    Segmento(Punto a, Punto b)
    {
        this->xa = a.x;
        this->ya = a.y;
        this->xb = b.x;
        this->yb = b.x;
    }

    int xa;
    int xb;
    int ya;
    int ya;
}

Così puoi costruire un oggetto Segmento sia a partire dai 4 valori xa, ya, xb,yb sia da due oggetti Punto.

Segmento s1(1, 1, 10, 10);

Punto a(1, 1), b(10, 10);
Segmento s2(a, b);

Questo è un esempio abbastanza semplice, ma puoi vedere come rende un po' più flessibile la classe Segmento.

Nel tuo esempio inoltre uno dei costruttori è senza argomenti, e come detto è necessario in alcuni casi (ad esempio se vuoi usare la classe Bycicle nei contenitori standard std::list, std::vector…).
Usare il primo costruttore è equivalente ad usare il secondo passandogli 0, 0, 0:

Bycicle bike1;
Bycicle bike2(0, 0, 0);
// I due oggetti hanno lo stesso valore: i loro tre campi sono tutti a zero.

In questo caso sarebbe stato meglio usare degli argomenti di default (che però forse non hai ancora affrontato nel libro):

class Bycicle{
public:
Bycicle();
Bycicle(int c = 0, int g = 0, int s = 0)
{
    cadence = c;
    speed = s;
    gear = g;
}
// le varie funzioni che cambiano cadence,gear e speed
private:
int cadence;
int gear;
int speed;
};