Articles of modelos em

Pacote de parâmetros do modelo de function não no final da lista de parâmetros

O código a seguir compila e executa ok. void foo() { } template void foo(T x, Args… args) { cout << x << endl; foo(args…); } // inside main() foo(1,1,1); Este outro código não compila: void foo() { } template void foo(Args… args, T x) { foo(args…); cout << x << endl; } // inside […]

modelo c ++ parece quebrar os especificadores de access

O código a seguir não é compilado por razões óbvias, ou seja, que o Foo está tentando acessar um membro privado do Bar. No entanto, se você descomentar / comentar as linhas marcadas, fazendo Foo um modelo, ele compila e produz 42. O que estou perdendo aqui? Por que isso funciona? Parece que não deveria. […]

Modelos parametrizados para enums

Eu quero fazer isso: template class Message { private: Type m_type }; enum StdInMessages { PrintHello, Echo, … }; class StdInMsg : Message { … } enum NetworkMessages { DoSomethingElse, Shutdown … }; class NetworkMsg : Message { … } Claro, as mensagens reais são ligeiramente diferentes Por que isso não funciona? template class ATemplate […]

O Clang não pode manipular uma especialização de modelo usando o modelo de modelo referenciado, mas o GCC pode

Eu uso um padrão como o seguinte na minha arquitetura genérica. Compila e executa corretamente no GCC 5.2.0: #include using namespace std; template class Foo { public: void foo(){cout<<"Foo method";} }; template<template class FooType> class BarBase: public FooType { public: double bar() {cout<<"Generic bar";} }; template<template class FooType> class Bar: public BarBase { }; template […]

sfinae na function de membro definida fora do corpo da class

Tipo de continuação da minha pergunta anterior . O que eu tenho é um monte de funções que formam uma cadeia de dependência sfinae assim (deixe a notação “A -> B” significa que a existência de A depende da existência de B): S::f_base -> S::f -> ns::f_ -> f -> T::f onde T é o […]

Usando uma referência de lvalue como um parâmetro de modelo não-tipo

Eu li que os seguintes tipos são permitidos como parâmetros de modelo não-tipo: tipos integrais enum ptr para objects / methods Referência de valor a objects / methods std :: nullptr_t Eu não entendo como um ponteiro não constante ou uma referência lvalue é aceitável? Eles não deveriam ser tipos constantes para que sejam identificados […]

A dedução de modelo falha com o argumento após o pacote de parâmetros

Eu tenho essa function: template void f(Args… args, int last) { } A dedução de modelo falha se eu a chamar sem parâmetros de modelo explícitos: f(2, 2); // candidate expects 1 argument, 2 provided Mas fornecer os parâmetros explícitos do modelo para o pacote de parâmetros funciona: f(2, 2); // compiles fine Mesmo que […]

Retorna um valor dependendo do tipo

Considere o seguinte exemplo template class MyClass { public: double getValue() { // if “Type == void” return _x, if “Type != void” return _y return (/* SOMETHING */) ? (_x) : (_y); } protected: double _x; static const double _y; }; Qual poderia ser a condição /* SOMETHING */ ? Eu quero retornar _x […]

Determinando o tipo de retorno de std :: function

Estou escrevendo uma function de template que recebe um object std::function (Gerado chamando std::bind com os argumentos apropriados). Dentro dessa function, gostaria de determinar o tipo de retorno desse object de function. É possível? De fato, eu quero que a function template retorne o mesmo tipo. Você consegue pensar em uma maneira elegante e padronizada […]

nenhuma function correspondente para chamada para o modelo de function

template void f(int[10][i]) { }; int main() { int a[10][30]; f(a); } Por que o f(a) falha? http://ideone.com/Rkc1Z