Différence entre func() et (* this) .func() en C++

Question

Je travaille sur le code de quelqu'un d'autre en C++, et j'ai trouvé un appel bizarre à une certaine fonction func(). Voici un exemple:

if(condition) 
    func(); 
else 
    (*this).func(); 

Quelle est la différence entre func() et (*this).func()?

Dans quels cas l'appel à func() et (*this).func() exécutera-t-il un code différent? Dans mon cas, func() n'est pas une macro. C'est une fonction virtuelle dans la classe de base, avec une implémentation dans la classe de base et la classe dérivée, et non func() libre. Le if est situé dans une méthode de la classe de base.

Answer 1

Il existe en fait une différence, mais dans un contexte très non trivial. Considérez ce code:

void func () 
{ 
    std::cout << "Free function" << std::endl; 
} 

template <typename Derived> 
struct test : Derived 
{ 
    void f () 
    { 
     func(); // 1 
     this->func(); // 2 
    } 
}; 

struct derived 
{ 
    void func () 
    { 
     std::cout << "Method" << std::endl; 
    } 
}; 

test<derived> t; 

Maintenant, si nous appelons t.f(), la première ligne de test::f invoquera la fonction libre func, tandis que la deuxième ligne appellera derived::func.

Answer 2

Il est impossible de dire à partir de l'extrait, mais peut-être il y a deux objets appelables appelés func(). Le (*this).func(); s'assure que la fonction membre est appelée.

A objet appelable pourrait être (par exemple) un functor ou une expression lambda:

foncteur

struct func_type 
{ 
    void operator()() const { /* do stuff */ } 
}; 

func_type func; // called using func(); 

lambda

auto func = [](){ /* do stuff */ }; // called using func(); 

Par exemple:

#include <iostream> 

class A 
{ 
public: 

    // member 
    void func() { std::cout << "member function" << '\n'; } 

    void other() 
    { 
     // lambda 
     auto func = [](){ std::cout << "lambda function" << '\n'; }; 

     func(); // calls lambda 

     (*this).func(); // calls member 
    } 
}; 

int main() 
{ 
    A a; 
    a.other(); 
} 

Sortie:

lambda function 
member function 

Answer 3

Avec le type nom à charge, il peut être différent:

void func() { std::cout << "::func()\n"; } 

struct S { 
    void func() const { std::cout << "S::func()\n"; } 
}; 

template <typename T> 
struct C : T 
{ 
    void foo() const { 
     func();   // Call ::func 
     (*this).func(); // Call S::func 
    } 
}; 

Demo

Answer 4

Un autre cas où ces deux lignes wi Appelez différentes fonctions:

#include <iostream> 

namespace B 
{ void foo() { std::cout << "namespace\n"; } } 

struct A { 
    void foo() { std::cout << "member\n"; } 

    void bar() 
    { 
     using B::foo; 
     foo(); 
     (*this).foo(); 
    } 
}; 

int main() 
{ 
    A a; 
    a.bar(); 
}