Os templates são alternativas as sobrecargas de funções. Eles permitem que os programadores reutilizem uma boa parte do código, criando definições genéricas para funções e classes, capazes de se adaptar a diferentes tipos de dados. Os templates são especialmente úteis quando uma mesma lógica é aplicável a diversos tipos de dados. E como desvantagem, um código com templates pode ter um tempo de compilação maior.

Quando criamos um template desenvolvemos um código com um “tipo de dado genérico”, e no momento da utilização este tipo genérico é capaz de se adaptar automaticamente aos tipo dados reais que são inseridos nas funções ou classes.

Para construir um template basta adicionar a expressão junto com a declaração da função ou classe, e usar o para receber dados e desenvolver o código.

Na hora de usar um template, é só usar a função normalmente, ou instanciar um objeto da classe de maneira usual, e o próprio C++ irá identificar os tipos inseridos e automaticamente adaptar o para o tipo real inserido. Mas podemos utilizar as chaves para determinar explicitamente os tipos que devem ser usados.

Vamos nessa, galerinha!

Essa é uma daquelas questões de encontrar erros. A melhor forma de resolver é olhar cada uma das linhas e procurar por problemas.

Os problemas começam a aparecer na linha 04.

Se você olhar com atenção, vai notar que o sufixo de template está errado. A forma correta do sufixo é:

O primeiro erro é que a linha começa com a palavra-chave errada, o correto é iniciar um template usando a palavra chave

O segundo erro é que a palavra-chave está no lugar errado. O correto é usar o dentro dos símbolos .

E existe mais um erro, o uso inadequado do ponto-e-vírgula . Esse símbolo não deve ser usado no final do template. Lembre-se que o sufixo de template faz parte da declaração da função.

No caso desse código o nome do tipo genérico é , então com isso está tudo certo.

Vamos aplicar estas correções no código:

Vamos pra linha seguinte. Na linha 05 nós fazemos a declaração do template de função propriamente dito.

A vantagem do template é que ele pode usar o tipo genérico que foi definido na linha anterior.

Mas a um erro na linha 05, os parâmetros da função não estão declarados corretamente. O segundo parâmetro não possui nenhum tipo!

Vamos fazer a correção. Vamos adicionar o tipo genérico logo antes do parâmetro na linha 05:

Show de bola

Olhando pras próximas linhas, tudo parece está certo agora. Mas pra ter certeza, vamos rodar o código usando as correções que fizemos na linha anterior.

E prontinho. Código rodando liso que nem manteiga!

E aí galerinha. Vamos pra mais um exercício maneiro.

1. Explique o motivo deste erro.

Esse é um daqueles exercício em que o código tem um erro. Esse é um erro um tanto difícil de encontrar apenas olhando, mas pra nossa sorte a questão já informou que o erro está no terceiro , o da linha 14.

O erro é sutil, e pra entender a gente precisar olhar antes pra definição de template nas linhas 04 e 05



Olha só, na declaração da função-template definimos os dois parâmetros e usando o mesmo tipo genérico .

Agora vamos olhar pra linha 14, que é onde o compilador avisa do erro. Nessa linha, a gente entrega pra função dois parâmetros de tipos diferentes. O é um inteiro, e o é um .



Quando o compilador tentar rodar essa linha ele vai ficar doidinho. Pois ele não vai saber se o tipo genérico deve ser considerado como , ou se deve ser considerado como .

Se você tentar rodar esse código, o seu compilador vai informar um erro parecido com esse:



Que basicamente está dizendo “não existe um template chamado em que os parâmetros possam ter tipos diferentes!”

Passo 2

2. Corrija o erro sem alterar o conteúdo entre parêntesis.

Belezinha. Identificamos o erro, e já explicamos o motivo de ele acontecer. Mas como corrigimos isso?

Uma forma de corrigir o erro seria trocando o valor entre parêntesis, para que os dois valores sejam do mesmo tipo. Porém a questão falou que a gente não pode fazer isso.

A forma mais fácil de corrigir esse erro é forçando que o valor de assuma um tipo predeterminado. Pra fazer isso, a gente pode colocar o tipo que queremos definir dentro de chaves logo depois do nome da função e antes dos parêntesis:

Então, pra corrigir o código, é só a gente ir na linha 14 e forçar que a função template utilize um tipo específico. Para garantir maior precisão, vou forçar o uso do tipo

Agora o código está corrigido! Mas pra garantir, vamos colocar o código pra rodar e ver o resultado:

