programmering/multi_malloc.cpp at main · dinodork/programmering · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
#include <iostream>
#include <malloc.h>
#include <stdio.h>
#include <string.h>
#include <tuple>
#include <vector>

using std::cout;
using std::endl;

struct Apa {
  int m_a, m_b;
  Apa(int a, int b) : m_a(a), m_b(b) {}
};

template <typename... CtorArgs> Apa *makeAnApa(CtorArgs... ctorArgs) {
  return new Apa(ctorArgs...);
}

template <typename T, typename... CtorArgs> Apa *makeAn(CtorArgs... ctorArgs) {
  return new T(ctorArgs...);
}

template <typename... Ts> class Type_holder {};

template <typename T, typename... CtorArgs>
std::tuple<T *> makeSome(CtorArgs... ctorArgs) {
  return std::tuple<T *>(new T(ctorArgs...));
}

template <typename T, typename... Ts, typename... CtorArgs>
std::tuple<T *, Ts...> makeSome(CtorArgs... ctorArgs) {
  auto ttt = makeSome<Ts..., CtorArgs...>(ctorArgs...);
  auto newT = new T(ctorArgs...);
  return std::tuple_cat<std::tuple<T *>(newT), ttt>;
}

template <typename T, typename... Ts> struct add_pointers {};

int main() {
  Type_holder<int, char> th;
  Apa *newApa = makeAnApa(1, 2);
  Apa *newApa2 = makeAn<Apa>(1, 2);
  std::tuple<Apa *> newApa3 = makeSome<Apa>(1, 2);
  //  std::tuple<Apa*, Apa> newApa4 = makeSome<Apa, Apa>(1, 2);

  Apa *apa = std::get<0>(newApa3);
  cout << "An apa! " << apa->m_a << ", " << apa->m_b << endl;
}