input::
{
  attribute_1: value_1
}

when attribute_1 == value_1, produce attribute_2 = value_2

{
  attribute_2: value_2
}

{
  condition: {
    condition: cond,
  },
  value: {
    value: v,
  }
}

{
  conditions: {
    condition_1: cond_1,
    condition_2: cond_2,
    ...
  },
  values: {
    value_1: v_1,
    value_2: v_2,
    ...
  }
}

           root
            |
       condition_1
    /               \
 cond_3 {value_2: v2}   cond_1 {value_1: v_1}
                      \
                      condition_2           
                        \
                        cond_2 {value_1: v_1}

{
  conditions: {
    condition_1: cond_3,
    condition_2: cond_2,
  },
  values: {
    value_1: v_1,
  }
}

{
  conditions: {
    condition_1: cond_1,
  },
  values: {
    value_2: v_2,
  }
}

data ConfigElement = ConfigElement
data Trie = Empty | TrieNode String String ConfigElement [Trie]

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        unordered_map<int, int> cache;
        int result = imp(coins, amount, cache);
        return result == INT_MAX ? -1 : result;
    }

    int imp(vector<int>& coins, int remaining, unordered_map<int, int>& cache) {
        if (remaining == 0) return 0;
        if (remaining < 0) return INT_MAX;
        if (cache.count(remaining)) return cache[remaining];

        int resultMin = INT_MAX;
        for (int i = 0; i < coins.size(); ++i) {
            int curMin = imp(coins, remaining-coins[i], cache);
            if (curMin == INT_MAX) continue;  // handle overflow
            resultMin = min(curMin+1, resultMin);
        }

        cache[remaining] = resultMin;
        return resultMin;
    }
};

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        vector<int> dp(amount+1, amount+1);  // use amount+1 to prevent IN_MAX overflow.
        dp[0] = 0;
        for (int i = 1; i <= amount; ++i) {
            for (int j = 0; j < coins.size(); ++j) {
                if (coins[j] <= i) {
                    dp[i] = min(dp[i], dp[i - coins[j]] + 1);
                }
            }
        }

        return dp[amount] > amount ? -1 : dp[amount];
    }
};

class Solution {
public:
    int leastInterval(vector<char>& tasks, int n) {
        unordered_map<char, int> taskCounts;
        priority_queue<int> taskQ;

          // O(t) count
        for (auto t : tasks) {
            ++taskCounts[t];
        }

          // O(tlogt) insert
        for (auto [t, freq]: taskCounts) {
            taskQ.push(freq);
        }

        int cycle = 0;
        while (!taskQ.empty()) {
            vector<int> remainingTasks;

            int idle = 0;
            int gaps = n;
              // note while (--i) and while (i--) executes different times
              // * while (--i) i-1 times
              // * while (i--) i   times
            while (gaps-- >= 0) {
                if (!taskQ.empty()) {
                    remainingTasks.push_back(taskQ.top());
                    taskQ.pop();
                    ++cycle;
                } else {
                    ++idle;
                }
            }

            for (auto tf : remainingTasks) {
                if (--tf > 0) {
                    taskQ.push(tf);
                }
            }

            if (!taskQ.empty()) {
                // to avoid trailing idle time
                cycle += idle;
            }
        }

        return cycle;
    }
};

class Solution {
public:
    void wiggleSort(vector<int>& nums) {
        vector<int> tmp = nums;
        int n = nums.size(), m = (n+1)/2, k = n;

        sort(tmp.begin(), tmp.end());
        for (int i = 0; i < n; ++i) {
            nums[i] = i & 1 ? tmp[--k] : tmp[--m];
        }
    }
};

