c++ - qué - parametros y argumentos

¿Por qué GCC piensa que el parámetro de plantilla es int mientras que es un tipo completamente diferente?

Question

Tengo un problema con la compilación del siguiente programa usando GCC (probé varias versiones, todas fallan con el mismo error). Se compila bien en Clang:

#include <vector>

struct Tag1
{
    static void logAllocation(){}
    static void logDeallocation(){}
};
struct Tag2
{
    static void logAllocation(){}
    static void logDeallocation(){}
};

template<typename Tag, typename T>
struct MyAllocator
{
    using value_type = typename std::allocator<T>::value_type;

    T* allocate(std::size_t n)
    {
        Tag::logAllocation();
        return std::allocator<T>{}.allocate(n);
    }

    void deallocate(T* p, std::size_t n)
    {
        Tag::logDeallocation();
        std::allocator<T>{}.deallocate(p, n);
    }
};

int main()
{
    std::vector<int, MyAllocator<Tag1, int>> vec;
}

El problema es que GCC piensa que Tag==int dentro de MyAllocator y obtengo el error de que ''logDeallocation'' no es miembro de ''int'' . ¿Es este un error en GCC? Cuando doy vuelta a los parámetros de la plantilla ( template<typename T, typename Tag ) y declaro mi vector como std::vector<int, MyAllocator<int, Tag1>> vec; se compila.

Answer 1

Este no es un asignador conforme, y suministrarlo como uno a un componente de la biblioteca da como resultado un comportamiento indefinido (por lo tanto, ambas implementaciones son conformes). ¡Falta != , == , conversión implícita de tipo cruzado y, según corresponda, rebind .

La implementación predeterminada de la rebind allocator_traits asume que el tipo de valor es el primer parámetro de la plantilla (y que cualquier parámetro de la plantilla restante se puede reutilizar sin modificar). Dado que no es el caso de su asignador, debe proporcionar su propio rebind o invertir el orden de los parámetros de la plantilla.

vector es bastante especial, ya que la implementación puede, si así lo desea, simplemente usar el asignador provisto tal como está sin volver a vincularlo. Es por eso que tu código de ejemplo se compila con libc ++. Los contenedores de libstdc ++ admiten una extensión que le permite hacer vector<int, allocator<char>> , por lo que siempre vuelve a vincular el asignador al value_type especificado.