#include <string>
#include <vector>
#include <deque>
#include <list>
#include <forward_list>
#include <array>

#include <iostream>

using namespace std;

//-----------------------------------------------
// A range for simplifies the code
//-----------------------------------------------

template <class T>
void dumpContainer(const T c) {
  for (auto el : c) {
    cout << el << ' ';
  }
  cout << endl;
}

//-----------------------------------------------
// A function templated with a constant
//-----------------------------------------------

template <class T, int N>
void dumpNativeArray(const T c[]) {
  for (int i=0; i<N; i++) {
    cout << c[i] << ' ';
  }
  cout << endl;
}

//-------------------------------------------------------

int main(int argc, char *argv[]) {
  string str = "one two three";
  vector<string> stringVec = {"one", "two", "three"};
  deque<int> intDeque = {1, 2, 3};
  list<float> floatList = {1.0, 2.0, 3.0};
  forward_list<double> doubleForwardList = {1.0, 2.0, 3.0};

  dumpContainer(str);
  dumpContainer(stringVec);
  dumpContainer(intDeque);
  dumpContainer(floatList);
  dumpContainer(doubleForwardList);

  //----------------------------------------------------------------
  // The array<T,N> class solves the looping in a subroutine issue
  //----------------------------------------------------------------
  array<int,3> arrayArray = {1, 2, 3};

  // The templated procedure will know the inferred type,
  // array<int,3>, and so will know the length of the array
  dumpContainer(arrayArray);

  //----------------------------------------------------------------
  // A related templating trick...
  //----------------------------------------------------------------
  int nativeArray[3] = {1,2,3};
  dumpNativeArray<int,3>(nativeArray);

  return 0;
}