template<class T, class U> auto add(T t, U u) -> decltype(t + u)
{
    return t + u;
}

using uint8=unsigned char; 		
//等价于typedef unsigned char uint8;
using FunctionPtr = void (*)(); 	
//等价于typedef void (*FunctionPtr)();
template<typename T> using MapString = std::map<T, char*>;	
//定义模板别名，注意typedef无法定义模板别名，因为typedef只能作用于具体类型而非模板

//引入名字空间
using namespace std;
//引入类型
using std::iostream;
//引入函数
using std::to_string;
//引入对象
using std::cout;
//在子类中解除父类同名函数的隐藏
class Base
{
public:
	void func()
	{ 
		cout << "in Base::func()" << endl;
	}
	void func(int n)
	{ 
		cout << "in Base::func(int)" << endl;
	}
};

class Sub : public Base
{
public:
	using Base::func;	//引入父类所有同名函数func，解除函数隐藏
	void func()
	{
		cout<<"in Sub::func()"<<endl;
	}
};

int main()
{
	Sub s;
	s.func();
	s.func(1); // Success!
}

const A* a = new A{0};

//第一种情况：
//如果 e 是一个变量或者类成员访问表达式，假设e的类型是T，那么的decltype(e)为T，decltype((e))为T&
decltype(a->x) y;       // type of y is double
decltype((a->x)) z = y; // type of z is const double&,因为a一个常量对象指针

//第二种情况
//如果e是一个解引用操作，那么decltype(e)和decltype((e))均为T&
int* aa=new int;
decltype(*aa) y=*aa;    //type of y is int&，解引用操作

//第三种情况
//decltype(e)与decltype((e))均为T。struct A { double x; };
decltype(5) y;          //type of y is int
decltype((5)) y;        //type of y is int
const int&& RvalRef() { return 1; }
decltype ((RvalRef())) var = 1;  //type of var is const int&&

const int i=3;    //i是一个常变量
const int j=i+1;  //j是一个常变量，i+1是一个常量表达式
int k=23;         //k的值可以改变，从而不是一个常变量
const int m=f();  //m不是常变量，m的值只有在运行时才会获取

voidFunc0() throw(runtime_error);
//可能抛出runtime_error类型的异常
voidFunc1() throw();
//不会抛出任何异常
voidFunc2();
//没有异常说明，可以抛出任何类型的异常

void Func() noexcept;
//此时同上述的throw()，表示函数不会抛出异常，也就是说如果发生了，编译器会直接调用std::terminate()终止程序运行。
//同时就效率讨论，noexcept会较throw高一些

void Func() noexcept(常量表达式);
//如果常量表达式的结果为true，表示该函数不会抛出异常；反之抛出。 不规定表达式则默认为true;

//第二个 noexcept 是一个操作符，如果其参数是一个有可能抛出异常的表达式，
//noexcept(T()) 则返回值为false，那么 func5 有可能会抛出异常 
//否则,noexcept(T()) 返回true，func5 不会抛出异常。这样函数模板是否会抛出异常，可以由表达式进行推导

template <typename T>
void fun() noexcept(noexcept(T())) { throw 1; }

class Base
{
public:
    virtual void f() {}
};
class Test :public Base
{
public:
    ~Test() noexcept(true) {}
};
class TestFalse :public Base
{
public:
    ~TestFalse() noexcept(false) {}
};

int main(int argc, char **argv)
{
    std::cout << noexcept(TestFalse()) << std::endl;        // false
    std::cout << noexcept(Test()) << std::endl;             // true

    try
    {
        fun<TestFalse>();
    }
    catch (...)
    {
        std::cout << "throw" << std::endl;                   // throw
    }

    try
    {
        fun<Test>();                                         // terminate
    }
    catch (...)
    {
        std::cout << "throw" << std::endl;
    }
    return 0;
}

template<typename... Args> void g(Args... args)
{
	cout<<sizeof...(Args)<<endl;  //类型参数的数目
	cout<<sizeof...(args)<<endl;  //函数参数的数目
}

class DataOnly
{
public:
	DataOnly()=default;               //default constructor
	~DataOnly()=default;              //destructor

	DataOnly(const DataOnly& rhs)=default;    			//copy constructor
    DataOnly& operator=(const DataOnly & rhs)=default;  //copy assignment operator

    DataOnly(const DataOnly && rhs)=default;  		//C++11,move constructor
    DataOnly& operator=(DataOnly && rhs)=default;  	//C++11,move assignment operator
};

//禁止生成默认版本
class DataOnly
{
public:
	DataOnly()=delete;               //default constructor
	~DataOnly()=delete;            	//destructor

	DataOnly(const DataOnly& rhs)=delete;    //copy constructor
	DataOnly& operator=(const DataOnly & rhs)=delete;  //copy assignment operator

	DataOnly(const DataOnly && rhs)=delete;  		//C++11,move constructor
	DataOnly& operator=(DataOnly && rhs)=delete;  	//C++11,move assignment operator
};

//过滤函数的形参类型
bool isLucky(int number);        // original function
bool isLucky(char) = delete;     // reject chars
bool isLucky(bool) = delete;     // reject bools
bool isLucky(double) = delete;   // reject doubles and floats

//在模板特例化中，也可以用 delete 来过滤一些特定的形参类型
class Widget
{
public:
	template<typename T> void processPointer(T* ptr){}
};
template<> void Widget::processPointer<void>(void*)=delete;	//deleted function template

static_assert(断言表达式，提示字符串);

template <typename T1, typename T2> auto add(T1 t1, T2 t2)
{
	return t1 + t2;
}