Utilizzato this

#include <iostream>

class MyClass {
private:
    int x;

public:
    // Costruttore che utilizza this per inizializzare la variabile di istanza x
    MyClass(int x) {
        // Utilizzo di this per riferirsi alla variabile di istanza x
        this->x = x;
    }

    // Metodo per visualizzare il valore di x
    void displayX() {
        std::cout << "Valore di x: " << this->x << std::endl;
    }
};

int main() {
    // Creazione di un oggetto della classe MyClass con il costruttore chiamato
    MyClass obj(42);

    // Chiamata al metodo displayX sull'oggetto
    obj.displayX();

    return 0;
}

Explicit

In C++, la parola chiave `explicit` viene utilizzata per specificare che un costruttore o una funzione di conversione non può essere chiamato implicitamente dal compilatore durante le conversioni implicite di tipo. Questo significa che la conversione deve essere espressamente richiesta dal programmatore.

Costruttore esplicito

   class MyClass {
   public:
       // Costruttore esplicito
       explicit MyClass(int value) {
           // Inizializzazione della classe...
       }

       // Altri membri della classe...
   };

   int main() {
       // Creazione di un oggetto MyClass con un valore intero
       MyClass obj1(42);

       // La seguente riga genererà un errore, poiché il costruttore è esplicito
       // MyClass obj2 = 42; // Errore!

       // Creazione esplicita dell'oggetto
       MyClass obj3 = MyClass(42);

       return 0;
   }

Nel caso sopra, il costruttore di `MyClass` è dichiarato come esplicito.
Questo significa che non verrà chiamato automaticamente quando si cerca di inizializzare un oggetto di tipo `MyClass` con un valore intero, a meno che la chiamata non sia esplicita, come mostrato in `MyClass obj3 = MyClass(42);`.

Funzione di conversione esplicita

   class Distance {
   private:
       int feet;

   public:
       // Costruttore
       explicit Distance(int f) : feet(f) {}

       // Funzione di conversione esplicita da Distance a int
       explicit operator int() const {
           return feet;
       }
   };

   int main() {
       Distance d(5);

       // La seguente riga genererà un errore, poiché la conversione è esplicita
       // int feet_value = d; // Errore!

       // Conversione esplicita richiesta
       int feet_value = static_cast<int>(d);

       return 0;
   }

Nel secondo esempio, la funzione di conversione da `Distance` a `int` è dichiarata come esplicita.
Questo significa che quando si tenta di assegnare un oggetto `Distance` a una variabile di tipo `int`, è necessario utilizzare esplicitamente `static_cast<int>(d)`.