c++ - guia - qgis manual

Funcionantes de operador transparente

Question

Visual Studio 2013 Preview es compatible con una función de C ++ 14 llamada (según this página) "Funcionadores de operador transparente". No tengo claro lo que eso significa. La propuesta más cercana de C ++ 14 que encontré es esta, pero no estoy seguro si es lo mismo: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3421

Estoy buscando una explicación más clara de lo que es, por qué es una mejora, y tal vez un fragmento que demuestre su uso.

Answer 1

La propuesta transparente de funtores del operador está ahí como una forma de tener funtores generalizados que se encuentran en <functional> . Personalmente, creo que la propuesta en sí tiene un muy buen ejemplo que podría ayudar a ilustrar la necesidad. Sin embargo, seguiré adelante y trataré de explicarlo también.

Supongamos que tiene una función, una función muy básica:

template<typename T, typename U>
auto less_than(T&& t, U&& u) -> decltype(std::forward<T>(t) < std::forward<U>(u)) {
    return std::forward<T>(t) < std::forward<U>(u);
}

Sin embargo, desea utilizar esta función generalizada en el encabezado <algorithm> . Tienes dos opciones, para que sea un functor de estructura:

struct MyLessThanFunctor {
    template<typename T, typename U>
    auto operator()(T&& t, U&& u) -> decltype(std::forward<T>(t) < std::forward<U>(u)){
        return std::forward<T>(t) < std::forward<U>(u);
    }
};

O en C ++ 14, para hacer una lambda polimórfica:

[](auto&& t, auto&& u) -> decltype(auto) { 
    return std::forward<decltype(t)>(t) < std::forward<decltype(u)>(u); 
}

Ambos son muy detallados cuando se usan en un algoritmo como ese:

int main() {
    std::vector<int> v = {112,12,1281271,1919101,29181,412,1 };
    std::sort(std::begin(v), std::end(v), MyLessThanFunctor()); // one
    std::sort(std::begin(v), std::end(v), [](auto&& t, auto&& u) -> decltype(auto) { 
        return std::forward<decltype(t)>(t) < std::forward<decltype(u)>(u); 
    });
}

Esta propuesta pretende hacerla más compacta y generalizada al hacer esto en su lugar:

std::sort(std::begin(v), std::end(v), std::less<>());

Esto le proporciona un reenvío perfecto y resuelve los problemas de truncamiento o problemas que surgen al cambiar el contenedor, pero no el tipo subyacente designado por el contenedor como se menciona en el documento.

Supongamos que tiene un functor no generalizado:

struct Functor {
    bool operator()(uint32_t a, uint32_t b) {
        return a < b;
    }
};

Y lo usas con std::vector<uint32_t> y funciona perfectamente, pero te olvidas de que tu functor no está generalizado y lo usas con std::vector<uint64_t> . ¿Puedes ver el problema que ha surgido? Los elementos se truncarán antes de ser comparados, lo que probablemente no sea lo que el usuario quería. Los funtores generalizados resuelven este problema por usted antes de que surjan.