merkwürdige Weise ein Verfahren von einer Instanz-Objekt aufrufen ...

Question

einige Codes Graben, fand ich eine eigentümlich Weise ein Verfahren von einer Instanz-Objekt aufzurufen, die I unten im Beispielcode zeigt:

class Example{ 
public: 
    void Print(){ std::cout << "Hello World" << std::endl;} 
}; 

int main(){ 
    Example ex; 
    ex.Example::Print(); // Why use this notation instead of just ex.Print(); 
    return 0; 
} 

Es gibt irgendeinen Verhaltensunterschied zwischen ex.Example :: Print() und dem Standardweg ex.Print()? Warum verwendete der Code des Autors den ersteren anstelle des letzteren?

Vielen Dank im Voraus

Answer 1

Der Unterschied besteht darin, dass ex.Example::Print() gibt an, dass Sie die Version von Print() in der Klasse Example definiert werden sollen. In diesem speziellen Beispiel gibt es keinen Unterschied. Allerdings sollten Sie Folgendes berücksichtigen:

#include <iostream> 

class One { 
    int i; 

    public: 
    One(int ii) : i(ii) {} 
    virtual void print() { std::cout << i << std::endl; } 
}; 

class Two : public One { 
    int j; 

    public: 
    Two(int ii, int jj) : One(ii), j(jj) {} 
    void print() override { 
     One::print(); 
     std::cout << j << std::endl; 
    } 
}; 

class Three : public Two { 
    int k; 

    public: 
    Three(int ii, int jj, int kk) : Two(ii, jj), k(kk) {} 
    void print() override { 
     Two::print(); 
     std::cout << k << std::endl; 
    } 
}; 

int main() { 
    Three four(1, 2, 3); 

    four.print(); 
    std::cout << std::endl; 

    four.One::print(); 
    std::cout << std::endl; 
    four.Two::print(); 
    std::cout << std::endl; 
    four.Three::print(); 
    std::cout << std::endl; 
} 

Der Ausgang wird:

1 
2 
3 

1 

1 
2 

1 
2 
3 

Answer 2

Kein Unterschied zwischen ex.Example::Print() und ex.Print() in diesem Beispiel nennen.

Die einzige Verwendung/Nutzen dieser Aufruf, die ich mir vorstellen kann, ist mit Vererbung; Sie können die übergeordnete Methode in der übergeordneten Klasse explizit mit dieser Syntax von einer Instanz der abgeleiteten Klasse aus aufrufen.

Answer 3

ex.Example::Print(); // Why use this notation instead of just ex.Print(); 

der entsandte Code gegeben, das ist die gleiche wie:

ex.Print(); 

Es wird einen Unterschied machen nur, wenn Namen Versteck ins Spiel kommt und Sie wollen über den Aufruf einer bestimmten Version der explizit sein Funktion.

Ex:

struct Foo 
{ 
    void Print() const { std::cout << "Came to Foo::Print()\n"; } 
}; 

struct Bar : Foo 
{ 
    void Print() const { std::cout << "Came to Bar::Print()\n"; } 
}; 

int main() 
{ 
    Bar b; 
    b.Print(); // Calls Bar::Print() 
    b.Foo::Print(); // Calls Foo::Print() 
} 

das ist nur die Mechanik, wie die Dinge funktionieren. Als Design-Wahl, wird es besser sein virtual Funktionen zu verwenden:

struct Foo 
{ 
    virtual void Print() const { std::cout << "Came to Foo::Print()\n"; } 
}; 

struct Bar : Foo 
{ 
    virtual void Print() const { std::cout << "Came to Bar::Print()\n"; } 
};