Existem recursos para identificar problemas que poderiam ser melhor resolvidos com modelos?

Decidi melhorar meus conhecimentos em meta-programação de modelos. Conheço a sintaxe e as regras e tenho jogado com inúmeros exemplos de recursos online.

Entendo o quanto os modelos podem ser poderosos e a otimização do tempo de compilação que eles podem fornecer, mas ainda não consigo "pensar em modelos", não consigo saber por mim mesmo se um determinado problema pode ser melhor resolvido com modelos e, se puder, como adaptar esse problema aos modelos.

Existe algum tipo de recurso ou livro on-line que ensina como identificar problemas que poderiam ser melhor resolvidos com modelos e como adaptar esse problema?

Livros:

Design moderno em C ++

Metaprogramação de modelos C ++

Estar familiarizado com a recursão e a programação funcional é uma enorme vantagem, pois é isso que envolve muito tmp. Ele está completo e, portanto, essencialmente tudo é possível, embora geralmente tudo se refira a aplicar funções puras a constantes ou a gerar tipos de outros tipos.

Atenção: tmp é um monstro feio que transforma um bom código em espaguete. Quanto mais você usa, menos você gosta de C ++. É uma coisa má.

Aprenda Haskell ou alguma outra linguagem funcional pura (Lisp, Scheme, OCaml, para citar algumas, você pode encontrar mais na Wikipedia ).

Considerando Haskell, você pode encontrar mais informações sobre suas instalações de metaprogramação aqui .

A programação de modelos segue as mesmas regras, na verdade.

Só porque você pode fazer algo com modelos não significa que você deveria. Praticamente falando, a menos que, quando você estiver projetando, pense que este é um trabalho incrível para modelos, provavelmente é melhor não usá-los. se você pensa demais em modelos, apenas cria um código insanamente abstrato que é tão ruim quanto uma única função gigante.

Lembre-se de que os modelos sendo a melhor solução são muito raros. Eu só defini o meu uma vez nos últimos 5 anos, e meus colegas que revisaram esse código nunca o fizeram. Os casos em que os modelos fazem muito sentido já foram implementados na maioria das bibliotecas padrão.

Para programação genérica, o importante a ser observado é que você está copiando e colando funções para fazer apenas pequenas alterações, como constantes ou tipos, e não consegue descobrir uma maneira limpa de usar algo como herança ou parâmetros de função para evitar repetições. você mesmo.

Uma maneira bastante comum de os modelos serem utilizados é a segurança de tipos, se você tiver tipos que se comportam da mesma forma, mas, por qualquer motivo, não os queira misturar acidentalmente.

Para o cálculo do tempo de compilação usando modelos, o importante a ser observado é o uso intensivo de recursos, onde todas as suas entradas são conhecidas em tempo de compilação, mas onde diferentes entradas constantes são usadas em diferentes locais do código. No entanto, lembre-se de que isso reduzirá a velocidade de suas compilações todas as vezes; portanto, é preferível codificar manualmente os resultados manualmente, se eles não forem alterados com muita frequência.

Alguns advogados usam modelos para micro-otimizações, como evitar pesquisas de tabelas virtuais usando polimorfismo estático ou desenrolar o loop, mas na minha opinião a complexidade geralmente supera os ganhos de desempenho, a menos que seu código seja muito crítico para o desempenho.

Basicamente, existem vários bons motivos para usar modelos:

1. Você tem uma função ou uma classe que possui a mesma funcionalidade para tipos diferentes. Um bom exemplo de uso de bons modelos é a biblioteca de impulso
2. você deseja usar o polimorfismo estático e obter erros de compilação, em vez de erros em tempo de execução
3. você deseja obter um comportamento específico, dependendo de alguns parâmetros estáticos. Por exemplo, boost :: type_traits fornece bons exemplos.

Você definitivamente deve procurar modelos em C ++! Isso o ajudará bastante a entender tópicos como Design Patterns e Generic Programming. Compare-os com o que outros idiomas lhe oferecem. Em detalhes, você deve usar modelos, especialmente nos seguintes cenários:

1. Generalização e Reutilização de Código
2. Flexibilidade
3. Restrições de tempo e orçamento
4. Falta de conhecimento para uma determinada tarefa

Aqui está um bom recurso on-line para você: http://en.wikipedia.org/wiki/Generic_programming#Templates_in_C.2B.2B

Um indicador simples de quando um modelo melhoraria seu código é quando você vê que seu código frequentemente exige que você projete um objeto em um tipo diferente. Um exemplo que encontrei no meu próprio código Java, o que me levou a converter uma assinatura de método existente em um modelo:

    public MsgBase getLastSentMessage(Class<? extends MsgBase> msgBaseClass)

Meu código de cliente sempre se parecia com isso:

    OrderResponse response = (OrderResponse) getLastSentMessage(OrderResponse.class);

e sempre que usei esse método, tive que converter o resultado na subclasse correta do tipo MsgBase. A assinatura do método aprimorado foi:

    public <T extends MsgBase> T getLastSentMessage(Class<T> clazz)

Agora o código do cliente era:

     OrderResponse response = getLastSentMessage(OrderResponse.class);

Então, para resumir, se você se deparar com muitas interpretações que parecem desnecessárias, você pode ter um bom caso em que um modelo limpará seu código.

Atualização: uma maneira melhor de generalizar a declaração acima:

Quando sua classe de origem será usada por objetos de muitos tipos diferentes, e a classe de origem puder interagir com esses tipos em um nível mais alto (mais abstrato), mas suas classes de clientes quiserem interagir com subtipos específicos, esse é o caso do uso de modelos . (Classes Container / List sendo o exemplo bem conhecido).

Ainda hoje, usei modelos para implementar uma máquina de estados finitos para extrair alguma contribuição. Os modelos de expressão são ferramentas extremamente poderosas para implementar conceitos de código como esse - eles funcionam como C ++ otimizado à mão e são obscenamente rápidos, mas muito genéricos e fáceis de escrever.

De um modo geral, os modelos fazem mais sentido ao implementar algoritmos genéricos. Se você não está implementando um algoritmo genérico, eles não fazem muito sentido.

Os usos mais comuns dos modelos são os seguintes:

std::vector<int> vec;
std::map<int, float> mymap;

O próximo exemplo comum é:

template<class T>
class MyArray {
public:
   virtual T get(int i) const=0;
};

Juntamente com este tipo de uso:

class ArrayImpl : public MyArray<float> {
public:
     float get(int i) const { }
};

Aquele mostrou parte importante dos modelos, que é a substituição do tipo - T é substituído pelo tipo float nos dois locais em que é usado.