c++ - reserva - ¿Por qué std:: equal_to causa una asignación dinámica?

memoria dinamica y estatica en c

Question

Considere el siguiente ejemplo simple, donde estoy usando std::equal_to para comparar dos std::pair<std::string, unsigned> . El operator new está sobrecargado para que imprima un mensaje cuando se realicen las asignaciones (código en vivo here ):

#include <functional>
#include <string>
#include <iostream>

// overloaded to see when heap allocations take place
void* operator new(std::size_t n)
{
    std::cout << "Allocating " << n << std::endl;
    return malloc(n);
}

int main()
{
    using key_type = std::pair<std::string, unsigned>;
    auto key1 = std::make_pair(std::string("a_______long______string______"), 1);
    auto key2 = std::make_pair(std::string("a_______long______string______"), 1);

    std::cout << "Finished initial allocations/n/n" << std::endl;

    std::equal_to<key_type> eq;
    eq(key1, key2); // how can this cause dynamic allocation???
}

El mensaje que estoy viendo es

Allocating 31
Allocating 31
Finished initial allocations


Allocating 31
Allocating 31

Puede ver que hay dos asignaciones que tienen lugar cuando se comparan key2 y key2 . ¿Pero por qué? El operador de std::equal_to toma sus argumentos por referencia constante, por lo que no debería realizarse ninguna asignación ... ¿qué me estoy perdiendo? Gracias.

Answer 1

Es porque haces copias de las parejas.

Los tipos de keyX son std::pair<std::string, int> . eq tiene un operador de llamada de función para los argumentos const std::pair<std::string, unsigned>&, const std::pair<std::string, unsigned>& . Como los tipos no coinciden, las referencias no pueden vincularse a los argumentos directamente. Sin embargo, int es implícitamente convertible a unsigned y, por lo tanto, un par dado se puede convertir implícitamente al par de argumentos.

Entonces, usted crea implícitamente un par de argumentos temporales para la comparación. La creación de las cadenas temporales provoca la asignación de memoria.

Si hubiera usado std::equal_to<> como operador de comparación, no habría creado copias, ya que deduce los tipos de argumentos y, por lo tanto, no habría causado la conversión.