class Solution {
public:
    void wiggleSort(vector<int>& nums) {
        if (nums.size() < 2) return;

        int n = nums.size(), m = (n+1)/2;
        vector<int> copy = nums;

        // find median
        nth_element(nums.begin(), nums.begin() + m, nums.end());
        int mid = nums[m];

        threeWay(copy, mid);

        // if odd pick from right partition
        // if even pick from left partition
        for (int i = 0; i < nums.size(); ++i) {
            nums[i] = i & 1 ? copy[--n] : copy[--m];
        }
    }

    // https://en.wikipedia.org/wiki/Dutch_national_flag_problem
    void threeWay(vector<int>& A, int mid) {
        int i = 0, j = 0, k = A.size() - 1;

        while(j <= k) {
            if (A[j] < mid) {
                swap(A[i], A[j]);
                i++; j++;
            } else if (A[j] > mid) {
                swap(A[j], A[k]);
                k--;
            } else {
                j++;
            }
        }
    }
};

class Solution {
public:
    string mergeOrders(
        unordered_map<char, unordered_set<char>>& g,
        unordered_map<char, int>& cnt
    ) {
        queue<char> q;

        for (const auto& [ch, c] : cnt) {
            if (c == 0) {
                q.push(ch);
            }
        }

        string ret = "";
        while(!q.empty()) {
            char c = q.front();
            q.pop();

            ret += c;
            for (const auto& e : g[c]) {
                cnt[e]--;
                if (cnt[e] == 0) q.push(e);
            }
        }

        if (ret.size() != cnt.size()) return "";
        return ret;
    }

    string alienOrder(vector<string>& words) {
        unordered_map<char, unordered_set<char>> g;
        unordered_map<char, int> cnt;

        for (int i = 0; i < words.size(); ++i) {
            for (int j = 0; j < words[i].size(); ++j) {
                cnt[words[i][j]] = 0;
            }
        }

        for (int i = 0; i < words.size()-1; ++i) {
            string& cur = words[i];
            string& next = words[i+1];

            int limit = min(cur.size(), next.size());
            for (int j = 0; j < limit; ++j) {
                if (cur[j] != next[j]) {
                    if (g[cur[j]].find(next[j]) == g[cur[j]].end()) {
                        g[cur[j]].insert(next[j]);
                        cnt[next[j]] += 1;
                    }
                    break;
                }
            }
        }

        return mergeOrders(g, cnt);
    }
};

class Solution {
    struct V {
        int dist, index, k;
    };

public:
    int findCheapestPriceDijk(int n,
                          const vector<vector<int>>& flights,
                          int src, int dst, int K) {
        // build graph
        unordered_map<int, unordered_map<int, int>> g;
        for (const auto& e : flights) {
            g[e[0]][e[1]] = e[2]; // from, to, weight
        }

        // tracker
        vector<int> pathTo(n);

        // Dijkstra
        using T = tuple<int, int, int>;
        priority_queue<T, vector<T>, greater<T>> pq;  // dis, k, cur
        pq.push({0, K, src});

        while (!pq.empty()) {
            auto [dis, k, from] = pq.top();
            pq.pop();

            if (k < -1) continue;
            if (from == dst) return dis;

            for (const auto& [to, price] : g[from]) {
                pq.push({price + dis, k - 1, to});
            }
        }

        return -1;
    }
};

class Solution {
public:
    int findCheapestPrice(int n, vector<vector<int>>& flights, int src, int dst, int K) {
        int cheapest = -1;

        unordered_map<int, unordered_map<int, int>> adj_list;
        vector<int> distTo(n);
        distTo[src] = -1;

        for (const auto& flight : flights) {
            adj_list[flight[0]][flight[1]] = flight[2];
        }

        // {index, price}
        queue<pair<int, int>> q;
        q.push({src, 0});

        while (!q.empty() && K >= -1 ) {
            int size = q.size();
            while (size-- > 0) {    // concise
                auto cur = q.front();
                int index = cur.first, price = cur.second;
                q.pop();

                if (index == dst) {
                    cheapest = -1 == cheapest ? price : min(cheapest, price);
                }
                else
                {
                    for (const auto& e : adj_list[index]) {
                        if (distTo[e.first] == 0 || distTo[e.first] > e.second + price) {
                            q.push({e.first, price + e.second});
                            distTo[e.first] = price + e.second;
                        }
                    }
                }
            }

            K--;
        }

        return cheapest;
    }
};

