1 // function 3
2 template <typename...Types>
3 void printX (const Types&... args)
4 { /*...*/ }

 1 vector<string> v;
 2 
 3 // ...
 4 
 5 auto pos = v:begin(); // pos has type vector<string>::iterator
 6 
 7 auto l = [](int x)->bool { // l has the type of a lambda
 8 
 9 // ... // taking on int and returning a bool
10 
11 }

int values[] {1, 2, 3};

vector<int> v {2, 3, 5, 7, 11, 13, 17};

vector<string> cities {

"Berlin", "New York", "London", "Braunschweig", "Cairo", "Cologne"

};

complex<double> c {4.0, 3.0} // equivalent to c(4.0,3.0)

int x1(5.3);     // ok, but x1 becomes 5
int x2 = 5.3     // ok, but x2 becomes 5
int x3{5.3};     // error, narrowing
int x4 = {5.3}   // error, narrowing
char c1{7};      // ok, even though 7 is an int, this is not narrowing
char c2{9999};   // error, narrowing (if 9999 doesn't fit into a char)
std::vector<int> v1 {1, 2, 4, 5}      // ok
std::vector<int> v2 {1, 2.3, 4, 5.6}  // error, narrowing

void print (std::initializer_list<int> vals) 
{
    for (auto p = vals.begin(); p != vals.end(); ++p)
    {
        std::cout << *p << std::endl;
    }
}
print({2,3,5,7,11,13,17});  // pass a list of values to print()

// 以int试验
int a = 9;
int b = 4;
a = b;   // ok
b = a;   // ok
a = a+b; // ok
a + b = 42; // Error: lvalue required as left operand of assignment

// 以string试验
string s1("Hello");
string s2("World");
s1 + s2 = s2;                  // ok, s1+s2可以当做lvalue
cout << "s1: " << s1 << endl;  // s1: Hello
cout << "s2: " << s2 << endl;  // s2: World
string() = "World";            // ok, 竟然可以对临时对象赋值

// 以complex试验
complex<int> c1(3,8), c2(1,0);
c1 + c2 = complex<int>(4,9);         // ok, c1+c2可以当做lvalue
cout << "c1: " << c1 << endl;        // c1:(3,8)
cout << "c2: " << c2 << endl;        // c2:(1,0)
complex<int>() = complex<int>(4,9);  // 竟然可以对临时对象赋值

// ...\4.9.2\include\c++\bits\move.h

//  @brief  Forward an lvalue.
//  @return The parameter cast to the specified type.
//  This function is used to implement "perfect forwarding".
template<typename _Tp>
    constexpr _Tp&&
    forward(typename std::remove_reference<_Tp>::type& __t) noexcept
    { return static_cast<_Tp&&>(__t); }

//  @brief  Forward an rvalue.
//  @return The parameter cast to the specified type.
//  This function is used to implement "perfect forwarding".
template<typename _Tp>
    constexpr _Tp&&
    forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
    {
        static_assert(!std::is_lvalue_reference<_Tp>::value, "template argument"
        " substituting _Tp is an lvalue reference type");
        return static_cast<_Tp&&>(__t);
    }

//  @brief  Convert a value to an rvalue.
//  @param  __t  A thing of arbitrary type.
//  @return The parameter cast to an rvalue-reference to allow moving it.
template<typename _Tp>
    constexpr typename std::remove_reference<_Tp>::type&&
    move(_Tp&& __t) noexcept
    { return static_cast<typename std::remove_reference<_Tp>::type&&>(__t); }

 1 class MyString 
 2 { 
 3 private: 
 4     char* _data; 
 5     size_t _len; 
 6     void _init_data(const char *s) 
 7     { 
 8             _data = new char[_len+1]; 
 9             memcpy(_data, s, _len); 
10             _data[_len] = '\0'; 
11     } 
12 public: 
13     // default ctor
14     MyString() : _data(NULL), _len(0) {  }
15     // ctor
16     MyString(const char* p) : _len(strlen(p)) 
17     { 
18         _init_data(p); 
19     } 
20     // copy ctor
21     MyString(const MyString& str) : _len(str._len) 
22     { 
23         cout << "Copy Constructor is called! source: " << str._data 
24              << " [" << (void*)(str._data) << ']' << endl;       
25         _init_data(str._data);     // COPY
26     } 
27     // move ctor, with "noexcept"
28     MyString(MyString&& str) noexcept : _data(str._data), _len(str._len) {  
29         cout << "Move Constructor is called! source: " << str._data 
30              << " [" << (void*)(str._data) << ']' << endl; 
31         str._len = 0;         
32         str._data = NULL;   // 这句很重要!!!
33                             // 另外需要避免 delete (in dtor)，不然会把临时对象杀掉  
34     }
35  
36     // copy assignment
37     MyString& operator=(const MyString& str) 
38     { 
39         cout << "Copy Assignment is called! source: " << str._data 
40              << " [" << (void*)(str._data) << ']' << endl; 
41         if (this != &str) { 
42             if (_data) delete _data;  
43             _len = str._len; 
44             _init_data(str._data);     // COPY! 
45         } 
46         else {
47             cout << "Self Assignment, Nothing to do." << endl;   
48         }
49         return *this; 
50     } 
51     // move assignment
52     MyString& operator=(MyString&& str) noexcept 
53     { 
54         // 注意 noexcept 
55         cout << "Move Assignment is called! source: " << str._data 
56              << " [" << (void*)(str._data) << ']' << endl; 
57         if (this != &str) 
58         { 
59             if (_data) delete _data; 
60             _len = str._len; 
61             _data = str._data;    // MOVE!
62             str._len = 0; 
63             str._data = NULL;     // 这句很重要!!!
64                                 // 另外需要避免 delete (in dtor)，不然会把临时对象杀掉 
65         } 
66         return *this; 
67     }
68  
69     // dtor
70     virtual ~MyString() 
71     { 
72         cout << "Destructor is called! " << "source: "; 
73         if (_data)
74             cout << _data; 
75         cout << " [" << (void*)(_data) << ']' << endl;
76         
77         if (_data) 
78         {
79             delete _data;     
80         }
81     }       
82 };