Articles of c ++ 11

¿Deberíamos pasar un shared_ptr por referencia o por valor?

Cuando una función debe tomar un shared_ptr (de boost o C ++ 11 STL), ¿lo está pasando? por const referencia: void foo(const shared_ptr& p) o por valor: void foo(shared_ptr p) ? Preferiría el primer método porque sospecho que es más rápido. ¿Pero esto realmente vale la pena o hay algún problema adicional? ¿Podría explicar los […]

El más simple y más limpio c ++ 11 ScopeGuard

Intento escribir un ScopeGuard simple basado en los conceptos de Alexandrescu pero con modismos de C ++ 11. namespace RAII { template class ScopeGuard { mutable bool committed; Lambda rollbackLambda; public: ScopeGuard( const Lambda& _l) : committed(false) , rollbackLambda(_l) {} template ScopeGuard( const AdquireLambda& _al , const Lambda& _l) : committed(false) , rollbackLambda(_l) { _al(); […]

Diferencia entre puntero y referencia como parámetro de hilo

Este es el ejemplo: #include #include using namespace std; void f1(double& ret) { ret=5.; } void f2(double* ret) { *ret=5.; } int main() { double ret=0.; thread t1(f1, ret); t1.join(); cout << "ret=" << ret << endl; thread t2(f2, &ret); t2.join(); cout << "ret=" << ret << endl; } Y la salida es: ret=0 ret=5 […]

Diferencias entre std :: make_unique y std :: unique_ptr

¿Tiene std::make_unique algún beneficio de eficiencia como std::makes_shared ? Comparado con la construcción manual de std::unique_ptr : std::make_unique(1); // vs std::unique_ptr(new int(1));

¿Por qué la definición de “diseño estándar” POD de C ++ 11 es como es?

Estoy investigando la definición nueva y relajada de POD en C ++ 11 (sección 9.7) Una clase de diseño estándar es una clase que: no tiene miembros de datos no estáticos de clase de diseño no estándar (o matriz de tales tipos) o referencia, no tiene funciones virtuales (10.3) ni clases base virtuales (10.1), tiene […]

¿Por qué la deducción de argumento de la plantilla está deshabilitada con std :: forward?

En VS2010 std :: forward se define como tal: template inline _Ty&& forward(typename identity::type& _Arg) { // forward _Arg, given explicitly specified type parameter return ((_Ty&&)_Arg); } identity parece ser utilizada únicamente para deshabilitar la deducción del argumento de la plantilla. ¿Para qué sirve deshabilitarlo a propósito en este caso?

Hash genérico para tuplas en unordered_map / unordered_set

¿Por qué std::unordered_map<tuple, string> simplemente funciona de la caja? Es tedioso tener que definir una función hash para tuple , por ej. template struct do_hash<tuple> { size_t operator()(std::tuple const& tt) const {…} }; Construir un mapa desordenado con tuplas como teclas (Matthieu M.) muestra cómo automatizar esto para boost::tuple . ¿Hay alguna forma de hacer […]

¿Es posible is_constexpr en C ++ 11?

¿Es posible producir un valor booleano en tiempo de comstackción en función de si una expresión C ++ 11 es una expresión constante (es decir, constexpr ) en C ++ 11? Algunas preguntas sobre SO se relacionan con esto, pero no veo una respuesta directa en ninguna parte.

Inicializando una matriz miembro en el inicializador del constructor

class C { public: C() : arr({1,2,3}) //doesn’t compile {} /* C() : arr{1,2,3} //doesn’t compile either {} */ private: int arr[3]; }; Creo que la razón es que las matrices solo se pueden inicializar con la syntax = , es decir: int arr[3] = {1,3,4}; Preguntas ¿Cómo puedo hacer lo que quiero hacer (es […]

initializer_list y tipo de plantilla deducción

Considera la función: template void printme(T&& t) { for (auto i : t) std::cout << i; } o cualquier otra función que espere un parámetro con un tipo begin () / end () – enabled. ¿Por qué es ilegal lo siguiente? printme({‘a’, ‘b’, ‘c’}); Cuando todos estos son legítimos: printme(std::vector({‘a’, ‘b’, ‘c’})); printme(std::string(“abc”)); printme(std::array {‘a’, […]