class Solution {
public:
    int findCheapestPrice(int n,
                          const vector<vector<int>>& flights,
                          int src, int dst, int K) {
        // build graph
        unordered_map<int, unordered_map<int, int>> g;
        for (const auto& e : flights) {
            g[e[0]][e[1]] = e[2]; // from, to, weight
        }

        // SPFA
        // setup
        vector<int> distTo(n, INT_MAX);
        // vector<char> inQueue(n, false);  -> optional optimization
        queue<tuple<int, int, int>> q;   // cur, K, acc

        // init
        q.push({src, K, 0});
        // inQueue[src] = true;

        while (!q.empty()) {
            auto [cur, k, acc] = q.front();
            q.pop();
            // inQueue[src] = false;

            if (k < 0) {  // k stop, k+1 edges
                continue;
            }

            for (const auto& [to, weight] : g[cur]) {
                if (distTo[to] > acc + weight) {
                    distTo[to] = acc + weight;
                    // if (!inQueue[to]) {
                        q.push({to, k - 1, acc + weight});
                    // }
                }
            }
        }

        return distTo[dst] == INT_MAX ? -1 : distTo[dst];
    }
};

struct Interval {
    int length, k, dist;

    Interval(int i) : length(i), k(1), dist(i) {}

    bool operator< (const Interval& other) const {
        return dist < other.dist;
    }

    void addK() {
        k++;
        dist = length/k;
    }
};

priority_queue<Interval> buildQueue(const vector<int>& v) {
    vector<int> ret(v.size());
    adjacent_difference(v.begin(), v.end(), ret.begin());
    ret.erase(ret.begin());
    return priority_queue<Interval>(ret.begin(), ret.end());
}

int minMaxDist(const vector<int>& v, int k) {
    auto pq = buildQueue(v);
    int maxDist = (v.back() - v.front())/(k+1); // just for optimization

    while(k) {
        Interval top = pq.top();
        pq.pop();

        while(pq.top() < top || top.dist > maxDist) {
            top.addK();
            k--;
        }
        pq.push(top);
    }

    return pq.top().dist;
}

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        return find(nums, 0, nums.size()-1, k);
    }

    int partition(vector<int>& nums, int begin, int end, int k)
    {
        if (begin > end) return -1; // should not happend
        int p = nums[(end + begin)/2];
        int i  = begin, j = end;
        while(i != j)
        {
            if (nums[j] > p)
            {
                j--;
            }
            else if (nums[i] < p)
            {
                i++;
            }
            else
            {
                std::swap(nums[i], nums[j]);
                if (nums[j] == p) i++; // edge case where after swap if nums[j] == p then we can't --j
                else j--;
            }
        }
        int diff = end-i+1-k;
        if (diff == 0)
        {
            return nums[i];
        }
        else if (diff > 0)
        {
            return find(nums,i+1,end,k); // i j are the same anyways
        }
        else
        {
            return find(nums,begin,j-1,-diff); // i j are the same anyways
        }
    }
};

class Solution {
public:
    vector<string> generateParenthesis(int n) {
        vector<string> ret;
        generate(ret, "", n, n);
        return ret;
    }

    void generate(
        vector<string>& ret,
        string s,
        int num_of_left,
        int num_of_right)
    {
        if (num_of_left == 0 && num_of_right == 0)
        {
            ret.push_back(s);
            return;
        }

        if (num_of_left > 0)
        {
            generate(ret, s+"(", num_of_left-1, num_of_right);
        }
        if (num_of_right > num_of_left)
        {
            generate(ret, s+")", num_of_left, num_of_right-1);
        }
    }
};

