Articles of c ++ 14

Dedução de tipo de retorno com um protótipo explícito em C ++

Eu tenho jogado com a dedução de tipo de retorno suportada em g + + com -std = c + + 1y. Se você prototipar uma function com um tipo de retorno explícito e depois tentar definir a function com dedução de tipo de retorno, o compilador reclamará de uma declaração antiga ambígua: std::string some_function(); […]

Use enum para determinar o tipo de resultado de retorno (um hack usando Macro)

Eu tenho muitos tipos de objects de jogo que estão relacionados juntos é de algumas maneiras. Todas as relações são implementadas pelo Map . #include using namespace std; template class Map{ //N:N relation public: std::vector getK2(K1* k1){/* some code */return std::vector();} public: std::vector getK1(K2* k2){/* some code */return std::vector();} //… various function … }; Aqui […]

n = {0,1,…, n-1} em C ++

A definição formal (na teoria dos conjuntos) de um número natural n é a seguinte: 0 é o conjunto vazio 1 = {0} n = {0,1, …, n-1} Eu acho que isso tornaria algum código C ++ muito mais simples, se eu pudesse fazer isso: for (int n : 10) cout << n << endl; […]

Ligação externa para o nome dentro do namespace sem nome

De acordo com a cláusula 3.5 / 4 do padrão C ++: Um namespace sem nome ou um namespace declarado direta ou indiretamente em um namespace sem nome possui uma binding interna. Simultaneamente no parágrafo 7.3.1.1 temos nota 96): Embora as entidades em um namespace sem nome possam ter uma binding externa, elas são efetivamente […]

Passando diferentes lambdas para o template de function em c ++

Eu tenho uma class Foo que aceita diferentes variantes de predicado através de seu construtor. template struct Value { T value; }; class Foo { public: template Foo(Value &value, function predicate) { } template Foo(Value &value, function<bool(const Value &)> predicate) : Foo(value, function([&value, predicate](){ return predicate(value); })) { } }; Isso me permite construir a […]

C ++ 11/14 e devolução (…) vs retorno

Em C ++ você tem permissão para escrever uma declaração de retorno que se pareça com: return ( … ); que é diferente do mais popular: return … ; Em particular, a primeira versão retorna o endereço / referência de algo que é local para a pilha da function que contém essa instrução de return […]

std :: is_constructible não fornece o resultado correto

Originado deste tópico do CodeReview: #include #include #include #include #include template class aggregate_wrapper : public T { private: using base = T; public: using aggregate_type = T; template aggregate_wrapper(Ts&&… xs) : base{std::forward(xs)…} { // nop } }; struct foo_t { foo_t(int) {} }; int main() { std::cout << std::is_constructible::value << std::endl; std::cout << std::is_constructible<aggregate_wrapper>::value << […]

C ++ Atribuir ao lvlv implicitamente convertido

Considere este trecho de código C ++: struct Foo { float value; operator float& () { return this->value; } }; int main() { Foo foo; foo=1.0f; //Doesn’t compile, foo isn’t implicitly converted to a float& return 0; } Por que isso não compila? Existe uma razão específica para isso não estar incluído no padrão C […]

Aridade de agregado em tempo logarítmico

Como definir aridade de um agregado em tempo de compilation logarítmico (pelo menos na base dois) (estritamente falando, em número logarítmico de instanciações)? O que eu posso fazer atualmente é alcançar o desejado em um tempo linear: #include #include struct filler { template operator type (); }; template< typename A, typename index_sequence = std::index_sequence, typename […]

SFINAE falha ao avaliar um constexpr em um parâmetro de modelo?

Por algum motivo, este constexpr não está sendo avaliado corretamente em um contexto de parâmetro de modelo: #include #include namespace detail { // Reason to use an enum class rahter than just an int is so as to ensure // there will not be any clashes resulting in an ambigious overload. enum class enabler { […]