#include <iostream>
#include <string>
#include <vector>
#include <list>

// Um função template que pega os dois primeiros valores
// de b e coloca no final de a.
template<typename Container>
void adiciona2(Container &a, Container const &b) {
  a.push_back(b[0]);
  a.push_back(b[1]);
}

// No template acima, os dois containers precisam ser do
// mesmo tipo. Se queremos misturar tipos diferente,
// precisamos declarar cada parâmetro com um tipo distinto.
template<typename Container1, typename Container2>
void adiciona2_bis(Container1 &a, Container2 const &b) {
  a.push_back(b[0]);
  a.push_back(b[1]);
}

// Um template para mostrar todos os valores em um container.
template<typename Container>
void mostra(Container const &v) {
  for (auto x: v) {
    std::cout << x << " ";
  }
  std::cout << std::endl;
}

int main(int, char const *[])
{
  std::vector<int> primeiro{1, 2, 3};
  std::vector<int> segundo{4, 5, 6};

  // Mostra os valores antes.
  mostra(primeiro);
  mostra(segundo);

  // Altera primeiro.
  adiciona2(primeiro, segundo);

  // Mostra os valores depois a alteração.
  mostra(primeiro);
  mostra(segundo);

  // Funciona também para std::string, pois ela
  // tem operador de indexação e push_back.
  std::string s1{"Aqui"};
  std::string s2{"!!"};

  adiciona2(s1, s2);
  std::cout << s1 << ", " << s2 << std::endl;

  // Para misturar tipos, precisamos da segunda versão.
  std::vector<double> v1{1., 10., 100.};
  adiciona2_bis(v1, segundo);

  // A segunda versão também pode ser usada para tipos
  // idênticos, portanto a priomeira é desnecessária.
  adiciona2_bis(primeiro, segundo);

  std::vector<char> vc{'a', 'b', 'c', 'd'};
  std::string facil{"facil"};

  // Os dois containers podem ser de tipos diferentes.
  // Aqui vector e string.
  adiciona2_bis(vc, facil);

  std::list<int> lista1{1, 2, 3};
  std::list<int> lista2{4, 5, 6};

  // A linha seguinte é inválida, pois std::list não
  // tem operador de indexação.
  // adiciona2(lista1, lista2);
  mostra(lista1);
  mostra(lista2);

  return 0;
}