class Solution {
public:
    vector<string> generateParenthesis(int n) {
        vector<vector<string>> tmp = ;
        for (int j = 1; j <= n; ++j)
        {
            vector<string> vec;
            for (int i = 0; i < j; ++i)
            {
                for (auto fst : tmp[i])
                {
                    for (auto snd : tmp[j-i-1])
                    {
                        vec.push_back("("+fst+")"+snd);
                    }
                }
            }
            tmp.push_back(vec);
        }
        return tmp.back();
    }
};

class Solution {
public:
    bool canAttendMeetings(vector<Interval> &intervals) {
        if (intervals.size() <= 1) return true;
        sort(
            intervals.begin(),
            intervals.end(),
            [](const Interval &a, const Interval &b)
            {
                return a.start < b.start;
            });
        for (int i = 1; i < intervals.size(); ++i)
        {
            if (intervals[i].start < intervals[i-1].end) return false;
        }
        return true;
    }
};

class Solution {
public:
    bool START = true;
    bool END = false;

    int minMeetingRooms(vector<Interval> &intervals) {
        vector<pair<int, bool>> vec;
        for (const auto& itv : intervals)
        {
            vec.push_back(make_pair(itv.start, START));
            vec.push_back(make_pair(itv.end, END));
        }

        std::sort(vec.begin(), vec.end(),
        [](const auto& l, const auto& r) {
            return l.first < r.first;
        });

        int rooms = 0, current = 0;
        for (const auto& it : vec)
        {
            if (it.second)
            {
                current++;
            }
            else
            {
                current--;
            }
            rooms = std::max(rooms, current);
        }

        return rooms;
    }
};

class Solution {
public:
    int minMeetingRooms(vector<Interval>& intervals) {
        map<int, int> m;
        for (auto a : intervals) {
            ++m[a.start];
            --m[a.end];
        }
        int rooms = 0, res = 0;
        for (auto it : m) {
            res = max(res, rooms += it.second);
        }
        return res;
    }
};

class Solution {
public:
    int minMeetingRooms(vector<Interval>& intervals) {
        sort(intervals.begin(), intervals.end(), [](const Interval &a, const Interval &b){return a.start < b.start;});
        priority_queue<int, vector<int>, greater<int>> q;
        for (auto a : intervals) {
            if (!q.empty() && q.top() <= a.start) q.pop();
            q.push(a.end);
        }
        return q.size();
    }
};

class Solution {
public:
    int evaluate(string expression) {
        scopes_.clear();
        int pos = 0;
        return eval(expression, pos);
    }
private:
    int eval(const string& s, int& pos) {
        scopes_.push_front(unordered_map<string, int>());
        int value = 0; // The return value of current expr
        if (s[pos] == '(') ++pos;

        // command, variable or number
        const string token = getToken(s, pos);

        if (token == "add") {
            int v1 = eval(s, ++pos);
            int v2 = eval(s, ++pos);
            value = v1 + v2;
        } else if (token == "mult") {
            int v1 = eval(s, ++pos);
            int v2 = eval(s, ++pos);
            value = v1 * v2;
        } else if (token == "let") {
            string var;
            // expecting " var1 exp1 var2 exp2 ... last_expr)"
            while (s[pos] != ')') {
                ++pos;
                // Must be last_expr
                if (s[pos] == '(') {
                    value = eval(s, ++pos);
                    break;
                }
                // Get a token, could be "x" or "-12" for last_expr
                var = getToken(s, pos);
                // End of let, var is last_expr
                if (s[pos] == ')') {
                    if (isalpha(var[0]))
                        value = getValue(var);
                    else
                        value = stoi(var);
                    break;
                }
                // x -12 -> set x to -12 and store in the current scope and take it as the current return value
                value = scopes_.front()[var] = eval(s, ++pos);
            }
        } else if (isalpha(token[0])) {
            value = getValue(token); // symbol
        } else {
            value = std::stoi(token); // number
        }
        if (s[pos] == ')') ++pos;
        scopes_.pop_front();
        return value;
    }