E aí está. Tudo rodando certinho!

Até a próxima questão, galera!

Vamos lá galerinha.

A questão quer que a gente crie uma função para somar dois números. Mas o diferencial é que vamos utilizar templates.

A vantagem de usar templates é que a função vai conseguir se adaptar a qualquer tipo de dado que for inserido na nossa função.

Então vamos começar escrevendo o cabeçalho do nosso programinha.

Vamos começar desenvolvendo a nossa função template.

Sempre que for começar um template iniciamos com a palavra-chave e em seguida definimos os nomes dos tipos genéricos entre as chaves usando a palavra chave .

Vamos por isso no código. Eu vou chamar o tipo genérico de , mas se você quiser pode dar outro nome.

Agora, usando o tipo genérico a gente desenvolve a função template chamada e que recebe dois parâmetros e que também usam o tipo genérico.

Fazendo isso, a nossa função vai poder receber qualquer tipo de dado, e o retorno da função também vai se adaptar aos tipos de dados.

E essa função vai retornar a soma entre os dois parâmetros inseridos.

Show. O template de função está concluído.

Beleza.

Agora vamos testar o template que a gente desenvolveu. Para testar vamos fazer várias somas inserindo parâmetros com tipos variados.

Na linha 14 inserimos tipos diferentes no mesmo template, então usamos as chaves para forçar que os parâmetros sejam recebidos como tipo .

E rodando o código a gente vai ter o seguinte resultado:

E é isso pessoal. Até o próximo exercício.

Vamos lá pessoal. Essa questão está pedindo pra gente criar uma classe para representar um ponto, mas com alguns detalhes:

O exercício pede que a classe aceite que os valores sejam inteiros ou reais. Uma forma de fazer isso é desenvolvendo uma classe template. Vamos usar um tipo genérico para desenvolver um código, e esse tipo genérico vai se adaptar conforme a necessidade.

Os atributos devem ser privados, então vamos desenvolver métodos gettes e setters. O detalhe é que esses métodos devem ser projetados usando o tipo genérico. Assim, eles poderão se adaptar a qualquer tipo de dado usado na classe.

Para inserir os valores no momento da criação vamos precisar de um método construtor. O detalhe é que esse método também deve usar o tipo genérico. E dessa forma o construtor vai trabalhar com os tipos adequados.

Mas antes de começar tudo isso, vamos escrever o cabeçalho:

Agora é hora de desenvolver o template da classe. Pra desenvolver um template sempre começamos com a sintaxe:

No nosso código vamos chamar o tipo genérico simplesmente de e chamaremos o template de classe de :

Usando esse tipo genérico vamos declarar duas variáveis e no contexto privado. Usando o nosso os atributos vão conseguir se adaptar para números reais ou inteiros.

Em seguida vamos desenvolver o construtor da classe. Lembre-se, o construtor é uma função sem tipo que tem o mesmo nome que a classe. Os parâmetros do nosso construtor são os valores das componentes do ponto que são do tipo genérico . No corpo do construtor vamos apenas assimilar os valores inseridos dentro dos atributos privados.

O passo seguinte e desenvolver os métodos getters, pra que a gente consiga acessar os valores privados da classe. Novamente, devemos lembrar que os atributos e são do tipo genérico , e para um método retornar o valor desses atributos, esse método deve retornar o tipo genérico também! Ou seja, os métodos e devem ser do tipo genérico :

E pra finalizar vamos desenvolver os métodos setters. Como de praxe, os setters são do tipo , afinal eles não precisam retornar nenhum valor, eles só precisam receber um parâmetro e alterar o valor de uma variável privada. O diferencial é que os parâmetros devem ser do tipo genérico , pois assim os parâmetros vão combinar com as variáveis e que queremos alterar.

E com os dois métodos setter concluídos, o template está finalizado!

Show! Vamos por esse template pra trabalhar agora

Pra criar objetos partindo de um template é quase igual a criar um objeto de uma classe, porém usamos as chaves para determinar o tipo de dados que vai substituir o tipo genérico:

Usando essa lógica, no nosso código vamos criar dois pontos com valores aleatórios:

E vamos usar os métodos getters para conferir se deu tudo certo!

E é isso, galerinha! A questão está pronta!

Vamos nessa!

Essa é uma questão simples e direta: construir um template para efetuar uma função de troca.

Lembre-se, uma função de troca deve receber o endereço de memória de duas variáveis, e então trocar os conteúdos existentes em cada endereço.

