C++

void printValues(int (&arr)[10]) { /*......*/ }   // &arr两边的圆括号是必需的，因为下标操作符具有更高的优先级

int main() {
    int k[10] = {0,1,2,3,4,5,6,7,8,9};
    printValues(k);    //ok: argument is an array of 10 ints

    int i=0, j[2]={0, 1};
    printValues( &i ); //error: argument is not an array of 10 ints
    printValues( j );  //error: argument is not an array of 10 ints
    return 0;
}

int arr[5] = {0};
string s[] = {"foo", "bar"};

vector<int> i1 = {1, 3, 4};                // C++98中报错
vector<string> v1 = { "foo", " bar" };     // C++98中报错

// 下面是使用Initializer List进行变量初始化的例子
string s1[] = {"foo", "bar"};           // C++98中合法，C++11中合法
string s2[] {"foo", "bar"};             // C++98中报错，C++11中合法（和上一样，只是省略了等号）
vector<int> i1 = {1, 3, 4};             // C++98中报错，C++11中合法
vector<int> i2 {1, 3, 4};               // C++98中报错，C++11中合法（和上一样，只是省略了等号）
vector<string> v1 = { "foo", " bar" };  // C++98中报错，C++11中合法
vector<string> v2 { "foo", " bar" };    // C++98中报错，C++11中合法（和上一样，只是省略了等号）
map<int, float> m1 = {{1, 1.0f}, {2, 2.0f}}; // C++98中报错，C++11中合法
map<int, float> m2 {{1, 1.0f}, {2, 2.0f}};   // C++98中报错，C++11中合法（和上一样，只是省略了等号）

char buf[100*1024];  //函数体内这样的大buffer如果自动初始化，会影响性能。

const int *p = nullptr;        // p是一个指向整型常量的“指针”
constexpr int *q = nullptr;    // q是一个指向整数的“常量指针”

typedef double wages;      // wages是double的同义词

using wages = double;      // wages是double的同义词
using SI = Sales_item;     // SI是类型Sales_item的同义词

decltype(f()) sum = x;       // sum的类型就是函数f的返回类型

int main() {
    int i = 42, *p = &i, &r = i;
    decltype(r) a;          // 报错，r是引用，所以a必须初始化
    decltype(r) a2 = i;     // 正确
    decltype(r + 0) b;      // 正确，表达式 r+0 不是变量，它的结果是具体值，而非引用
    decltype(*p) c;         // 报错，表达式内容是解引用操作，将得到引用类型，c必须初始化
    decltype(*p) c2 = i;    // 正确
    decltype(*p + 0) d;     // 正确，表达式 *p+0 的结果是int
    return 0;
}

(new_type) expression      // C-language-style cast notation
new_type (expression)      // Function-style cast notation

#include<stdio.h>

void fun1(int i) {
    printf("%d\n", i);
}

void fun2(const int i) {
    printf("%d\n", i);
}

int main()
{
    int a = 1;
    const int b = 2;
    fun1(a);
    fun1(b);
    fun2(a);
    fun2(b);
}

#include<stdio.h>

void fun1(int *ip) {
    printf("%d\n", *ip);
}

void fun2(const int *ip) {    /* 不能通过ip修改指针所指向的对象 */
    printf("%d\n", *ip);
}

int main()
{
    int a = 1;
    const int b = 2;
    int * ap = &a;
    const int * bp = &b;
    fun1(ap);
    fun1(bp);  // 用C++编译器会提示编译错误(invalid conversion from 'const int*' to 'int*')，用C编译器可成功编译（仅有警告）
    fun2(ap);
    fun2(bp);
}

bool isShorter(const string &s1, const string &s2) {
  return s1.size() < s2.size();
}

#include<stdio.h>

void fun1(int &i) {
    printf("%d\n", i);
}

void fun2(const int &i) {     /* 由于引用参数由const修饰，故函数内不能修改i */
    printf("%d\n", i);
}

int main()
{
    int a = 1;
    const int b = 2;
    fun1(a);
    fun1(b);  //编译错误(invalid initialization of reference of type 'int&' from expression of type 'const int')
    fun2(a);
    fun2(b);
}

void foo(parm_list, ...);
void foo(...);

#include<stdio.h>

int count;

int fun2();

void fun1(int i=0, int j=fun2()) {         //fun1()中参数j的默认实参为函数fun2()，在调用fun1()时会调用fun2()
    printf("i=%d, j=%d\n", i, j);
}

int fun2() {                               //fun2()中又调用了fun1()，这样形成了一个死循环！
    printf("call %d times\n", count++);
    fun1();
    return 1;
}

int main() {
    fun1();
    return 0;
}

string append_xxx(const string &str) {
    return str + "xxx";
}

const string & shorterString(const string &s1, const string &s2) {
    return s1.size() <= s2.size() ? s1 : s2;
}

