std::vector<std::vector<value_type> > val(i, std::vector<value_type>(DIM, 0));

#define value_type nVector<vector_length, double>

class A {
    public:
        ...
    private:
        A(const A&);
        A& operator=(const A&);
};

class A {
    public:
        ...
        A(const A&) = delete;
        A& operator=(const A&) = delete;
};

struct A {
    void * operator new(std::size_t) = delete;
    void * operator new[](std::size_t) = delete;
};

struct A {
    ~A() = delete;
};

auto * pA = new A();

struct A {
    A(long long);
    A(long) = delete;
};

void B(long long);
void B(long) = delete;

struct A {};
struct B : A {};

void f(A&) {}
template <class T> void f(T&) = delete;

int main()
{
    A a;
    B b;
    f(a);    // OK!
    f(b);    // error: deleted function 'void f(T&) [with T = B]'
}

#include <thread>
#include <iostream>

class SayHello
{
public:
    void operator()() const
    {
        std::cout<<"hello"<<std::endl;
    }
};

int main()
{
    std::thread t((SayHello()));
    t.join();
}

int main()
{
    SayHello hello;
    std::thread t(hello);
    t.join();
}

int main()
{
    std::thread t=std::thread(SayHello());
    t.join();
}

int main()
{
    std::thread t{SayHello()};
    t.join();
}

#include <thread>
#include <iostream>
#include <string>

class Greeting
{
    std::string message;
public:
    explicit Greeting(std::string const& message_):
        message(message_)
    {}
    void operator()() const
    {
        std::cout<<message<<std::endl;
    }
};

int main()
{
    std::thread t(Greeting("goodbye"));
    t.join();
}

#include <thread>
#include <iostream>
#include <string>
#include <functional>

void greeting(std::string const& message)
{
    std::cout<<message<<std::endl;
}

int main()
{
    std::thread t(std::bind(greeting,"hi!"));
    t.join();
}

#include <thread>
#include <iostream>
#include <string>

void greeting(std::string const& message)
{
    std::cout<<message<<std::endl;
}

int main()
{
    std::thread t(greeting,"hi!");
    t.join();
}

#include <thread>
#include <iostream>

void write_sum(int x,int y)
{
    std::cout<<x<<" + "<<y<<" = "<<(x+y)<<std::endl;
}

int main()
{
    std::thread t(write_sum,123,456);
    t.join();
}

#include <thread>

void my_thread_func()
{}

int main()
{
    std::thread t(my_thread_func);
}

#include <thread>
#include <iostream>

void my_thread_func()
{
    std::cout<<"hello"<<std::endl;
}

int main()
{
    std::thread t(my_thread_func);
}

int main()
{
    std::thread t(my_thread_func);
    t.join();
}

#define MAX(a, b, result) ((result) = (a) > (b) ? (a) : (b))

#define MAX(a, b, result) {
    typeof(a) c = (a); typeof(b) d = (b);
    (result) = (c > d ? c : d);
}

struct T { int a; };
T t1;
T &t2 = t1;
const T &t3 = t1;

decltype(t3) t4 = t2;             // t4 具有类型 const T &
decltype(t1->a) a1 = t1->a;       // a1 具有类型 int
decltype(t2->a) a2 = t1->a;       // a2 具有类型 int &
decltype(t3->a) a3 = t1->a;       // a3 具有类型 const int &

template <class T1, class T2, class T3>
auto area(const T1 &a, const T2 &b, const T3 &c)
    -> decltype(sqrt(a + b + c))
{
    typedef decltype(sqrt(a + b + c)) T;
    T s = (a + b + c) / 2;
    return sqrt(s * (s - a) * (s - b) * (s - c));
}

auto f() -> int;

template <class T1, class T2, class T3>
decltype(sqrt((*(T1*)0) + (*(T2*)0) + (*(T3*)0)))
area(const T1 &a, const T2 &b, const T3 &c);

vector<double> v = { 1, 2, 3.456, 99.99 };
list<pair<string,string>> languages = {
    {"Nygaard","Simula"}, {"Richards","BCPL"}, {"Ritchie","C"}
}; 
map<vector<string>,vector<int>> years = {
    { {"Maurice","Vincent", "Wilkes"},{1913, 1945, 1951, 1967, 2000} },
    { {"Martin", "Ritchards"}, {1982, 2003, 2007} }, 
    { {"David", "John", "Wheeler"}, {1927, 1947, 1951, 2004} }
};

vector<double> v{ 1, 2, 3.456, 99.99 };

void f(initializer_list<int> args)
{
    for (auto p=args.begin(); p!=args.end(); ++p) cout << *p << "\n";
}

f({1,2,5,8});

void g(const vector<int> &v);

g({1,5,8,10});

for (const auto x : { 1,2,3,5,8,13,21,34 }) cout << x << '\n';

template <class T, class A1, class A2>
void f(T *g, A1 &a1, A2 &a2)
{
    return (*g)(a1, a2);
}

void g(T1 a1, T2 a2);

f(&g, a1, a2);

void g(const int &a1, int &a2);

int a;
g(1, a);        // 正确！
f(&g, 1, a);    // 编译错误！

template <class T, class A1, class A2> void f(T *g, A1 &a1, A2 &a2) { return (*g)(a1, a2); }
template <class T, class A1, class A2> void f(T *g, const A1 &a1, A2 &a2) { return (*g)(a1, a2); }
template <class T, class A1, class A2> void f(T *g, A1 &a1, const A2 &a2) { return (*g)(a1, a2); }
template <class T, class A1, class A2> void f(T *g, const A1 &a1, const A2 &a2) { return (*g)(a1, a2); }

template <class T, class A1, class A2>
void f(T *g, A1 &&a1, A2 &&a2)
{
    return (*g)(a1, a2);
}

template <class T, class A1, class A2>
void f(T *g, A1 &&a1, A2 &&a2)
{
    return (*g)(std::forward<A1>(a1), std::forward<A2>(a2));
}

template <class T>
struct identity
{
    typedef T type;
};

template <class T>
T&& forward(typename identity<T>::type&& a)
{
    return a;
}