BOOK

template 
class NamedObject {
  public:
    NamedObject(std::string& name, const T&value);
    ...
  private:
    std::string& nameValue;  // 如今這是個 reference
    const T objectValue;  // 如今這是個 const
};

std::string newDog("Persephone");
std::string oldDog("Satch");
NamedObject p(newDog, 2);
NamedObject s(oldDog, 36);
p = s;  // 此時 p 的成員變數該發生什麼事？

class HomeForSale {
  public:
    ...
  private:
    ...
    HomeForSale(const HomeForSale&);  // 只有宣告
    HomeForSale& operator=(const HomeForSale&);  // 只有宣告
}

class Uncopyable {
  protected:
    Uncopyable();  // 允許 derived 物件的建構和解構
    ~Uncopyable();
  private:
    Uncopyable(const Uncopyable&);  // 但阻止 copying
    Uncopyable& operator=(const Uncopyable&);
};

class omeForSale : private Uncopyable {
    ...
};

class TimeKeeper {
  public:
    TimeKeeper();
    ~TimeKeeper();
    ...
};

class AtomicClock : public TimeKeeper() { ... };
class WaterClock : public TimeKeeper() { ... };
class WristClock : public TimeKeeper() { ... };

TimeKeeper* getTimeKeeper();  // 傳回指向 derived class 的指標

TimeKeeper* pkt = getTimeKeeper();  // 取得的態配置物件
...
delete pkt;  // 釋放資源

class TimeKeeper {
  public:
    TimeKeeper();
    virtual ~TimeKeeper();
    ...
};

TimeKeeper* pkt = getTimeKeeper();
...
delete pkt;

class SpecialString : public std::string {
    // bad idea, std::string 有個 non-virtual destructor
    ...
};

SpecialString* pss = new SpecialString("Impending Doom");
std::string* ps;
...
ps = pss;
...
delete(ps);// 未定義，現實情況會有 memory leak

class AWOV {  // Abstract Without Virtuals
  public:
    virtual ~AWOV() = 0;  // 宣告 pure virtual destructor
};
// 

 AWOV::~AWOF() { }

class Widget {
  public:
    ...
    ~Widget() { ... }  // 假設這裡可能吐出 exception
};

void doSomething() {
    std::vector v;
    ...        // v 在這裡被 destruct
}

class DBConnection {
  public:
    ...
    static DBConnection create();  // 傳回 DBConnection 物件
    void close();  // 關閉連線，失敗則拋出 exception
};

class DBConn {  // 用來管理 DBConnection 物件
  public:
    ...
    ~DBCon() {  // 確保資料庫連線總是會被關閉
        db.close();
    }
  private:
    DBConnection db;
};

DBConn::~DBConn() {
    try { db.close(); }
    catch (...) {
        ...        // 記下對 close() 的呼叫失敗
        std::abort();  // 結束程式
    }
};

DBConn::~DBConn() {
    try { db.close(); }
    catch (...) {
        ...        // 記下對 close() 的呼叫失敗
    }
};

class DBConn {  // 用來管理 DBConnection 物件
  public:
    ...
    void close() {  供使用者使用的新函式
        db.close();
        closed = true;
    }

    ~DBCon() {  // 確保資料庫連線總是會被關閉
        if (!closed) {
            try () {
                db.close();
            } catch (...) {
                ...       // 記下對 close() 的呼叫失敗
            }
        }
    }
  private:
    DBConnection db;
    closed;
};

class Transaction {  // 所有交易的 base class
  public:
    Transaction();
    virtual void logTransaction() const = 0;
    // pure virtual function for writing log
    ...
};

Transaction::Transaction() {  // constructor of base class
    ...
    logTransaction();  // writing the log
}

class BuyTransaction : public Transaction {  // derived class
  public:
    virtual void logTransaction() const;  // log this transaction
    ...
};

class SellTransaction : public Transaction {  // derived class
  public:
    virtual void logTransaction() const;  // log this transaction
    ...
};
  // 

BuyTransaction b;

class Transaction {  // 所有交易的 base class
  public:
    explicit Transaction(const std::string& logInfo);
    void logTransaction(const std::string& logInfo);
    // non-virtual function for writing log
    ...
};

