《现代C++教程》笔记（2）

void foo(char*); 
void foo(int);

#include <iostream> 
#define LEN 10

int len_foo() { 
  int i = 2; 
  return i; 
} 

constexpr int len_foo_constexpr() { 
  return 5; 
}

constexpr int fibonacci(const int n) {
  return n == 1 || n == 2 ? 1 : fibonacci(n-1)+fibonacci(n-2); 
}

int main() { 
  char arr_1[10]; // 合法 
  char arr_2[LEN]; // 合法
  int len = 10; // 
  char arr_3[len]; // 非法
  const int len_2 = len + 1; 
  constexpr int len_2_constexpr = 1 + 2 + 3; 
  // char arr_4[len_2]; // 非法 
  char arr_4[len_2_constexpr]; // 合法
  // char arr_5[len_foo()+5]; // 非法 
  char arr_6[len_foo_constexpr() + 1]; // 合法
  std::cout << fibonacci(10) << std::endl; // 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 
  std::cout << fibonacci(10) << std::endl;
  return 0;
}

if (初始化语句; 条件)
switch (初始化语句; 条件) 

MagicFoo(std::initializer_list<int> list) { 
  for (std::initializer_list<int>::iterator it = list.begin(); 
  it != list.end(); ++it) vec.push_back(*it); 
}

#include <iostream>
#include <tuple>

std::tuple<int, double, std::string> f() { 
  return std::make_tuple(1, 2.3, "456"); 
}

int main() {
  auto [x, y, z] = f(); 
  std::cout << x << ", " << y << ", " << z << std::endl; 
  return 0; 
}

// 由于 cbegin() 将返回 vector<int>::const_iterator 所以 itr 也应该是 vector<int>::const_iterator 类型
for(vector<int>::const_iterator it = vec.cbegin(); itr != vec.cend(); ++it)

#include <iostream>
template<typename T> 
auto print_type_info(const T& t) { 
  if constexpr (std::is_integral<T>::value) { 
    return t + 1; 
  } 
  else { 
    return t + 0.001; 
  } 
}

int print_type_info(const int& t) { 
  return t + 1; 
} 
double print_type_info(const double& t) { 
  return t + 0.001; 
}

template class std::vector<bool>; // 强行实例化 
extern template class std::vector<double>; // 不在该当前编译文件中实例化模板

typedef int (*process)(void *); 
using NewProcess = int(*)(void *); 
template<typename T> 
using TrueDarkMagic = MagicType<std::vector<T>, std::string>;

int main() { 
  TrueDarkMagic<bool> you; 
}

// T 和 U 后面的 = int 就是加的
template<typename T = int, typename U = int> 
auto add(T x, U y) -> decltype(x+y) { 
return x+y; 
}

template<typename... Ts> void magic(Ts... args) { 
  std::cout << sizeof...(args) << std::endl; 
}

#include <iostream> 

template<typename T0> 
void printf1(T0 value) { 
  std::cout << value << std::endl; 
} 

template<typename T, typename... Ts> void printf1(T value, Ts... args) { 
  std::cout << value << std::endl; printf1(args...); 
}

template<typename T0, typename... T> void printf2(T0 t0, T... t) { 
  std::cout << t0 << std::endl; if constexpr (sizeof...(t) > 0) printf2(t...); 
}

template<typename T, typename... Ts> auto printf3(T value, Ts... args) { 
  std::cout << value << std::endl; 
  // 为了避免编译器警告，我们可以将 std::initializer_list 显式的转为 void
  (void) std::initializer_list<T>{([&args] { 
    std::cout << args << std::endl; 
  }(), value)...}; 
}

template<typename ... T> auto sum(T ... t) { 
  return (t + ...); 
}

#include <iostream> class Base { 
  public: int value1; 
  int value2; 

  Base() { 
    value1 = 1; 
  } 

  Base(int value) : Base() { // 委托 Base() 构造函数 
    value2 = value; 
  } 
};

class Subclass : public Base { 
  public: using Base::Base; // 继承构造 
};

struct Base { 
  virtual void foo(); 
}; 

struct SubClass: Base {
  void foo();
};

struct Base { 
  virtual void foo(int); 
}; 

struct SubClass: Base { 
  virtual void foo(int) override; // 合法 
  virtual void foo(float) override; // 非法, 父类没有此虚函数 
};

struct Base { 
  virtual void foo() final; 
}; 

struct SubClass1 final: Base { 
}; // 合法 

struct SubClass2 : SubClass1 { 
}; // 非法, SubClass1 已 final

struct SubClass3: Base { 
  void foo(); // 非法, foo 已 final 
};