// 下面代码是错误的：这个函数试图返回局部对象的引用
const string &manip() {
    string ret;

    // 以某种方式改变一下变量ret

    if (!ret.empty()) {
        return ret;          // 错误：返回局部对象的引用！
    } else {
        return "Empty";      // 错误："Empty"是一个局部临时量
    {
}

 1: #include <iostream>
 2: #include <string>
 3: 
 4: using namespace std;
 5: 
 6: char &get_val(string &str, string::size_type ix) {
 7:     return str[ix];            // get_val假设索引值是有效的
 8: }
 9: 
10: int main() {
11:     string s("a value");
12:     cout << s << endl;         // 输出 a value
13:     get_val(s, 0) = 'A';     // 将 s[0] 的值改为 A
14:     cout << s << endl;         // 输出 A value
15:     return 0;
16: }

int (*fun1(int i))[10];

typedef int arrT[10];
arrT* fun1(int i);

using arrT = int[10];
arrT* fun1(int i);

auto fun1(int i) -> int(*)[10];

template<typename T1, typename T2>
decltype(t1 + t2) Sum(T1 & t1, T2 & t2) {   // 编译器报错，提示t1和t2未定义
    return t1 + t2;
}

template<typename T1, typename T2>
auto Sum(T1 & t1, T2 & t2) -> decltype(t1 + t2) {
    return t1 + t2;
}

void fun1(int i) { /* */ }
void fun1(const int i) { /* */ }     //C和C++编译器都会提示“重定义”错误！

void fun1(int *ip) { /* */ }
void fun1(const int *ip) { /* */ }   //C++中，这是合法的函数重载；但C中，会报“重定义”错误！

void fun1(int *ip) { /* */ }
void fun1(int *const ip) { /* */ }   //C++和C中，都会报“重定义”错误！

void fun1(int &i) { /* */ }
void fun1(const int &i) { /* */ }    //合法的函数重载。

#include<iostream>

int main() {
    int girls = 3, boys = 4;

    // auto totalChild = [] (int x, int y) -> int { return x + y; };
    auto totalChild = [=] () -> int { return girls + boys; };

    std::cout << totalChild() << std::endl;
    return 0;
}

#include  <iostream>
using namespace std;

int main () {

    int j = 12;

    auto by_val_lambda =  [=] { return j + 1; };    // 值传递捕捉
    auto by_ref_lambda =  [&] { return j + 1; };    // 引用传递捕捉

    cout << "by_val_lambda: " << by_val_lambda() << endl;
    cout << "by_ref_lambda: " << by_ref_lambda() << endl;

    j++;

    cout << "by_val_lambda：" << by_val_lambda() <<endl;
    cout << "by_ref_lambda：" << by_ref_lambda()  <<endl;
}

#include <iostream>

using namespace std;

int main() {
    auto lambda = [](auto x, auto y) {return x + y;};

    std::cout << lambda(1, 2) << std::endl;
    std::cout << lambda(1.1, 2.1) << std::endl;

    return 0;
}

auto lambda1 = [](int x, int y) {return x + y;};
auto lambda2 = [](double x, double y) {return x + y;};

int factory(int i) { return i * 10; }
auto f = [x = factory(4)] { return x; };   // x 初始化为表达式 factory(4) 的值

auto generator = [x = 0] () mutable {
  // this would not compile without 'mutable' as we are modifying x on each call
  return x++;
};
auto a = generator(); // == 0
auto b = generator(); // == 1
auto c = generator(); // == 2

auto x = 1;
auto f = [&r = x, x = x * 10] {
  ++r;
  return r + x;
};
f();               // sets x to 2 and returns 12

Rectangle obj1;              // 注意：Rectangle obj1();是定义对象的错误写法，这种方式是声明一个函数！千万要小心！
Rectangle obj1=Rectangle();  // 效果同上。创建并初始化一个Rectangle对象，然后用它来按值初始化obj1（会调用复制构造函数，但往往会被编译器优化为不调用复制构造函数）。

Rectangle *p_obj1 = new Rectangle();
Rectangle *p_obj1 = new Rectangle;       // 同上。

class Rectangle {
  int width, height;
public:
  Rectangle (int,int);
};

Rectangle::Rectangle (int a, int b): width(a), height(b) { }

Rectangle::Rectangle (int a, int b) {
  width = a;
  height = b;
}

class A {
int fun1 ();
int fun1 () const;  /* 基于成员函数是否为const，可以重载函数。 */
};

class Value
{
private:
  int m_nValue;
public:
  Value(int nValue) { m_nValue = nValue; }
  friend bool IsEqual(const Value &cValue1, const Value &cValue2);
};

bool IsEqual(const Value &cValue1, const Value &cValue2)
{
  return (cValue1.m_nValue == cValue2.m_nValue);  //如果没有友元声明，私有成员m_nValue不能被访问。
}

#include<iostream>

class Storage
{
private:
  int m_nValue;
  double m_dValue;
public:
  Storage(int nValue, double dValue)
  {
    m_nValue = nValue;
    m_dValue = dValue;
  }

  // Make the Display class a friend of Storage
  friend class Display;
};

class Display
{
private:
  bool m_bDisplayIntFirst;

public:
  Display(bool bDisplayIntFirst) { m_bDisplayIntFirst = bDisplayIntFirst; }

  void DisplayItem(Storage &cStorage)   //友元类的所有成员函数都可以访问授予友元关系的那个类的非公有成员
  {
    if (m_bDisplayIntFirst)
      std::cout << cStorage.m_nValue << " " << cStorage.m_dValue << std::endl;
    else // display double first
      std::cout << cStorage.m_dValue << " " << cStorage.m_nValue << std::endl;
  }
};

int main()
{
  Storage cStorage(5, 6.7);
  Display cDisplay(false);

  cDisplay.DisplayItem(cStorage);  //输出： 6.7 5

  return 0;
}

// file foo1.h
class foo1
{
private:
    static int i;
};

// file foo1.cpp
int foo1::i = 10;     // static数据成员在定义时才初始化。static关键字只能出现在类定义体内部的声明中，定义时不能标示为static。

// file foo2.h
class foo2
{
private:
    static const int i = 10;  //类的定义体中进行初始化要满足三个要求：1. static, 2. const, 3. int类型
};

// file foo2.cpp
const int foo2::i;            //整型const static数据成员在类内部提供了初始化式时，在定义时不必再指定初始值。
                              //整型const static数据成员在类内部提供了初始化式时，有些编译器可以省略它的定义。

class Date {
    int d, m, y;
    static Date default_date;
public:
    Date(int dd =0, int mm =0, int yy =0);
    // ...
    static void set_default(int dd, int mm, int yy);  // set default_date to Date(dd,mm,yy)
};

string null_book = "9-999-99999-9";  // copy-initialization
string dots(10, '.');                // direct-initialization

string empty_copy = string();        // copy-initialization
string empty_direct;                 // direct-initialization

// file copy_elision.cpp
#include <iostream>
using namespace std;

class A {
public:
  A(const char* str = "\0") {      // default constructor
    cout << "Constructor called" << endl;
  }

  A(const A &a) {                  // copy constructor
    cout << "Copy constructor called" << endl;
  }
};

int main() {
  A obj1 = "test";   // 编译器会优化后效果类似于：A obj1("test");
  return 0;
}

// default string constructor and five string copy constructors invoked
vector<string> svec(5);

vector<string> svec;       // empty vector

svec.push_back(string1);   // append string1 into vector svec
svec.push_back(string2);   // append string2 into vector svec

class Sales_item {
private:
    std::string isbn;
    int units_sold;
    double revenue;
};

Sales_item::Sales_item(const Sales_item &orig):
               isbn(orig.isbn),                    // uses string copy constructor
               units_sold(orig.units_sold),        // copies orig.units_sold
               revenue(orig.revenue)               // copy orig.revenue
               { }                                 // empty body

class Sales_item {
private:
    std::string isbn;
    int units_sold;
    double revenue;
};

// equivalent to the synthesized copy-assignment operator
Sales_item&
Sales_item::operator=(const Sales_item &rhs) {
    isbn = rhs.isbn;             // calls string::operator=
    units_sold=rhs.units_sold;   // uses built-in int assignment
    revenue = rhs.revenue;       // uses built-in double assignment
    return *this;
}

// p points to default constructed object
Sales_item *p = new Sales_item;
{                           // new scope
  Sales_item item(*p);      // copy constructor copies *p into item
  delete p;                 // destructor called on object pointed by p
}                           // exit local scope; destructor called on item

// pointer is destroyed because it goes out of scope,
// but not the object it pointed to. MEMORY LEAK!!!
if (1) {
  Foo *myfoo = new Foo("foo");
}

// pointer is destroyed because it goes out of scope,
// object it points to is deleted. no memory leak
if(1) {
  Foo *myfoo = new Foo("foo");
  delete myfoo;
}

// no memory leak, object goes out of scope
if(1) {
  Foo myfoo("foo");
}

#include <iostream>

using namespace std;

class A
{
public:
    A() { cout << "A constructor called" << endl; }
    ~A() { cout << "A destructor called" << endl; }
};

class B
{
public:
    B() { cout << "B constructor called" << endl; }
    ~B() { cout << "B destructor called" << endl; }
};

class Test
{
    A obj1;
    B obj2;
public:
    Test() { cout << "Test constructor called" << endl; }
    ~Test() { cout << "Test destructor called" << endl; }
};

int main()
{
    Test foo;
    return 0;
} // foo goes out of scope here

a = b + c;

int i = 42;
int&& rr1 = i;          // 编译出错：不能用左值初始化一个右值引用。rvalue reference to type 'int' cannot bind to lvalue of type 'int'
int&& rr2 = i * 42;     // 正确：将右值引用 rr2 绑定到乘法结果（右值）上
int&& rr3 = 42;         // 正确：字面常量是右值

#include <iostream>
#include <string>

int main() {
    std::string s1 = "Test";

    const std::string& r2 = s1 + s1; // okay: 常量左值引用可以“增加临时对象的生命期”
//  r2 += "Test";                    // error: 不能修改它（因为是 const 的）

    std::string&& r3 = s1 + s1;      // okay: 右值引用可以“增加临时对象的生命期”
    r3 += "Test";                    // okay: 可以修改它
    std::cout << r3 << '\n';
}

#include <iostream>
#include <utility>

void f(int& x) {
    std::cout << "lvalue reference overload f(" << x << ")\n";
}

void f(const int& x) {
    std::cout << "lvalue reference to const overload f(" << x << ")\n";
}

void f(int&& x) {
    std::cout << "rvalue reference overload f(" << x << ")\n";
}

int main() {
    int i = 1;
    const int ci = 2;
    f(i);  // calls f(int&)
    f(ci); // calls f(const int&)
    f(3);  // calls f(int&&)
           // would call f(const int&) if f(int&&) overload wasn't provided
    f(std::move(i)); // calls f(int&&)

    // rvalue reference variables are lvalues when used in expressions
    int&& x = 1;
    f(x);            // calls f(int& x)
    f(std::move(x)); // calls f(int&& x)
}

ClassA (ClassA &&)               // 移动构造函数语法

#include <iostream>
#include <string>

using namespace std;

class HasPtrMem {
private:
    int * d;
    static int n_cstr;
    static int n_dstr;
    static int n_cptr;

public:
    HasPtrMem() : d(new int(100)) {
        cout << "Construct:" << ++n_cstr << endl;
    }

    HasPtrMem(const HasPtrMem &h) : d(new int(*h.d)) {
        cout << "Copy construct: " << ++n_cptr << endl;
    }

    ~HasPtrMem() {
        cout << "Destruct: " << ++n_dstr << endl;
    }
};

int HasPtrMem::n_cstr = 0;
int HasPtrMem::n_dstr = 0;
int HasPtrMem::n_cptr = 0;

HasPtrMem GetTemp() { return HasPtrMem(); }

int main() {
    HasPtrMem a = GetTemp();
    return 0;
}

#include <iostream>
#include <string>

using namespace std;

class HasPtrMem {
private:
    int * d;
    static int n_cstr;
    static int n_dstr;
    static int n_cptr;
    static int n_mvtr;              // 记录移动构造函数调用次数

public:
    HasPtrMem() : d(new int(100)) {
        cout << "Construct:" << ++n_cstr << endl;
    }

    HasPtrMem(const HasPtrMem &h) : d(new int(*h.d)) {   // 复制构造函数中有“申请堆内存的过程”
        cout << "Copy construct: " << ++n_cptr << endl;
    }

    // 下面是移动构造函数
    HasPtrMem(HasPtrMem && h) : d(h.d) { // 用临时值的指针成员(h.d)初始化新对象的指针成员(d)，这里没有“申请堆内存的过程”，只是新指针指向了旧指针对应的堆内存
        h.d = nullptr;                   // 必须将临时值的指针成员置空，这样临时值被构造时不会释放底层的堆内存
        cout << "Move construct: " << ++n_mvtr << endl;
    }

    ~HasPtrMem() {
        cout << "Destruct: " << ++n_dstr << endl;
    }
};

int HasPtrMem::n_cstr = 0;
int HasPtrMem::n_dstr = 0;
int HasPtrMem::n_cptr = 0;
int HasPtrMem::n_mvtr = 0;

HasPtrMem GetTemp() { return HasPtrMem(); }

int main() {
    HasPtrMem a = GetTemp();
    return 0;
}

 1: class A
 2: {
 3: public:
 4:     A(int a){};
 5:     A() = default;     // 明确要求编译器生成默认构造函数
 6: };
 7: 
 8: int main() {
 9:     A a;               // 如果注释掉第5行代码，编译器会报错。因为用户编译了构造函数后，默认构造函数将默认不生成
10:     return 0;
11: }

class X {
    // ...
    X& operator=(const X&) = delete;  // Disallow copying
    X(const X&) = delete;
};

#include <iostream>
using namespace std;

class Box {
public:
  double getVolume(void) { return length * breadth * height; }

  void setLength( double len ) { length = len; }
  void setBreadth( double bre ) { breadth = bre; }
  void setHeight( double hei ) { height = hei; }

  Box operator+(const Box& b) {                      // 重载+操作符为成员函数。
    Box box;
    box.length = this->length + b.length;
    box.breadth = this->breadth + b.breadth;
    box.height = this->height + b.height;
    return box;
  }

  friend Box operator-(const Box &, const Box &);
private:
  double length;      // Length of a box
  double breadth;     // Breadth of a box
  double height;      // Height of a box
};

Box operator-(const Box &a, const Box &b) {          // 重载-操作符为非成员函数。
  Box box;
  box.setLength(a.length - b.length);                // 通常要将非成员函数重载操作符设置为所操作类的友元。这样可以直接使用访问私有成员a.length
  box.setBreadth(a.breadth - b.breadth);
  box.setHeight(a.height - b.height);
  return box;
}

int main() {
  Box Box1, Box2, Box3, Box4;
  double volume = 0.0;

  // box 1 specification
  Box1.setLength(6.0);
  Box1.setBreadth(7.0);
  Box1.setHeight(5.0);

  // box 2 specification
  Box2.setLength(12.0);
  Box2.setBreadth(13.0);
  Box2.setHeight(10.0);

  // volume of box 1
  volume = Box1.getVolume();
  cout << "Volume of Box1 : " << volume <<endl;  //Volume of Box1 : 210

  // volume of box 2
  volume = Box2.getVolume();
  cout << "Volume of Box2 : " << volume <<endl;  //Volume of Box2 : 1560

  // Add two object as follows:
  Box3 = Box1 + Box2;                // 操作符+为成员函数。
                                     // 还可以写为Box3 = Box1.operator+(Box2);的形式，但不能写为Box3 = operator+(Box1,  Box2);

  // volume of box 3
  volume = Box3.getVolume();
  cout << "Volume of Box3 : " << volume <<endl;  //Volume of Box3 : 5400

  Box4 = Box2 - Box1;                // 操作符-为非成员函数。
                                     // 还可以写为Box4 = operator-(Box2, Box1);的形式。

  // volume of box 4
  volume = Box4.getVolume();
  cout << "Volume of Box4 : " << volume <<endl;  //Volume of Box4 : 180

  return 0;
}

#include <iostream>
using namespace std;

class Distance
{
private:
    int feet;
    int inches;
public:
    Distance(){
        feet = 0;
        inches = 0;
    }

    Distance(int f, int i) {
        feet = f;
        inches = i;
    }

    friend ostream &operator<<(ostream &output, const Distance &D) {  // 第一个形参为ostream&，第二个形参为const对象引用
        output << "Feet : " << D.feet << " Inches : " << D.inches;
        return output;
    }

    friend istream &operator>>(istream  &input, Distance &D) {        // 第一个形参为istream&，第二个形参为对象引用
        input >> D.feet >> D.inches;         // 仅是demo，没有处理输入期间的错误（如输出值和期待的类型不同）。
        return input;
    }
};

int main() {
   Distance D1(11, 10), D2(5, 11), D3;

   cout << "Enter the value of object : " << endl;
   cin >> D3;
   cout << "First Distance : " << D1 << endl;
   cout << "Second Distance :" << D2 << endl;
   cout << "Third Distance :" << D3 << endl;

   return 0;
}

#include <iostream>
using namespace std;

class Time
{
   private:
      int hours;             // 0 to 23
      int minutes;           // 0 to 59
   public:
      Time() {
         hours = 0;
         minutes = 0;
      }
      Time(int h, int m) {
         hours = h;
         minutes = m;
      }

      void displayTime() {
         cout << "H: " << hours << " M:" << minutes <<endl;
      }

      // overloaded prefix ++ operator
      Time operator++ () {
         ++minutes;          // increment this object
         if(minutes >= 60) {
            ++hours;
            minutes -= 60;
         }
         return *this;                     // 前缀形式返回被增量对象的引用
      }

      // overloaded postfix ++ operator
      Time operator++(int) {               // 后缀形式有额外的int型形参
         // save the orignal value
         Time T(hours, minutes);
         // increment this object
         ++minutes;
         if(minutes >= 60) {
            ++hours;
            minutes -= 60;
         }
         // return old original value
         return T;                          // 后缀形式返回尚未自增的旧值
      }
};

int main() {
   Time T1(11, 59), T2(10,40);

   ++T1;                    // increment T1
   T1.displayTime();        // display T1
   ++T1;                    // increment T1 again
   T1.displayTime();        // display T1

   T2++;                    // increment T2
   T2.displayTime();        // display T2
   T2++;                    // increment T2 again
   T2.displayTime();        // display T2
   return 0;
}

#include <iostream>
#include <string>
#include <vector>
using namespace std;

bool GT6(const string &s) {
  return s.size() >= 6;
}

bool GT7(const string &s) {
  return s.size() >= 7;
}

int main() {
  vector<string> words;
  words.push_back("abc");
  words.push_back("abcdef");
  words.push_back("abcdefg");
  words.push_back("qwertyuiop");

  cout << count_if(words.begin(), words.end(), GT6)
       << " words 6 characters or longer" << endl;            // 3 words 6 characters or longer

  cout << count_if(words.begin(), words.end(), GT7)
       << " words 7 characters or longer" << endl;            // 2 words 7 characters or longer

  return 0;
}

#include <iostream>
#include <string>
#include <vector>
using namespace std;

class GT_cls {
public:
  GT_cls(size_t val = 0): bound(val) { }

  bool operator()(const string &s) {
    return s.size() >= bound;
  }

private:
  string::size_type bound;
};

int main() {
  vector<string> words;
  words.push_back("abc");
  words.push_back("abcdef");
  words.push_back("abcdefg");
  words.push_back("qwertyuiop");

  cout << count_if(words.begin(), words.end(), GT_cls(6))       // 把函数指针GT6换成了函数对象GT_cls(6)
       << " words 6 characters or longer" << endl;

  cout << count_if(words.begin(), words.end(), GT_cls(7))       // 把函数指针GT7换成了函数对象GT_cls(7)
       << " words 7 characters or longer" << endl;

  return 0;
}

bool GTn(const string &s, size_t n) {
  return s.size() >= n;
}

#include <iostream>

class myFunctor1 {
public:
  myFunctor1 (int x) : _x(x) {}
  int operator() (int y) { return _x + y; }
private:
  int _x;
};

class myFunctor2 {
public:
  myFunctor2 (int x) : _x(x) {}
  int operator() (int y) { _x=_x + y; return _x; }     // 重载调用操作符时，修改了对象的状态（数据域）。
private:
  int _x;
};

int main() {
  myFunctor1 addFive1(5);
  std::cout << addFive1(1) << std::endl;
  std::cout << addFive1(1) << std::endl;

  myFunctor2 addFive2(5);
  std::cout << addFive2(1) << std::endl;
  std::cout << addFive2(1) << std::endl;
  return 0;
}

#include <iostream>
#include <string>
#include <vector>
using namespace std;

int main() {
  vector<string> words;
  words.push_back("yabc");
  words.push_back("xabcde");
  words.push_back("znm");

  sort(words.begin(), words.end(), greater<string>());   // 按降序对words进行排序

  for (std::vector<string>::const_iterator i = words.begin(); i != words.end(); ++i) {
    cout << *i << endl;
  }
  return 0;
}

// 书店关于书的类
#include <string>
#include <iostream>
using namespace std;

class Item_base {
public:
    Item_base(const std::string &book = "", double sales_price = 0.0):
        isbn(book), price(sales_price) { }

    std::string book() const { return isbn; }
    virtual double net_price(std::size_t n) const { return n * price; }
    virtual ~Item_base() { }

private:
    std::string isbn;         // identifier for the item

protected:
    double price;             // normal, undiscounted price
};

// Bulk为批量购买相关的类
class Bulk : public Item_base {
public:
    Bulk(): min_qty(0), discount(0.0) { }

    Bulk(const std::string& book, double sales_price,
              std::size_t qty = 0, double disc_rate = 0.0):
        Item_base(book, sales_price),
        min_qty(qty), discount(disc_rate) { }

    // redefines base version so as to implement bulk purchase discount policy
    double net_price(std::size_t cnt) const {
        if (cnt >= min_qty)
            return cnt * (1 - discount) * price;
        else
            return cnt * price;
    }

private:
    std::size_t min_qty;      // 享受折扣的最少购买量
    double discount;          // 折扣
};

// 输出n本书的价格
void print_total(ostream &os, const Item_base &item, size_t n) {
    os << "ISBN: " << item.book() // calls Item_base::book
       << "\tnumber sold: " << n << "\ttotal price: "
       << item.net_price(n) << endl;
    // virtual call: which version of net_price to call is resolved at run time
}

int main() {

    Item_base base("0-391-85410-4", 10);           // 每本10元
    Bulk bulk("0-201-82470-1", 10, 50, 0.2);       // 每本10元，满50本打8折

    print_total(cout, base, 30);
    print_total(cout, base, 90);
    print_total(cout, bulk, 30);
    print_total(cout, bulk, 90);

    return 0;
}
/* 程序输出：
ISBN: 0-391-85410-4     number sold: 30 total price: 300
ISBN: 0-391-85410-4     number sold: 90 total price: 900
ISBN: 0-201-82470-1     number sold: 30 total price: 300
ISBN: 0-201-82470-1     number sold: 90 total price: 720
*/

void Bulk::memfcn(const Bulk_item &d, const Item_base &b) {
    double ret = price; // ok: 直接使用基类中的protected成员
    ret = d.price;      // ok: 通过派生类对象使用基类中的protected成员
    ret = b.price;      // error: no access to price from an Item_base
}

class Base {
    friend class Frnd;
protected:
    int i;
};

// Frnd has no access to members in D1
class D1 : public Base {
protected:
    int j;
};

class Frnd {
public:
    int mem(Base b) { return b.i; }   // ok: Frnd is friend to Base
    int mem(D1 d) { return d.i; }     // error: 基类的友元对派生类的成员没有特殊访问权限
};

// D2 has no access to members in Base
class D2 : public Frnd {
public:
    int mem(Base b) { return b.i; }   // error: 如果基类被授予友元关系，则只有基类具有特殊访问权限，该基类的派生类不能访问授予友元关系的类。
};

Item_base *baseP = &derived;
// calls version from the base class regardless of the dynamic type of baseP
double d = baseP->Item_base::net_price(42);    // 强制将net_price调用确定为Item_base中定义的版本

// the order of the keywords public and virtual is not significant
class istream : public virtual ios { ... };
class ostream : virtual public ios { ... };

// iostream inherits only one copy of its ios base class
class iostream: public istream, public ostream { ... };

class B {
public:
  virtual int f1();
  virtual void f2(int);
  virtual int f3(int);
};

class D : public B {
  int f1();           // override
  virtual void f4();
  int f3(int);        // override
};

B *bp = new D;
bp->f2(11);
bp->f3(12);

B *bp = new D;
(*(bp->vptr)[1])(bp, 11);    // 在这个例子的虚函数表中，对应函数B::f2
(*(bp->vptr)[2])(bp, 12);    // 在这个例子的虚函数表中，对应函数D::f3

template <>
int compare<const char*>(const char* const &v1,      // 尖括号中指定这个特化定义的模板形参
                         const char* const &v2) {
     return strcmp(v1, v2);
}

const char *cp1 = "world", *cp2 = "hi";
int i1, i2;
compare(cp1, cp2); // calls the specialization
compare(i1, i2);   // calls the generic version instantiated with int

#include <iostream>

template <typename T, typename... Args>
void foo(const T &t, const Args& ... rest) {
    std::cout << "func foo called" << std::endl;
    std::cout << "sizeof...(Args)=" << sizeof...(Args) << std::endl;
    std::cout << "sizeof...(rest)=" << sizeof...(rest) << std::endl;
}

int main() {
    int i = 0; double d = 3.14; std::string s = "how now brown cow";

    foo(i, s, 42, d);
    foo(d, s);
    return 0;
}

// 用来终止递归并打印最后一个元素的函数
// 此函数必须在可变参数版本的 print 定义之前声明
template<typename T>
ostream &print(ostream &os, const T &t) {
  return os << t ;    // 包中最后一个元素之后不打印分隔符
}

// 包中除了最后一个元素之外的其他元素都会调用这个版本的 print
template <typename T, typename... Args>
ostream &print(ostream &os, const T &t, const Args&... rest) {
  os << t <<",";              // 打印第一个实参
  return print(os, rest...);  // 递归调用，打印其他实参。 rest... 是展开 packet，后面会介绍
}

print(cout, i, s, 42);       // parameter packet 中有两个参数

template <typename T, typename... Args>
ostream &print(ostream &os, const T &t, const Args&... rest) {  // 展开 Args
  os << t <<",";
  return print(os, rest...);                                    // 展开 rest
}

auto SumCpp11() {
    return 0;
}

template<typename T1, typename... Args>
auto SumCpp11(T1 s, Args... ts) {
    return s + SumCpp11(ts...);
}

template<typename ...Args>
auto sum(Args ...args) {
    return (args + ... + 0);
}

template<typename ...Args>
auto sum2(Args ...args) {
    return (args + ...);
}

#include <iostream>

template<typename... Args>
bool all(Args... args) {
    return (... && args);     // parameter packet 为空的话， && 会为 false
}

template<typename... Args>
bool any(Args... args) {
    return (... || args);     // parameter packet 为空的话， || 会为 false
}

int main() {
    std::cout << std::boolalpha;

    std::cout << all(true, true, true, false) << std::endl;
    std::cout << any(true, true, true, false) << std::endl;

    std::cout << all() << std::endl;    // true
    std::cout << any() << std::endl;    // false
    return 0;
}

throw;

// matches any exception that may be thrown
catch(...) {
   //
}

void f(int) throw(Bad, Worse); // 声明抛出Bad或者Worse类型的异常
void g(int) throw();           // 声明不抛出异常

void excpt_func() noexcept;

void excpt_func() noexcept(常量表达式);

 1: #include <iostream>
 2: 
 3: using namespace std;
 4: 
 5: void NoBlockThrow() {
 6:     throw 1;
 7: }
 8: 
 9: void BlockThrow() noexcept {
10:     throw 1;
11: }
12: 
13: int main() {
14:     try {
15:         throw 1;
16:     } catch(...) {
17:         cout << "Found throw, line: "  << __LINE__ << endl;
18:     }
19: 
20:     try {
21:         NoBlockThrow();
22:     } catch(...) {
23:         cout << "Found throw, line: "  << __LINE__ << endl;
24:     }
25: 
26:     try {
27:         BlockThrow();  // BlockThrow 用 noexcept 修饰了，但它却拋出了异常，这将导致程序调用
28:                        // std::terminate 而退出
29:     } catch(...) { // 这个catch语句中的代码不会执行，因为上一行会导致程序调用 std::terminate
30:                    // 中断程序的执行，从而阻止了异常的继续传播
31:         cout << "Found throw, line: "  << __LINE__ << endl;
32:     }
33: 
34:     return 0;
35: }

#include <iostream>

void fun1 ();
void fun2 () noexcept;

int main() {
    std::cout << std::boolalpha << noexcept(fun1()) << std::endl;   // 输出 false
    std::cout << std::boolalpha << noexcept(fun2()) << std::endl;   // 输出 true

    return 0;
}

template <class T>
void fun() noexcept(noexcept(T())) {}
        //   ^           ^
        //   |           |
        // 是修饰符   是操作符

// In some header file:
void f( T1*, T2* );

// At some call site:
f( new T1, new T2 );

// In some header file:
void f( std::unique_ptr<T1>, std::unique_ptr<T2> );

// At some call site:
f( std::unique_ptr<T1>{ new T1 }, std::unique_ptr<T2>{ new T2 } );

// In some header file:
void f( std::unique_ptr<T1>, std::unique_ptr<T2> );

// At some call site:
f( std::make_unique<T1>(), std::make_unique<T2>() );

int main()
try {
  // code
}
catch (My_error& me) {     // a My_error (user-defined exception class) happened
  //
}
catch (runtime_error& re) { // a runtine_error happened
  // we can use re.what()
}
catch (exception& e) {      // some standard-library exception happened
  // we can use e.what()
}
catch (...) {               // Some unmentioned exception happened
  //
}

#include<iostream>

template <class T>
class myVector
{
private:
  T* _data;
  int _capacity;
  int _size;

public:
  myVector() {
    _data = NULL;
    _capacity = _size = 0;
  }

  myVector(int capacity) {
    _data = new T[capacity];
    _capacity = capacity;
    _size = 0;
  }

  T& operator[](int index) {
    return _data[index];
  }

  void push_back(const T & item) {
    if(_size == _capacity) {
      size_t new_capacity = _capacity * 2 + 1;
      T* newData = new T[new_capacity];

      for (size_t i = 0; i < _size; i++) {
        newData[i] = _data[i];
      }
      // 上面for循环可以copy代替： std::copy(_data, _data + _size, newData);
      // 但不要用memcpy代替： memcpy(newData, _data, _size *sizeof(T)); 代替，
      // 因为如果类定义了“赋值操作符”/“复制构造函数”，memcpy并不会调用它们进行相应操作。
      _capacity = new_capacity;
      delete []_data;
      _data = newData;
    }
    _data[_size++] = item;
  }

  int size() { return _size; }

};

class A{
private:
  int _member;
public:
  A() { _member = 0 ; }
  A(int i): _member(i){}
  A& operator=(const A &rhs) {
    _member = rhs._member;
    //std::cout << "Assignment Operator called" << std::endl;
    return *this;
  }
};

int main() {
  myVector<A> v;
  v.push_back(A(10));
  v.push_back(A(20));
  v.push_back(A(30));

  std::cout << "size is " << v.size() << std::endl;   //output: size is 3

  return 0;
}

#include<vector>
#include <iostream>
using namespace std;

int main()
{
  vector<int> v;
  v.push_back(1);
  v.push_back(2);

  vector<int>::iterator iter1 = v.begin();
  v.push_back(3);                        // 在vector中插入元素可能导致其重新分配存储空间，从而导致迭代器 iter1 失效！

  for(; iter1 != v.end(); iter1++) {     // Wrong!!! 不能使用iter1了！它可能失效了！
    std::cout << *iter1 << std::endl;
  }

  return 0;
}

  for(iter1 = v.begin(); iter1 != v.end(); iter1++) {

void remodel(std::string & str)
{
    std::string * ps = new std::string(str);
    //...
    if (weird_thing())
        throw exception();   // throw前没有写delete ps，可能有内存泄露
    delete ps;               // 如果忘记写delete ps，也会导致内存泄露
    return;
}

    if (weird_thing()) {
        delete ps;
        throw exception();
    }

// smrtptrs.cpp -- using three kinds of smart pointers
// requires support of C++11 shared_ptr and unique_ptr
#include <iostream>
#include <string>
#include <memory>
class Report
{
private:
  std::string str;
public:
  Report(const std::string s) : str(s)
  { std::cout << "Object created!\n"; }
  ~Report() { std::cout << "Object deleted!\n"; }
  void comment() const { std::cout << str << "\n"; }
};

int main()
{
  {
    std::auto_ptr<Report> ps1 (new Report("using auto_ptr"));
    (*ps1).comment();
    ps1->comment();
  }  // 大括号结束了一个作用域，ps1对象会过期，ps1析构函数会被调用（它会删除相应的Report对象）。
  {
    auto ps2 = std::make_shared<Report>("using shared_ptr"); // 同 std::shared_ptr<Report> ps2 (new Report("using shared_ptr"));
    ps2->comment();
  }  // 大括号结束了一个作用域，ps2对象会过期，ps2析构函数会被调用（它会删除相应的Report对象）。
  {
    auto ps3 = std::make_unique<Report>("using unique_ptr"); // 同 std::unique_ptr<Report> ps3 (new Report("using unique_ptr"));
    ps3->comment();
  }  // 大括号结束了一个作用域，ps3对象会过期，ps3析构函数会被调用（它会删除相应的Report对象）。
  return 0;
}

auto_ptr<string> ps (new string("I reigned lonely as a cloud."));
auto_ptr<string> vocation;
vocation = ps;

// fowl.cpp -- auto_ptr a poor choice
#include <iostream>
#include <string>
#include <memory>
int main()
{
  using namespace std;
  auto_ptr<string> films[5] =
    {
      auto_ptr<string> (new string("Fowl Balls")),
      auto_ptr<string> (new string("Duck Walks")),
      auto_ptr<string> (new string("Chicken Runs")),
      auto_ptr<string> (new string("Turkey Errors")),
      auto_ptr<string> (new string("Goose Eggs"))
    };
  auto_ptr<string> pwin;
  pwin = films[2];                      // films[2] loses ownership
  cout << "The nominees for best avian baseball film are\n";
  for (int i = 0; i < 5; i++)
    cout << *films[i] << endl;          // 访问 *films[2] 时会 Segmentation fault
  cout << "The winner is " << *pwin << "!\n";
  cin.get();
  return 0;
}

auto_ptr<string> p1(new string("auto");  //#1
auto_ptr<string> p2;                     //#2
p2 = p1;                                 //#3

unique_ptr<string> p3(new string("auto");  //#4
unique_ptr<string> p4;                     //#5
p4 = p3;                                   //#6

unique_ptr<string> demo(const char * s)
{
  unique_ptr<string> temp(new string(s));
  return temp;
}

unique_ptr<string> ps;
ps = demo("Uniquely special");

using namespace std;
unique_ptr<string> pu1(new string "Hi ho!");
unique_ptr<string> pu2;
pu2 = pu1;                                    //#1 not allowed
unique_ptr<string> pu3;
pu3 = unique_ptr<string>(new string "Yo!");   //#2 allowed

// shared_ptr “循环引用”演示实例
#include <iostream>
#include <memory>
using namespace std;

class parent;
class children;

class parent
{
public:
    shared_ptr<children> children;
    ~parent() { std::cout <<"destroying parent\n"; }
};

class children
{
public:
    shared_ptr<parent> parent;
    ~children() { std::cout <<"destroying children\n"; }
};


void test()
{
    shared_ptr<parent> father(new parent());
    shared_ptr<children> son(new children());

    father->children = son;        // 这一行和下一行导致了“循环引用”
    son->parent = father;
}

int main()
{
    std::cout<<"begin test...\n";
    test();
    std::cout<<"end test.\n";
    return 0;
}

// file my_smart_ptr.h

template <typename T>
class my_smart_ptr {
private:
  int count;                               // 保存引用计数
  T *ptr;                                  // 保存底层保管的指针

public:
  my_smart_ptr(T*);                        // 构造函数，普通指针初始化智能指针
  my_smart_ptr(my_smart_ptr &);            // 拷贝构造函数（会对参数进行修改，没有声明为const）

  T* operator->();                         // 重载指针运算符
  T& operator*();                          // 重载解引用运算符
  my_smart_ptr& operator=(my_smart_ptr &); // 重载赋值运算符（会对参数进行修改，没有声明为const）

  ~my_smart_ptr();                         // 析构函数
};

// file my_smart_ptr.cpp
// 构造函数
template <typename T>
my_smart_ptr<T>::my_smart_ptr(T *p): count(1), ptr(p) { }

// 拷贝构造函数
template <typename T>
my_smart_ptr<T>::my_smart_ptr(my_smart_ptr &sp): count(++sp.count), ptr(sp.ptr)  { }

// 重载指针运算符
template <typename T>
T* my_smart_ptr<T>::operator->() {
  return ptr;
}

// 重载解引用运算符
template <typename T>
T& my_smart_ptr<T>::operator*() {
  return *ptr;
}

// 重载赋值运算符：左边的计数减1，右边计数加1，当左边计数为0时，释放内存。
template <typename T>
my_smart_ptr<T>& my_smart_ptr<T>::operator=(my_smart_ptr& sp) {
  ++sp.count;
  if (--count == 0) {         //自我赋值也能保证正确
    delete ptr;
  }
  this->ptr = sp.ptr;
  this->count = sp.count;
  return *this;
}

// 析构函数
template <typename T>
my_smart_ptr<T>::~my_smart_ptr() {
  if (--count == 0) {
    delete ptr;
  }
}

#include<iostream>

int a = 1;                         // 这个a定义在全局命名空间中。

int main() {
  int a = 2;
  std::cout << a << std::endl;
  std::cout << ::a << std::endl;   // 可以用 ::a 来引用全局命名空间中的a。
}

#include<iostream>

namespace A {
  namespace B {
    int a = 1;
  }
}

int main() {
  std::cout << A::B::a << std::endl;  // 输出 1
}

namespace A {
  namespace B {     // C++11 支持的语法
    int a = 1;
  }
}

namespace A::B {    // 同上，这是 C++17 中支持的嵌套命名空间的新定义形式
  int a = 1;
}

#include<iostream>

namespace {       // unnamed namespace
  int a = 1;      // 其它文件中不能引用它，相当于 static int a = 1;
}

// int a = 2;     // ambiguous !!

int main() {
  std::cout << a << std::endl;    // 输出 1
  std::cout << ::a << std::endl;  // 输出 1
}

#include<iostream>

namespace A {
  namespace {
    int a = 1;
  }
}

int main() {
  std::cout << A::a << std::endl;
}

namespace A = ABCDEF;    // 其中命名空间ABCDEF必须已定义。
namespace B = X::Y::Z;   // 用命名空间别名引用嵌套的命名空间。

#include <iostream>

namespace foo {
    namespace bar {
         namespace baz {
             int qux = 42;
         }
    }
}

namespace fbz = foo::bar::baz;       // Namespace aliases

int main()
{
    std::cout << fbz::qux << '\n';   // Output 42
}

#include <string>
#include <stdio.h>
using namespace std;

int main(void)
{
    string str1 = "hello world";
    string str2 = str1;

    printf ("Sharing the memory:\n");
    printf ("\tstr1's address: %p\n", str1.c_str() );
    printf ("\tstr2's address: %p\n", str2.c_str() );

    str1[1]='q';  /* modify str1 */
    str2[1]='w';  /* modify str2 */

    printf ("After Copy-On-Write:\n");
    printf ("\tstr1's address: %p\n", str1.c_str() );
    printf ("\tstr2's address: %p\n", str2.c_str() );

    return 0;
}

/*
 * Trim string. Both leading and trailing spaces(" \t\n\v\f\r") are removed.
 */
static string& trim(string& str){

    const char* white_space = " \t\n\v\f\r"; //isspace().
    str.erase(0, str.find_first_not_of(white_space));  // leading trim
    str.erase(str.find_last_not_of(white_space) + 1);  // tailing trim
    return str;
}

#include <string>
#include <iostream>

int main()
{
    using namespace std::string_literals;

    std::string s1 = "abc\0\0def";
    std::string s2 = "abc\0\0def"s;
    std::cout << "s1: " << s1.size() << " \"" << s1 << "\"\n";
    std::cout << "s2: " << s2.size() << " \"" << s2 << "\"\n";
}

class String {
public:
  String(const char *str = "");
  String(const String &other);

  ~String();
  String & operator=(const String &other);

  bool operator==(const String &str);
  friend ostream & operator<<(ostream& o,const String &str);
private:
  char * m_data;
};

#include<iostream>
using std::ostream;

// 普通构造函数
String::String(const char *str) {
  if (str == NULL) {
    m_data = new char[1];
    *m_data = '\0';
  } else {
    int len = strlen(str);
    m_data = new char[len + 1];
    strcpy(m_data, str);
  }
}

// 析构函数
String::~String() {
  delete [] m_data;
}

// 拷贝构造函数
String::String(const String &other) {
  int len = strlen(other.m_data);
  m_data = new char[len + 1];
  strcpy(m_data, other.m_data);
}

// 赋值函数
String & String::operator=(const String &other) {
  // 检查自我赋值
  if (this != &other) {
    // 要先分配内存，再释放原有的内存资源
    // 这时基于异常安全的考虑（new失败时以前数据不会被破坏）
    char *temp = new char[strlen(other.m_data) + 1];
    strcpy(temp, other.m_data);

    delete [] m_data;
    m_data = temp;
  }

  return *this;
}

bool String::operator==(const String &str) {
  return strcmp(m_data,str.m_data) == 0;
}

ostream & operator<<(ostream &o,const String &str) {
  o << str.m_data;
  return o;
}

int main()
{
  String s = "cplusplus";
  String s1 = s;
  String s2 = "cplusplus";
  std::cout<<"s1 = "<<s1<< std::endl;
  std::cout<<"s2 = "<<s2<< std::endl;
  std::cout<< std::boolalpha<<(s1 == s2)<< std::endl;
  return 0;
}

static_assert(sizeof(int) == 8, "This 64-bit machine should follow this!");

int main() {
    return 0;
}

int& a[3];    // error，因为不存在引用数组
int&* p;      // error，因为不存在引用指针
int& &r;      // error，因为不存在引用的引用

typedef int&  lref;
typedef int&& rref;

int n;
lref&  r1 = n;         // type of r1 is int&
lref&& r2 = n;         // type of r2 is int&
rref&  r3 = n;         // type of r3 is int&
rref&& r4 = 1;         // type of r4 is int&&

#include <iostream>

void addOneAndPrint(int& param) {   // 参数是左值引用
    param = param + 1;
    std::cout << param << std::endl;
}

void addOneAndPrint(int&& param) {  // 参数是右值引用
    param = param + 1;
    std::cout << param << std::endl;
}

int main() {
    int num = 2019;
    addOneAndPrint(num);      // 调用 addOne(int& param)
    addOneAndPrint(2019);     // 调用 addOne(int&& param)
    return 0;
}

#include <iostream>

template<typename T>
void addOneAndPrint(T&& param) {   // 参数是万能引用
    param = param + 1;
    std::cout << param << std::endl;
}

int main() {
    int num = 2019;
    addOneAndPrint(num);      // 实参是左值
    addOneAndPrint(2019);     // 实参是右值
    return 0;
}

template<typename T>
void f(const T&& param);            // “&&” 这里表示右值引用！

template<typename T>
void f(std::vector<T>&& param);     // “&&” 这里表示右值引用！

int i = 100;
int& r1 = i;
int&& r2 = 200;

auto&& r3 = r1;          // auto&& 是万能引用
auto&& r4 = r2;          // auto&& 是万能引用

#include <iostream>

void addOneAndPrint(int& param) {   // 参数是左值引用
    param = param + 1;
    std::cout << "传入参数为左值" << std::endl;
    std::cout << param << std::endl;
}

void addOneAndPrint(int&& param) {  // 参数是右值引用
    param = param + 1;
    std::cout << "传入参数为右值" << std::endl;
    std::cout << param << std::endl;
}

template<typename T>
void wrapper(T&& param) {    // 参数是万能引用
    addOneAndPrint(param);
}

int main() {
    int num = 2019;
    wrapper(num);    // 传入左值 num
    wrapper(2019);   // 传入右值 2019
    return 0;
}

template<typename T>
void wrapper(T&& param) {
    addOneAndPrint(std::forward<T>(param));
}