Articles of c ++ 11

C ++ 11 static_assert e instanciação de modelo

Em C ++ 11, deve a operação de static_assert dentro de um modelo depender se esse modelo foi instanciado ou não? Por exemplo, com o seguinte código template void sa() { static_assert(0,”Hello.”); } int main(int argc, char *argv[]) { return 0; } O GCC 4.5.0 falhará na asserção e produzirá o “Olá”. mensagem. A versão […]

A movimentação de um vetor invalida os iteradores?

Se eu tiver um iterador no vetor a , então eu movo-construo ou movimento-atribuo vetor b de a , esse iterador ainda aponta para o mesmo elemento (agora no vetor b )? Aqui está o que quero dizer em código: #include #include int main(int argc, char *argv[]) { std::vector::iterator a_iter; std::vector b; { std::vector a{1, […]

Por que o std :: move impede o RVO?

Em muitos casos, ao retornar um local de uma function, o RVO entra em ação. No entanto, pensei que usar explicitamente o std::move pelo menos reforçaria a movimentação quando o RVO não acontece, mas o RVO ainda é aplicado quando possível. No entanto, parece que este não é o caso. #include “iostream” class HeavyWeight { […]

modelo variadico recursivo para imprimir o conteúdo de um pacote de parâmetros

Como é possível criar um modelo variadico recursivo para imprimir o conteúdo de um pacote paramater? Eu estou tentando com isso, mas não consegue compilar: template std::string type_name () { return std::string(typeid(First).name()) + ” ” + type_name(); } std::string type_name () { return “”; } Como terminarei a recursion?

Existe um equivalente não atômico de std :: shared_ptr? E porque não há um em ?

Esta é uma questão de duas partes, tudo sobre a atomicidade de std::shared_ptr : 1. Tanto quanto eu posso dizer, std::shared_ptr é o único ponteiro inteligente em que é atômico. Eu estou querendo saber se existe uma versão não-atômica de std::shared_ptr disponível (não consigo ver nada em , então também estou aberto a sugestões fora […]

Auto C ++ 11: e se obtiver uma referência constante?

Por favor, dê uma olhada no seguinte código simples: class Foo { public: Foo(){} ~Foo(){} Foo(const Foo&){} Foo& operator=(const Foo&) { return *this; } }; static Foo g_temp; const Foo& GetFoo() { return g_temp; } Eu tentei usar auto assim: auto my_foo = GetFoo(); Eu esperava que my_foo fosse uma referência constante ao Foo , […]

pointers inteligentes e matrizes

Como os pointers inteligentes lidam com matrizes? Por exemplo, void function(void) { std::unique_ptr my_array(new int[5]); } Quando my_array sai do escopo e é destruído, toda a matriz de inteiros é re-reivindicada? Somente o primeiro elemento do array é recuperado? Ou há algo mais acontecendo (como comportamento indefinido)?

Quando usar std :: begin e std :: end em vez de versões específicas do contêiner

Existem algumas preferências gerais ou regras que explicam quando as versões específicas de contêiner de início e fim devem ser usadas em vez das funções livres std::begin e std::end ? No meu entender, se a function é um modelo pelo qual o tipo de container é um parâmetro de template, std::begin e std::end devem ser […]

As referências de valor permitem referências pendentes?

Considere o abaixo. #include using std::string; string middle_name () { return “Jaan”; } int main () { string&& danger = middle_name(); // ?! return 0; } Isso não computa nada, mas compila sem erros e demonstra algo que eu acho confuso: o danger é uma referência pendente, não é?

C ++ 11 equivalente para impulsionar shared_mutex

Existe um equivalente em C ++ 11 para o boost::shared_mutex . Ou outra solução para lidar com uma situação de múltiplos leitores / gravador único no C ++ 11?