Template

template <typename T>
class Vector {
  T* data;
  int capacity, length;

public:
  Vector(int n = 256) : data(new T[n]), capacity(n), length(0) {  }
  ~Vector() {
    if (data) delete[] data;
  }

  void push_back(T s) {
    if (capacity <= length) {
      T* temp = new T[capacity * 2];
      for (int i = 0; i < length; i++) {
        temp[i] = data[i];
      }
      delete[] data;
      data = temp;
      capacity *= 2;
    }
    data[length++] = s;
  }

  T operator[](int index) { return data[index]; }

  void remove(int index) {
    for (int i = index + 1; i < length; i++) {
      data[i - 1] = data[i];
    }
    length--;
  }

  const int size() { return length; }
}

struct Less {
  bool operator()(int x, int y) { return x < y; }
}

size_t GetStringSize(const char* s) { return strlen(s); }
size_t GetStringSize(const std::string& s) { return s.size(); }

template <typename String, typename...Strings>
size_t GetStringSize(const String& s, Strings... strs) {
  return GetStringSize(s) + GetStringSize(strs...);
}

void AppendToString(std::string* str) { }

template <typename String, typename... Strings>
void AppendToString(std::string* str, const String& s, Strings... strs) {
  str->append(s);
  AppendToString(str, strs...);
}

template <typename String, typename... Strings>
std::string StrCat(const String& s, Strings... strs) {
  // calcuate the length of the concatenated string
  size_t totalSize = GetStringSize(s, strs...);

  // allocate space in advance
  std::string res;
  res.reverse(totalSize);

  res = s; // initial string
  AppendToString(&res, strs...);

  return res;
}