Salut à tous !

Alors voila une question qui me trotte dans la tête depuis quelque temps. On peut dissimuler l'implémentation d'une classe de plusieurs façons dont voici les deux exemples qui me viennent à l'esprit :

- Un pimpl classique :
class Foo
{
struct Impl;
std::unique_ptr<Impl> impl;

public:
Foo();
void FooFunc();
};

Dans le fichier source :

struct Foo::Impl
{
void FooFunc()
{
std::cout << "FOOOOOOOO" << std::endl;
}
};

Foo::Foo() : impl(new Foo::Impl){}

void Foo::FooFunc()
{
impl->FooFunc();
}

Une autre façon de faire pourrait être celle ci :

struct Foo
{
virtual ~Foo() = default;
virtual void FooFunc() = 0;
};

extern Foo *CreateFoo();

Et dans le fichier source :

struct FooImpl : public Foo
{
void FooFunc() override
{
std::cout << "FOOOOOOOO" << std::endl;
}
};

La question que je me pose est simple. Pour la deuxième façon de faire (en supposant qu'il n'y ait bien qu'une seule implémentation de l'interface Foo), paierait-on le prix d'un appel de fonction polymorphique ou bien le compilateur peut-il se "rendre compte" que sa vftable est ne comporte qu'une seule entrée et donc décider de faire des optimisations que des appels polymorphiques ne permettent normalement pas ?

Non le compilateur ne peux pas se rendre compte de ces choses la facilement. Donc probablement il ne le fait pas.
Rappelle toi bien, que si un truc a l'air compliquer. probablement le compilateur ne le voit pas.

Ok, c'est bien ce que je me disais. Merci pour ta réponse godrik !