    int getValue(const string& symbol) {
        for (const auto& scope : scopes_)
            if (scope.count(symbol)) return scope.at(symbol);
        return 0;
    }

    // Get a token from current pos.
    // "let x" -> "let"
    // "-12 (add x y)" -> "-12"
    string getToken(const string& s, int& pos) {
        string token;
        while (pos < s.length()) {
            if (s[pos] == ')' || s[pos] == ' ') break;
            token += s[pos++];
        }
        return token;
    }

    deque<unordered_map<string, int>> scopes_;
};

bool isMatch(string s, string regex);

bool isMatch(string s, string regex) {
  if (s.empty() && regex.empty()) return false;
  int r_i = 0;
  for (int i = 0; i < s.size(); ++i) {
    if (s[i] == regex[r_i]) {
      return isMatch(s.substr(i), regex.substr(r_i));
    }
    if (regex[r_i] == '*') { // should be regex[r_i+1] == '*'
      return isMatch(s.substr(i+1), regex.substr(r_i-1))
        || isMatch(s.substr(i), regex.substr(r_i+1));
    }
    if (regex[r_i] == '.') {
      return isMatch(s.substr(i+1), regex.substr(r_i+1));
    }
    return false;
  }
  return false;
}

bool isMatch(string s, string p) {
  return imp(s.data(), p.data());
}

bool imp(const char* c, const char* p) {
    if (*c == '\0' && *p == '\0') {
        return true;
    }
    if (*p == '\0' || *c == '\0') return false; // ??? patching
    if (*(p+1) == '*') {
        return isMatch(c+1, p) || isMatch(c+1, p+2); // should be || isMatch(c, p+2)
    }
    if (*c == *p || *p == '.') {  // '\0' and '.'
        return isMatch(c+1, p+1);
    }
    return false;
}

bool isMatch(string s, string p) {
  return imp(s.data(), p.data());
}

bool imp(const char* c, const char* p) {
      // only when regex reaches the end, *c check make sense
    if (*p == '\0') return *c == '\0';
    if (*(p+1) == '*') {
        return
          imp(c, p+2)
          // test if c is end of string then we can safely
          // recursively call imp(c+1, p)
          || ((*p == *c || (*c != '\0' && *p == '.'))
                && imp(c+1, p));
    }
    if (*c == *p || (*c != '\0' && *p == '.')) {
        return imp(c+1, p+1);
    }
    return false;
}

// Copy from Leetcode
bool isMatch(string s, string p) {
    /**
     * f[i][j]: if s[0..i-1] matches p[0..j-1]
     * if p[j - 1] != '*'
     *      f[i][j] = f[i - 1][j - 1] && s[i - 1] == p[j - 1]
     * if p[j - 1] == '*', denote p[j - 2] with x
     *      f[i][j] is true iff any of the following is true
     *      1) "x*" repeats 0 time and matches empty: f[i][j - 2]
     *      2) "x*" repeats >= 1 times and matches "x*x": s[i - 1] == x && f[i - 1][j]
     * '.' matches any single character
     */
    int m = s.size(), n = p.size();
    vector<vector<bool>> f(m + 1, vector<bool>(n + 1, false));

    f[0][0] = true;
    for (int i = 1; i <= m; i++)
        f[i][0] = false;
    // p[0.., j - 3, j - 2, j - 1] matches empty iff p[j - 1] is '*' 
      // and p[0..j - 3] matches empty
    for (int j = 1; j <= n; j++)
        f[0][j] = j > 1 && '*' == p[j - 1] && f[0][j - 2];

    for (int i = 1; i <= m; i++)
        for (int j = 1; j <= n; j++)
            if (p[j - 1] != '*') {
                f[i][j] = f[i - 1][j - 1] && (s[i - 1] == p[j - 1]
                                              || '.' == p[j - 1]);
            }
            else
                // p[0] cannot be '*' so no need to check "j > 1" here
                f[i][j] = f[i][j - 2] || (s[i - 1] == p[j - 2]
                                          || '.' == p[j - 2]) && f[i - 1][j];

    return f[m][n];
}

