Costruttore Interno senza parametri

Ecco un esempio di definizione di un costruttore e creazione di un oggetto senza parametri in C++.

#include <iostream>


// Definizione di una classe con un costruttore senza parametri
class MiaClasse {
public:
    // Costruttore senza parametri
    MiaClasse() {
        std::cout << "Costruttore senza parametri chiamato" << std::endl;
    }
};

int main() {
    // Creazione di un oggetto utilizzando il costruttore senza parametri
    MiaClasse mioOggetto;

    return 0;
}

In questo esempio:

• La classe `MiaClasse` ha un costruttore senza parametri.
• Nel `main()`, viene creato un oggetto `mioOggetto` utilizzando il costruttore senza parametri.
• Quando viene creato l'oggetto, il costruttore senza parametri viene chiamato e stampa un messaggio a schermo.

Costruttore interno alla classe con parametri

#include <iostream>

// Definizione di una classe con un costruttore interno con parametri
class MiaClasse {
public:
    // Costruttore con parametri
    MiaClasse(int valore1, int valore2) {
        parametro1 = valore1;
        parametro2 = valore2;
        std::cout << "Costruttore con parametri chiamato con " << parametro1 << " e " << parametro2 << std::endl;
    }

    // Funzione membro per visualizzare i parametri
    void VisualizzaParametri() {
        std::cout << "Parametro1: " << parametro1 << ", Parametro2: " << parametro2 << std::endl;
    }

private:
    int parametro1;
    int parametro2;
};

int main() {
    // Creazione di un oggetto utilizzando il costruttore con parametri
    MiaClasse mioOggetto(10, 20);

    // Utilizzo di una funzione membro per visualizzare i parametri
    mioOggetto.VisualizzaParametri();

    return 0;
}

In questo esempio:

• La classe `MiaClasse` ha un costruttore interno con parametri `valore1` e `valore2`.
• Quando viene creato un oggetto `mioOggetto` utilizzando il costruttore con parametri, vengono passati i valori 10 e 20.
• Il costruttore con parametri assegna i valori ai membri della classe e stampa un messaggio a schermo.
• Viene utilizzata una funzione membro (`VisualizzaParametri()`) per visualizzare i parametri assegnati.

Costruttore esterno alla classe

#include <iostream>

// Dichiarazione di una classe con un costruttore esterno senza parametri
class MiaClasse {
public:
    // Dichiarazione del costruttore esterno
    MiaClasse();

    // Funzione membro
    void EseguiOperazione() {
        std::cout << "Operazione eseguita!" << std::endl;
    }
};

// Implementazione del costruttore esterno
MiaClasse::MiaClasse() {
    std::cout << "Costruttore esterno senza parametri chiamato" << std::endl;
}

int main() {
    // Creazione di un oggetto utilizzando il costruttore esterno senza parametri
    MiaClasse mioOggetto;

    // Utilizzo di una funzione membro
    mioOggetto.EseguiOperazione();

    return 0;
}

In questo esempio:

• La classe `MiaClasse` dichiara il costruttore esterno senza parametri all'interno della sezione `public`.
• L'implementazione effettiva del costruttore esterno è fornita al di fuori della definizione della classe.
• Quando viene creato un oggetto `mioOggetto`, viene chiamato il costruttore esterno senza parametri, che stampa un messaggio a schermo.
• Viene utilizzata una funzione membro (`EseguiOperazione()`) per eseguire un'operazione con l'oggetto.

Overload del costruttore

L'overload del costruttore in programmazione orientata agli oggetti (OOP) significa fornire più di una versione del costruttore all'interno di una classe, ognuna con una lista diversa di parametri.
In altre parole, una classe può avere più di un costruttore con lo stesso nome.

#include <iostream>

class MiaClasse {
public:
    // Costruttore con un parametro intero
    MiaClasse(int valore) {
        std::cout << "Costruttore con parametro intero: " << valore << std::endl;
    }

    // Costruttore con due parametri interi
    MiaClasse(int valore1, int valore2) {
        std::cout << "Costruttore con due parametri interi: " << valore1 << ", " << valore2 << std::endl;
    }

    // Costruttore senza parametri
    MiaClasse() {
        std::cout <<"Costruttore senza parametri chiamato" << std::endl;
    }
};

int main() {
    // Utilizzo del costruttore con un parametro
    MiaClasse oggetto1(42);

    // Utilizzo del costruttore con due parametri
    MiaClasse oggetto2(10, 20);

    // Utilizzo del costruttore senza parametri
    MiaClasse oggetto3;

    return 0;
}

In questo esempio, la classe `MiaClasse` ha tre versioni del costruttore: uno con un parametro, uno con due parametri e uno senza parametri.
A seconda di come viene chiamato il costruttore, verrà utilizzata la versione corrispondente con la firma appropriata.

Distruttore

#include <iostream>

class MiaClasse {
public:
    // Costruttore con messaggio di creazione
    MiaClasse() {
        std::cout << "Costruttore chiamato" << std::endl;
    }

    // Distruttore con messaggio di distruzione
    ~MiaClasse() {
        std::cout << "Distruttore chiamato" << std::endl;
    }
};

int main() {
    // Creazione di un oggetto
    MiaClasse mioOggetto;

    // Il distruttore verrà chiamato quando l'oggetto esce dallo scope
    return 0;
}

In questo esempio:
Quando l'oggetto esce dallo scope (alla fine della funzione `main()`), viene chiamato il distruttore, stampando un messaggio di distruzione. L'output di questo programma sarà:

Costruttore chiamato
Distruttore chiamato

Il costruttore Delegato

#include <iostream>
class MiaClasse {
public:
    // Costruttore principale
    MiaClasse(int valore) {
        Inizializza(valore);
        std::cout << "Costruttore principale chiamato" << std::endl;
    }

    // Costruttore delegato che chiama il costruttore principale
    MiaClasse() : MiaClasse(0) {
        std::cout << "Costruttore delegato chiamato" << std::endl;
    }

    // Metodo pubblico per inizializzare l'oggetto
    void Inizializza(int valore) {
        parametro = valore;
    }

    // Metodo pubblico per visualizzare il parametro
    void VisualizzaParametro() {
        std::cout << "Parametro: " << parametro << std::endl;
    }

public: // Attributo pubblico per semplificare l'esempio
    int parametro;
};

int main() {
    // Utilizzo del costruttore principale
    MiaClasse oggetto1(42);
    oggetto1.VisualizzaParametro();

    std::cout << std::endl;

    // Utilizzo del costruttore delegato
    MiaClasse oggetto2;
    oggetto2.VisualizzaParametro();

    return 0;
}

In questo esempio:
- Il costruttore principale (`MiaClasse(int valore)`) inizializza l'oggetto chiamando il metodo `Inizializza(int valore)` e stampa un messaggio.
- Il costruttore delegato (`MiaClasse()`) chiama il costruttore principale fornendo un valore di default, in questo caso `0`.
- Il metodo pubblico `Inizializza(int valore)` è utilizzato sia dal costruttore principale che da altri metodi per inizializzare l'oggetto.
- Il metodo pubblico `VisualizzaParametro()` è utilizzato per visualizzare il valore del parametro.
L'output di questo programma sarà:

Costruttore principale chiamato
Parametro: 42

Costruttore delegato chiamato
Costruttore principale chiamato
Parametro: 0