Então vamos começar com o cabeçalho da questão:

Vamos criar o template da função. Para criar um template a gente usa estrura:

Vamos usar o nome para o nosso tipo, e o nome da função será . A função não precisa de retorno, então o tipo será . Como parâmetros vamos receber duas variáveis por referência, para ter acesso ao endereço de memória.

Importante: os dois parâmetros que vamos receber devem usar o mesmo tipo genérico ! Pois se as variáveis forem de tipos diferentes não vai ser possível executar a troca de valores, pois será necessário efetuar conversões, o que resulta em perda de dados!

Agora vamos desenvolver o algoritmo da função.

Primeiro vamos declarar uma variável temporária que vai segurar o valor atual de .

Depois, sobrescrevemos o valor atual de com o valor de .

E pra finalizar, sobrescrevemos com o valor antigo que está guardado na variável temporária.

Detalhe, como os valores de e foram passados por referência, automaticamente as alterações realizadas dentro da função, serão refletidas nas variáveis que estão fora da função!

Show de bola! Agora é só executar a função!

Vamos declarar duas variáveis e com os valores e . E pra deixar bem legal, vamos imprimir o conteúdo dessas variáveis para o usuário.

Em seguida, vamos aplicar a função troca:

E imprimimos o resultado final:

E o resultado é:

Legal né! Lembrando que isso é um template. Então podemos usar variáveis de qualquer tipo e vamos obter um resultado semelhante!

E aí, pessoal?!

Essa é uma questão trabalhosa, mas que vamos fazer com calma e vai dar tudo certo. A chave da questão é perceber como cada um dos tipos genéricos vai se comportar quando uma função é chamada.

Vamos começar analisando os templates.

Vamos começar observando as classes , e

As três classes são bem similares, e consistem em apenas três atributos inteiros.

São classes sem função real, e tudo que importa pra essa questão é que elas representam tipos diferentes!

Agora vamos analisar as aparições dessas classes na (). Logo no início são declarados um objeto de cada uma das classes: do tipo , do tipo e do tipo .

Vamos analisar o template

O template de função usa apenas um tipo genérico chamado . Ele recebe dois valores do mesmo tipo e retorna como resultado o segundo valor. Ou seja, recebe e retorna valores todos do mesmo tipo!

Agora vamos analisar as aparições da função dentro da .

Esse template de função deve receber dois argumentos e um retorno do mesmo tipo. Então caso haja alguma diferença de tipo, haverá um erro.

Então podemos apontar um erro na linha 08 onde o retorno é diferente do tipo do argumento .

E um outro erro na linha 09 onde os três tipos envolvidos são diferentes.

Em seguida, vamos analisar .

O template de função utiliza dois tipos genéricos e . Essa função recebe dois valores, um de cada tipo, e retorna o segundo valor recebido. O importante é que na função o retorno é do mesmo tipo que o segundo argumento.

Agora vamos ver dentro da

Aqui o importante é que o tipo do retorno seja igual ao tipo do segundo argumento.

E por isso temos um erro na linha 13 onde os tipos e são diferentes.

E na linha 15 onde e são de tipos diferentes.

E por fim, a o template de função .

O template de função utiliza três tipos genéricos , e . Os valores recebidos são de tipos diferentes e antes de retornar, a função converte o tipo de para . Ou seja, a função pode receber dois argumentos de tipos diferentes, e retornar um valor de um terceiro tipo.

Porém, tem um detalhe. O prefixo de declara três tipos genéricos , e . O tipo real de será definido quando for passado o primeiro argumento . O tipo de será definido de acordo com o segundo argumento . Mas em que momento o tipo real de está sendo definido?

O tipo de não é definido em nenhum momento! Então para usar esse template, a única forma é definindo os tipos de , e de forma explicita usando as chaves:

Em nenhum momento o tipo verdadeiro de está sendo definido de forma explicita! Então todos os usos de mostrados no código estão errados.

Para corrigir esse código, primeiro vamos precisar remover as linhas 08 e 09

Depois, devemos remover as linhas 13 e 15.

E nas linhas 19 a 22 devemos adicionar explicitamente os tipos que estão sendo usados no template:

E é isso pessoal! Até a próxima!

Vamos nessa, pessoal.

Nesse exercício envolve um monte de conhecimentos: templates, alocação dinâmica e sobrecarga de operador. É bastante coisa! Mas vai ser divertido fazer essa questão.

A questão pede pra criar um template de classe que represente um vetor, então vamos chamar essa template de .