int* a = new int(5);
std::shared_ptr<int> sp(a);
// int* b = a;
// std::shared_ptr sb(b); undefined behavior
auto sb = sp; // refcount+1

struct A {
  std::shared_ptr<A> ptr;
};

void main() {
  std::shared_ptr<A> x=std::make_shared<A>();
  std::shared_ptr<A> y=std::make_shared<A>();

  x->ptr = y; // not quite a cycle yet
  y->ptr = x; // now we got a cycle x keeps y alive and y keeps x alive
}

#include <memory>

 int main()
 {
   int array[3];
   std::shared_ptr<int[3]> p(&array, [](int*p ){delete p;});
 }

template <typename _Tp>
  struct __libfund_v1 { using type = _Tp; };

class Base { };
class Derived : public Base { };

int main() {
  Base* b = new Derived(); // ok
  Base b_array[2];
  b_array = new Derived[2]; // if Base and Derived are of difference
                              // b_array[1] may cause trouble. "pointer arithmatic"
}

// helper for _Compatible
template<typename _From_type, typename _To_type>
  struct __sp_compatible_helper
  { static constexpr bool value
    = is_convertible<_From_type*, _To_type*>::value; };

template<size_t _Nm, typename _Tp>
  struct __sp_compatible_helper<_Tp[_Nm], _Tp[]>
  { static constexpr bool value = true; };

std::vector<A, alloc1> vec1;
std::vector<A, alloc2> vec2;
// oops, vec1 and vec2 now have different types now, which should not happen.

template <class _Tp>
  class polymorphic_allocator { }

template <typename _Alloc>
  class __resource_adaptor_imp : public memory_resource { }

template <typename _Alloc>
  using resource_adaptor = __resource_adaptor_imp<
    typename allocator_traits<_Alloc>::template rebind_alloc<char>>;

inline std::atomic<memory_resource*>&
__get_default_resource()
{
  static std::atomic<memory_resource*>
    _S_default_resource(new_delete_resource());
  return _S_default_resource;
}

static int a; -> static int a; //multiple copies
struct A { static int a; } int A::a = 3; -> struct A {}; int A_a = 3;

static size_t _S_aligned_size(size_t __size, size_t __alignment)
{ return ((__size - 1)|(__alignment - 1)) + 1; }

char a[10];
void* ap = (void*)a;
int b;
void* bp = (void*)&b;

class Any {
public:
  Any() : ptr(nullptr) {}

  Any(const Any& other) {
      ptr = other.ptr->Copy();
  }

  Any& operator=(const Any& other) {
      this->~Any();
      ptr = other.ptr->Copy();
      return *this;
  }

  ~Any() {
      if (ptr != nullptr) {
    delete ptr;
      }
  }

  template<typename T>
    void Assign(const T& data) {
  this->~Any();
  ptr = new Wrapper<T>(data);
    }

  template<typename T>
    T* Get() {
  auto wrapper = dynamic_cast<Wrapper<T>*>(ptr);
  if (wrapper != nullptr) {
      return &wrapper->data;
  }
  return nullptr;
    }

private:
  struct AnyData {
      virtual ~AnyData() { }

      virtual AnyData* Copy() = 0;
  };

  template<typename T>
    struct Wrapper : public AnyData {
  Wrapper(const T& data) : data(data) {}

  AnyData* Copy() override {
      return new Wrapper<T>(data);
  }

  T data;
    };

  AnyData* ptr;
};

#include <iostream>

int main() {
    Any a;
    a.Assign<int>(3);
    std::cout << (a.Get<char>() == nullptr) << "\n";
    std::cout << (*a.Get<int>() == 3) << "\n";

    Any b;
    b = a;
    std::cout << (*b.Get<int>() == 3) << "\n";

    return 0;
}

