Differenza tra questo-> campo e classe :: campo?

Question

Mi chiedo qualcosa in C++.

Ammettendo il seguente codice:

int bar; 
class Foo 
{ 
public: 
    Foo(); 
private: 
    int bar; 
}; 

Dentro la mia classe, c'è qualche differenza tra this->bar e Foo::bar? Ci sono casi in cui uno non è valido?

Answer 1

Classe interna Foo (nello specifico) non c'è differenza tra i due dato che bar non è static.

Foo::bar è chiamato il nome completo del membro bar e questo modulo è utile in scenari in cui potrebbero esserci più tipi nella gerarchia che definisce un membro con lo stesso nome. Ad esempio, si potrebbe necessità di scrivere Foo::bar qui:

class Foo 
{ 
    public: Foo(); 
    protected: int bar; 
}; 

class Baz : public Foo 
{ 
    public: Baz(); 
    protected: int bar; 

    void Test() 
    { 
     this->bar = 0; // Baz::bar 
     Foo::bar = 0; // the only way to refer to Foo::bar 
    } 
}; 

Answer 2

Per quello che ho imparato a trafficare con C/C++, l'uso di -> su qualcosa è principalmente per un oggetto puntatore, e l'uso di :: è usato per le classi che fanno parte di un namespace o di una super classe che è il classe generale di qualsiasi cosa tu stia includendo

Answer 3

che fanno gli stessi membri cosa.

Tuttavia, non sarà possibile utilizzare this-> per distinguere i membri con lo stesso nome nella gerarchia di classi. Dovrai utilizzare la versione ClassName:: per farlo.

Answer 4

Consente inoltre di fare riferimento a variabili di un'altra classe (classe base nella maggior parte dei casi) con lo stesso nome. Per me è ovvio da questo esempio, spero che ti possa aiutare.

#include <iostream> 
using std::cout; 
using std::endl; 

class Base { 
public: 
    int bar; 
    Base() : bar(1){} 
}; 

class Derived : public Base { 
public: 
    int bar; 

    Derived() : Base(), bar(2) {} 

    void Test() { 
     cout << "#1: " << bar << endl; // 2 
     cout << "#2: " << this->bar << endl; // 2 
     cout << "#3: " << Base::bar << endl; // 1 
     cout << "#4: " << this->Base::bar << endl; // 1 
     cout << "#5: " << this->Derived::bar << endl; // 2 
    } 
}; 

int main() 
{ 
    Derived test; 
    test.Test(); 
} 

Questo perché i dati reali memorizzati in classe è come questo:

struct { 
    Base::bar = 1; 
    Derived::bar = 2; // The same as using bar 
}