Transaction::Transaction(const std::string& logInfo) {  // constructor of base class
    ...
    logTransaction();  // writing the log
}

class BuyTransaction : public Transaction {  // derived class
  public:
    BuyTransaction( parameters )
            : Transaction(createLogString( parameters )) {
            // 將 log 資訊傳給 constructor of base class
        ...
    }
  private:
    static std::string createLogString( parameters );
};

int x, y, z;
x = y = z = 13;  // 連銷賦值

x = (y = (z = 13));

class Widget {
  public:
    ...
    Widget& operator=(const Widget& rhs) {
        ...
        return *this;
    }
};

class Widget {
  public:
    ...
    Widget& operator+=(const Widget& rhs) {
    // 這個協定適用於 +=, -=, *= 等等
        ...
        return *this;
    }

    Widget& operator=(int rhs) {
    // 即使參數形別不符合協定，也可以適用
        ...
        return *this;
    }
};

class Widget { ... };
Widget w;
...
w = w;  // 賦值給自己

a[i] = a[j];  // 若 i == j，則賦值給自己
*px = *py;  // 若 px == py，則賦值給自己

class Bitmap { ... };
class Widget {
    ...
  private:
    Bitmap* pb;  // 指向一個從 heap 配置而得的物件
};

Widget& Widget::operator=(const Widget& rhs) {
    // 不安全的 operator= 實作版本
    delete pb;
    pb = new Bitmap(*rhs.pb);
    return *this;
}

Widget& Widget::operator=(const Widget& rhs) {
    if (this == rhs) return *this;  // identity test

    delete pb;
    pb = new Bitmap(*rhs.pb);
    return *this;
}

Widget& Widget::operator=(const Widget& rhs) {
    Bitmap* pOrig = pb;  // 記住原先的 pb
    pb = new Bitmap(*rhs.pb);  // 令 pb 指向另一個複件
    delete pOrig;  // 刪除原先的 pb
    return *this;
}

class Widget {
    ...
    void swap(Widget& rhs);  // 交換 *this 和 rhs 的資料
};

Widget& Widget::operator=(const Widget& rhs) {
    Widget temp(rhs);  // 為 rhs 資料製作一份複件
    swap(temp);  // 將 *this 資料和上述複件的資料交換
    return *this;
}

Widget& Widget::operator=(Widget rhs) {  // pass by value
    swap(rhs);
    return *this;
}

void logCall(const std::string& funcName);  // 製造一個 log entry
class Customer {
  public:
    ...
    Customer(const Customer& rhs);
    Customer& operator=(const Customer& rhs);
    ...
  private:
    std::string name;
};

Customer::Customer(const Customer& rhs)
        : name(rhs.name) {
    logCall("Customer copy constructor");
}

Customer& Customer::operator=(const Customer& rhs) {
    logCall("Customer copy assignment operator");
    name = rhs.name;
    return *this;
}

class Customer {
  public:
    ...
  private:
    std::string name;
    Date lastTransaction;
};

class PriorityCustomer : public customer {
  public:
    ...
    PriorityCustomer(const PriorityCustomer& rhs);
    PriorityCustomer& operator=(const PriorityCustomer& rhs);
    ...
  private:
    int priority;
};

PriorityCustomer::PriorityCustomer(const PriorityCustomer& rhs)
        : priority(rhs.priority) {
    logCall("PriorityCustomercopy constructor");
}

PriorityCustomer& PriorityCustomer::operator=(const PriorityCustomer& rhs) {
    logCall("PriorityCustomer copy assignment operator");
    priority= rhs.priority;
    return *this;
}

PriorityCustomer::PriorityCustomer(const PriorityCustomer& rhs)
        : Customer(rhs)  // 呼叫 base class 的 copy constructor
        , priority(rhs.priority) {
    logCall("PriorityCustomercopy constructor");
}

PriorityCustomer& PriorityCustomer::operator=(const PriorityCustomer& rhs) {
    logCall("PriorityCustomer copy assignment operator");
    Customer::operator=(rhs);
    // 呼叫 base class 的 assignment operator
    priority= rhs.priority;
    return *this;
}