Dentro do template vamos ter que usar um array alocado dinamicamente para armazenar os elementos do nosso vetor. Se você se lembrar, a melhor forma de fazer isso é alocando a array dentro do construtor, e liberando a memória dentro do destruidor. Depois vamos sobrecarregar o operador .

Então vamos começar com o cabeçalho da questão:

Então vamos declarar o template de classe , e dentro do template vamos declarar o protótipo de todos os métodos.

Para criar um template de classe a gente utiliza a palavra-chave e determinamos um tipo genérico usando e em seguida declaramos a classe:

Template iniciado. Agora vamos pro encapsulamento privado, e declaramos o atributo ponteiro usando o tipo genérico . Afinal de contas, é esse ponteiro que vamos usar para alocar a memória dinamicamente, então ele precisa apontar para o tipo que vamos utilizar no nosso template.

O tamanho do sempre será um valor inteiro, então criamos um atributo que vai armazenar a quantidade de elementos do .

Agora vamos para o encapsulamento público. Aqui vamos criar o protótipo de todos os nossos métodos

Primeiro declararmos o construtor, que é um método sem tipo, e que vai receber o valor inteiro de . Ou seja, é só declarar um construtor normalmente.

Depois declaramos o destruidor, que também é um método sem tipo, então é só declarar um destruidor normalmente.

Agora vamos pensar na sobrecarga do operador . O primeiro detalhe é que esse operador só pode ser sobrecarregado como função-membro da classe.

O símbolo do operador é , e o parâmetro que vamos receber é o índice a ser acessado. O segundo detalhe é que o tipo da função será !

O tipo é pois o operador vai retornar um elemento do e o tipo dos elementos do são determinados de acordo com o tipo genérico do template. O símbolo está aí, pois queremos retornar uma referência para o valor do , isso torna possível que o valor seja alterado se necessário.

Pronto. O protótipo do template está desenvolvido. O próximo passo é desenvolver o conteúdo dos métodos.

O primeiro método que vamos desenvolver é o construtor.

Aqui temos que notar uma pequena diferença. Quando queremos desenvolver um método que foi declarando dentro de um template, nós temos que adicionar o prefixo de template, e antes do operador temos que adicionar os tipos genéricos entre chaves.

Ou seja, um método de template tem que ser escrito que nem um template de função, mas adicionando o nome da classe com o operador , da seguinte forma:

O construtor é um método sem tipo de retorno e com o mesmo nome da classe, então fica assim:

Dentro do construtor, a primeira coisa a ser feita é inicializar o parâmetro

Em seguida, alocamos no ponteiro um array dinâmico com a dimensão :

Prontinho! O array dinâmico foi criado com sucesso. Agora, vamos usar um loop para pedir pro usuário preencher cada uma das posições do array:

Agora vamos desenvolver o destruidor. Novamente precisamos lembrar que um método de template tem que ser escrito que nem uma função template, mas adicionando o nome da classe e o operador , da seguinte forma:

Dentro do destruidor temos que liberar a memória que foi alocada dinamicamente. Para isso vamos usar o operador para apagar o conteúdo do endereço de memória apontado por .

E é só isso. O destruidor está prontinho!

Agora vamos dar uma olhada detalhada na sobrecarga do operador . Novamente, quando escrevemos um um método de template precisamos adicionar os prefixos de template:

No caso da sobrecarga do operador o tipo de retorno é .

A principal função desse operador é mostrar o conteúdo existente um uma posição do array. Dentro do colchete a gente escreve um índice, e o operador sobrecarregado retorna a posição correspondente do array.

E é só isso! Usando o no retorno da sobrecarga a gente possibilita mais usos do operador .

Com isso a classe está concluída, e só falta a gente testar.

Agora só falta a gente testar pra garantir que tudo funciona!

Vamos criar um objeto do tipo e vamos inicia-lo com tamanho . Assim que o objeto for criado o construtor vai entrar em ação, e vai pedir que a gente preencha o vetor. Para fins de testes, vou imprimir o conteúdo da posição .

Em seguida vamos criar um outro objeto da classe , mas dessa vez usando o tipo . E vamos imprimir a primeira posição desse objeto.

E pronto, vamos rodar o programa:

E o programa rodou tranquilamente. Como estamos usando templates, foi super tranquilo alterar o tipo de dados usado no Vetor!

E veja só a última mensagem: é o destruidor entrando em ação e limpando a memória.

E por hoje é isso! Até a próxima!