Petite question philosophique concernant les std::priority_queue.

Soit le code suivant, dans lequel on d�finit un foncteur qui permet la comparaison entre deux entiers, qui est utilis� dans une std::priority_queue.

Code : S�lectionner tout - Visualiser dans une fen�tre � part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
#include <cstdlib>
#include <iostream>
#include <queue>
 
struct Comparator
{
        Comparator(){}
        Comparator(const Comparator & c) { std::cout << "Copy constructor of Comparator\n" ; }
        bool operator()(int a, int b) const { return a<b ; }
} ;
 
int main(int argc, char** argv)
{
        Comparator comp ;
        std::priority_queue<int, std::vector<int>, Comparator> queue(comp) ;
 
        queue.push(3) ; queue.push(5) ; queue.push(4) ; queue.push(6) ; 
 
        while (! queue.empty())
        {
                std::cout << queue.top() << std::endl ;
                queue.pop() ;
        }
 
        return EXIT_SUCCESS ;
}
Si on execute le code, on se rend compte que le constructeur par recopie de Comparator est appel� 26 fois. Je comprends bien qu'en dessous il y a toute la m�canique des appels � make_heap/push_heap/... et que ces fonctions sont appel�es 26 fois.

La question que je me pose, cependant, c'est pourquoi le comparateur est copi� � chaque appel ?

A noter, en plus, qu'une r�f�rence vers instance du comparateur est pass� au constructeur de la priority_queue. Au pire, qu'il y ait une copie du comparateur � la construction pour garantir l'existence du comparateur serait tout � fait logique, mais une multitude de copies pour chaque op�rations ??

En plus on ne peut pas d�finir de static operator() .

Je suis conscient que c'est du pinaillage parce que ce n'est pas la mort de recopier une structure sans attribut, mais quand m�me je trouve que c'est du g�chis. A moins que quelqu'un ait une explication raisonnable qui explique ce choix de conception. Si c'est le cas, je serai plus qu'heureux de l'entendre (je veux dire de la lire).