Sé que el siguiente código no se compilará. void baz(int i) { } void baz() { } class Bar { std::function<void()> bazFn; public: Bar(std::function<void()> fun = baz) : bazFn(fun){} }; int main(int argc, char **argv) { Bar b; return 0; } Porque std::functionse dice que no...
Tengo una función que toma dos argumentos: template <typename T1, typename T2> void foo(T1 arg1, T2 arg2) { std::cout << arg1 << " + " << arg2 << '\n'; } Y una variable que debe reenviar sus argumentos en pares: template <typename... Args> void...
Tengo el siguiente código con plantilla #include <vector> #include <array> #include <iostream> template<typename T1> void foo(std::vector<T1> bar) { std::cout << "GENERIC" << std::endl; } template<typename T1> void
¿Hay alguna manera de pasar una referencia como argumento a un argumento de nombre de tipo de plantilla? Quiero decir que en lugar de pasar un int, por ejemplo, pasar una referencia a un int. template <typename T> struct Foo { Foo(T arg) : ptr(arg) {} T ptr; }; int main() { int* a = new...
Tengo un código como template <size_t N> class A { template <size_t N> someFunctions() {}; }; Ahora quiero crear instancias de la clase y llamar a las funciones en un bucle for para un conjunto de muchos valores como // in main() int main() { for (int i = 1; i <= 100; i++)...
Últimamente escribí una función de plantilla para resolver algunas repeticiones de código. Se parece a esto: template<class T, class R, class... Args> R call_or_throw(const std::weak_ptr<T>& ptr, const std::string& error, R (T::*fun)(Args...), Args... args) { if (auto sp =...
Hola, he visto muchos ejemplos como este en Cppreference.com: std::is_class<T> std::is_integral Y así. Sé que si ejecuto el código, por ejemplo, obtengo trueo false. ¿Pero cuál es el punto en eso? por ejemplo, ¿saber que el objeto es de tipo de clase o no? #include...
template<class Msg, class... Args> std::wstring descf(Msg, Args&&... args) { std::wostringstream woss; owss << Msg << ". " << ... << " " << args << ": '" << args << "' ";//not legal at all //or owss << Msg << ". "...
No entiendo cuál es el problema: ya sea en mi código o en el compilador (menos posible). Hay un código como este: #include <iostream> #include <type_traits> #include <set> template<typename T, typename = void> struct TestA: std::false_type {}; template<typename...
Cuando queremos usar a static_asserten a if constexprdebemos hacer que la condición dependa de algún parámetro de plantilla. Curiosamente, gcc y clang no están de acuerdo cuando el código está envuelto en una lambda. El siguiente código se compila con gcc, pero clang activa la afirmación, incluso...
Tengo una plantilla de función que toma muchos tipos diferentes como entrada. De esos tipos, solo uno de ellos tiene una getInt()función. Por lo tanto, quiero que el código ejecute la función solo para ese tipo. Por favor sugiera una solución. Gracias #include <type_traits> #include...
Quiero comparar estructuras de forma genérica y he hecho algo como esto (no puedo compartir la fuente real, así que solicite más detalles si es necesario): template<typename Data> bool structCmp(Data data1, Data data2) { void* dataStart1 = (std::uint8_t*)&data1; void* dataStart2 =...
El siguiente código no se compila con gcc o clang. template<class T> class foo{}; template<class T> class template_class_with_struct { void my_method() { if(this->b.foo < 1); }; struct bar { long foo; } b; }; Mensaje de error es error: type/value mismatch at argument 1...
Considere el siguiente código: template<int i> class A { typedef A<i-1> B; B x, y; }; template<> class A<0> { char m; }; int main() { A<LEVEL> a; } Al comparar su compilación por g ++ con el siguiente comando Bash (con g ++ 8.3.0) for ((level=1; level<30;...
Dado que los conceptos se definen como predicados en tiempo de compilación, ¿también es posible reutilizar estos predicados para algoritmos en tiempo de compilación? Por ejemplo, ¿sería posible verificar si todos los tipos de una tupla se ajustan a un concepto? Por lo que he visto, no es posible...
Hasta el estándar C ++ 20 de C ++, cuando queríamos definir un operador fuera de clase que usara algunos miembros privados de una clase de plantilla, usaríamos una construcción similar a esta: template <typename T> class Foo; template <typename T> constexpr bool operator==(T lhs,...
El siguiente ejemplo sin sentido no se compila, pero ¿hay alguna otra forma de pasar una plantilla variable como argumento de plantilla? template<typename T> constexpr auto zero = T{0}; template<typename T, template<typename> auto VariableTemplate> constexpr auto add_one() {...
He estado leyendo sobre eliminar la referencia de un tipo, aquí . Da el siguiente ejemplo: #include <iostream> // std::cout #include <type_traits> // std::is_same template<class T1, class T2> void print_is_same() { std::cout << std::is_same<T1, T2>() <<...
Considere las 2 siguientes sobrecargas template<typename T> bool test() { return true; } template<template<typename ...> class T> bool test() { return false; } El primero funciona para clases regulares, mientras que el segundo funciona para plantillas que no se instancian....
Considere el siguiente programa. #include <iostream> template <typename T> void f( void ( *fn )( T ) ) { fn( 42 ); } void g( int x ) { std::cout << "g( " << x << " );\n"; } int main() { f( g ); } El programa se compila correctamente y su salida es g( 42...