#include <stdio.h>

typedef void (*GenericFuncPtr)(void);
//use general ptr array store vf pointer

struct Cat {
    GenericFuncPtr* vtable_ptr;
};

void cat_speak(struct Cat* this) {
    printf("miao");
}

void cat_die(struct Cat* this) {
    printf("ewww");
}

GenericFuncPtr cat_vtable[] = {
    // do in the compile time
    (GenericFuncPtr)cat_speak,
    (GenericFuncPtr)cat_die,
};

void construct_cat(struct Cat* c) {
    c->vtable_ptr = cat_vtable;
}

struct Lion {
    struct Cat base;
};

void lion_speak(struct Lion* this) {
    printf("ow");
}

void lion_die(struct Lion* this) {
    printf("ahhh");
}

GenericFuncPtr lion_vtable[] = {
    (GenericFuncPtr)lion_speak,
    (GenericFuncPtr)lion_die,
};

void construct_lion(struct Lion* l) {
    construct_cat(&l->base);
    l->base.vtable_ptr = lion_vtable;
}

int main () {
    struct Lion l;
    struct Cat* c;
    construct_lion(&l);
    c = &l.base;
    // c->speak
    ((void (*)(struct Lion*))c->vtable_ptr[0])((struct Lion*)c);
    // c->die
    ((void (*)(struct Lion*))c->vtable_ptr[1])((struct Lion*)c);
    return 0;
}

template <typename _Tp> // primary
class A {
};

template <typename _Tp>
class A<_Tp[]> {
};

template <typename _Tp>
class A<_Tp*> {
};

//template <typename _Tp> //error
//class A<_Tp> {
//};

template<typename T>
struct A {
    void Foo(T&& /*rvalue ref*/);
};
struct A {
    template<typename T>
      void Foo(T&& /*forwarding ref, or `universal ref`*/);
};
//上面的例子虽然T是模板参数，但不是等着被推出来的。

#include <iostream>
template <typename T>
class A {
public:
  A() { std::cout << "without size" << "\n"; }
  A(size_t size) { std::cout << "with size" << "\n"; }
  A(size_t size, size_t idx) { std::cout << "with size, idx" << "\n"; }
  ~A() { std::cout << "dtor" << "\n"; }
};

template <typename _Tp, typename... Args>
class B : A<_Tp> {
public:
  //B() { std::cout << "B ctor" << "\n"; } B<int>b1 wont work;
  B(Args&&... _args) : A<_Tp>(_args...) { }
private:
  //A<_Tp> _a;
};

class Tmp {
public:
  Tmp() { std::cout << "Tmp ctor" << "\n"; }
};

int main () {
    //B<int> b1;
    B<int,size_t> b2(1);
    //B<int,size_t> b(1,2); //error
    B<int,size_t,size_t> b3(1,2);

    Tmp tmp;
    Tmp tmp1(); // function !!!!!!!!!!!!
}

A* p = new B();
delete p;

一个类有10个virtual function你初始化一个子类对象这个子类对象一般多大？
假设基类size为A，子类size为B假设基类所有成员size和为A，
子类自己所有成员size和为B创建一个子类对象，占多大空间？

答案:A+B+sizeof(pointer_type), 另外alignment可能让他更大)

int GiveVal(int a) {
  int x = a;
  return x;
}

FWidget* CreateWidget(int x, int y, int z)
{
  FWidget* NewWidgetPointer = new FWidget(x,y,z);
  return NewWidgetPointer;
}

FWidget& CreateWidget(int x, int y, int z)
{
  FWidget NewWidget(x,y,z); // 栈分配
  return NewWidget;
}

FWidget* CreateWidget(int x, int y, int z)
{
  FWidget  NewWidget(x,y,z);
  return &NewWidget;
}