• #include<iostream>
  using namespace std;
  namespace variadic{
  	void print(){
  	}
  	
  	template <typename T, typename... Types>
  	void print(const T& firstArg, const Types&... args){
  		cout << sizeof...(args) << " " << firstArg << endl;
  		print(args...);
  	}
  	template<typename... Values> class tuple;
  	template<> class tuple<> {};
  	template<typename Head, typename... Tail>
  	class tuple<Head, Tail...>: private tuple<Tail...>{
  		typedef tuple<Tail...> inherited;
  		public:
  			tuple() {}
  			tuple(Head v, Tail... vtail): m_head(v), inherited(vtail...) {}
  			
  			Head head() {return m_head;}
  			inherited& tail() { return *this; }
  		protected:
  			Head m_head;
  	};
  	
  	
  }
  using namespace variadic;  // If this line is not added, the compilation will not pass 
  int main(){
  	int a = 1;
  	char c = 'T';
  	int b[10] = {0};
  	string s("abs");
  //	Cout < < B < < endl; / / the address is printed 
  //	s = "dsd"; / / can be compiled
  	print(a, c, b, s); 
  
  //	tuple<int, float, string> t(41, 6.3, "nico");
  //	cout << t.head() << endl;
  //	cout << t.tail().head() << endl;
  	return 0;
  }

• Vector < vector < int > > V; can be written as vector < vector < int > > V; (the space in the middle can not be written)

• C++11 At the beginning, the constant value of null pointer is defined as nullptr

• Auto can automatically deduce the type of variable. When the type is long or complex expression lambda, auto can be used instead.

• vector<int> v {1, 2, 3, 4};

• #include<iostream>
  struct Complex{
  	double _real;
  	double _i;
  //	Explicit / / explicit is added. The constructor must be explicitly called 
  	Complex(double real, double i = 0) : _real(real), _i(i) {}
  	Complex operator + (const Complex &c){
  		return Complex(c._real + _real, c._i + _i);
  	}
  	~Complex() = default;
  };
  int main() {
  	Complex c1(4, 2);
  	Complex c2 = c1 + 5; // The compiler implicitly calls the constructor to construct a Complex(5)
  	return 0;
  }
  

• vector<int> v {1,2, 3,4};

• for (auto a : v)
  • cout << a << endl;

• In the standard library, default is a function for big five.

#include<iostream>
using namespace std;
class Zoo{
	private:
		int d1, d2;
	public:
		Zoo(int i1, int i2):d1(i1), d2(i2) {}
		// Because the constructor is written, the system will not automatically generate the constructor.
		// Therefore, if you do not write the following line, Zoo z1; will report an error. 
		Zoo() = default;   
		Zoo(const Zoo&) = delete;
		Zoo(Zoo &&) = default;
		Zoo& operator = (const Zoo&) = default;
		Zoo& operator = (const Zoo&&) = delete;
		virtual ~Zoo() {}
}; 

int main() {
	Zoo z1;
//	Zoo z2(z1); / / because Zoo (const Zoo &) = delete; is used, an error is reported in this line 
	return 0;
}

#include<iostream>
#include<vector>
using namespace std;
//  The template should be placed outside the function 
// Use typedef syntax to copy, etc 
template<typename T>
using Vec = vector<T, allocator<T>>;

template <typename T, template <class> class Container>
class XCLs {
	private:
		Container<T> c;
	public:
		XCLs() {
			for(long i = 0; i < 10; i++)
				c.insert(c.end(), T()); 
				
//			output_static_data(T());
			Container<T> c1(c);
			// std::move is to transfer the state or ownership of an object from one object to another. It is just a transfer. There is no memory relocation or memory copy, so it can improve utilization efficiency and performance.
			Container<T> c2(std::move(c));
			c1.swap(c2);
		}
};
int main() {
	XCLs<int, Vec> c1;
	return 0;
}

• code:
  • class Base {};
  • using A = Base;

• noexcept to specify that a function will not throw an exception

• The override keyword provided in C++11 can solve this problem. It marks the virtual function in the derived class. If the virtual function in the base class is not overwritten, the compiler will report an error

• final adds two new functions: (1) prohibit base classes from being inherited, (2) prohibit virtual functions from being rewritten;

• Neither the constant 4 nor the expression var+1 is lvalue (they are rvalue). They are not lvalues because they are all temporary results of expressions and have no definite memory space (in other words, they just reside in temporary registers for the period of calculation). So assigning them has no meaning - there is no place to assign them.

• Foo returns a temporary rvalue. Trying to assign a value to it, foo()=2, is an error; The compiler expects to see an lvalue in the left part of the assignment operator.

• Not all assignments to function call results are invalid. For example, the reference of C + + makes this possible:

• const int a = 10; //‘ A 'is an lvalue

• a = 10; // But it cannot be assigned

• [...] an lvalue has no array type, no incomplete type, no const modified type, and if it is a structure or union, there is no const modified member (containing, recursive containing, collection of any member elements).

• A non function, non array type lvalue t can be converted to an lvalue. [...] If t is a non class type, the R-value type converted is a non CV modified version of T. Otherwise, the right value type is t.

• &&Syntax is a new R-value reference. Indeed, it's the same name - give us a reference to the right value that will be destructed after the call. We can use the fact that we just "steal" the internal r-values - we don't need them at all! Output is:

#include<iostream>
using namespace std;

class Intvec
{
public:
    explicit Intvec(size_t num = 0)
        : m_size(num), m_data(new int[m_size])
    {
        log("constructor");
    }

    ~Intvec()
    {
        log("destructor");
        if (m_data) {
            delete[] m_data;
            m_data = 0;
        }
    }

    Intvec(const Intvec& other)
        : m_size(other.m_size), m_data(new int[m_size])
    {
        log("copy constructor");
        for (size_t i = 0; i < m_size; ++i)
            m_data[i] = other.m_data[i];
    }

//    Intvec & operator = (const intvec & & other) / / execute v2 = v1; Will report an error 
    Intvec& operator=(const Intvec& other)
    {
        log("copy assignment operator");
        Intvec tmp(other);  // After the function is executed, tmp will be released 
        // The content in other is still there
        std::swap(m_size, tmp.m_size);   //Since other is a constant type, std::swap(m_size, other.m_size) cannot be called;
        std::swap(m_data, tmp.m_data);
        return *this;
    }
    
    Intvec& operator=(Intvec&& other) // Understand & & as stealing 
	{
	    log("move assignment operator");
	    std::swap(m_size, other.m_size);
	    std::swap(m_data, other.m_data);
	    return *this;
	}
private:
    void log(const char* msg)
    {
        cout << "[" << this << "] " << msg << "\n";
    }

    size_t m_size;
    int* m_data;
};
int main() {
	Intvec v1(20);
	Intvec v2;
	
	cout << "assigning lvalue...\n";
//	v2 = v1;
	//  Intvec(33) constructs a temporary object. After executing the following statement, it will be released. 
	// Intvec & operator = (const intvec & other), if there is const type in it, otherwise if the = overloaded function is not written, the system will say that the = overloaded function cannot be found 
	//	Or write intvec & operator = (intvec & & other)  
	v2 = Intvec(33);    //The system calls intvec & operator = (intvec & & other)  
	
	cout << "ended assigning lvalue...\n";
	return 0;
}