Effective C++

char greeting[] = "Hello";
char *p = greeting;              //non-const pointer, non-const data

const char *p = greeting;        //non-const pointer, const data
char const *p = greeting;        //same as above

char * const p = greeting;       //const pointer, non-const data

const char * const p = greeting; //const pointer, const data

std::vector<int> vec;
const std::vector<int>::iterator iter = vec.begin(); // iter acts like a T* const

std:vector<int>::const_iterator cIter = vec.begin(); // cIter acts like a const T*

class TextBlock
{
public:
    const char& operator[](std::size_t position) const {  //operator[] for
        return text[position];                            //const object
    }

    char& operator[](std::size_t position) {              //operator[] for
        return text[position];                            // non-const object
    }
private:
    std::string text;
};

class Base {
    virtual  void pure_virtual_example() = 0;
};

#include <iostream>
using namespace std;

class Base
{
public:
    Base() {
        cout << "Base Ctor" << endl;
    }
    virtual ~Base() = 0;
    virtual void speak() = 0;
};
Base::~Base() {
    cout << "Pure Virtual Dtor Need One Difinition!" << endl;
}

class De : public Base {
public:
    De() {
        cout << "De Ctor" << endl;
    }
    virtual ~De() {
        cout << "De Dtor" << endl;
    }
    void speak() {}
};

int main(int argc, char *argv[])
{
    De *dd = new De();
    delete dd;
    return 0;
}

x = y = z = 15;
// Following is the real order by default
x = (y = (z=15));

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

class Bitmap {
//..
};

class Widget {
private:
    Bitmap* pb;
};

// Wrong Version!! what about if rhs is this
Widget& Widget::operator=(const Widget& rhs) {
    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;
}

class Widget {
    Bitmap* pOrig = pb; // remember previous pb
    // if exception here, the next line delete pOrig will not execute
    pb = new Bitmap(*rhs.pb);
    delete pOrig;
    return *this;
}

class Customer {
    //...
};

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

PriorityCustomer::PriorityCustomer(const PriorityCustomer& rhs)
    : Customer(rhs), priority(rhs.priority) {}
PriorityCustomer& PriorityCustomer::operator=(const PriorityCustomer& rhs) {
    Customer::operator=(rhs);
    priority = rhs.priority;
    return *this;
}

class Investment {
    //...
};

// 返回指针,指向动态分配的内存(存储Investment对象),
// 调用者有责任释放他们
Investment* createInvestment();

void f() {
    Investment* pInv = createInvestment();
    //...
    delete pInv;
}

void f() {
    //会在对象离开作用域的时候, 自动调用析构函数保证资源释放
    std::auto_ptr<Investment> pInv(createInvestment());
    //...
}

// pInv1指向createInvestment的返回值
std::auto_ptr<Investment> pInv1(createInvestment());
//现在pInv2指向对象, pInv1为null
std::auto_ptr<Investment> pInv2(pInv1);
//现在pInv1指向对象, pInv2为null
pInv1 = pInv2

// 馊主意,会用错误的delete形式
std::auto_ptr<std::string> aps(new std::string[10]);
std::tr1::shared_ptr<int> spi(new int[1024]);

typedef std::string AddressLine[4];
// new Addressline返回一个new string[4]
std::string* pal = new AddressLine;

//...
delete pal; //Not defined
delete []pal; //Good

int priority();

//declaration for the function
void processWidget(std::tr1::shared_ptr<Widget>, int priority);

//usage fo the function
processWidget(new Widget, priority());

processWidget(std::tr1::shared_ptr<Widget>(new Widget), priority());

std::tr1::shared_ptr<Widget> pw(new Widget);

processWidget(pw, priority());

inline const Rational operator*(const Rational& lhs, const Rational& rhs) {
    return Rational(lhs.n * rhs.n, lhs.d * rhs.d);
}

const Rational& operator* (const Rational& lhs,
                           const Rational& rhs) {
    //警告!糟糕的代码!!
    Rational result(lhs.n * rhs.n, lhs.d * rhs.d);
    return result;
}

const Rational& operator* (const Rational& lhs,
                           const Rational& rhs) {
    Rational* result = new Rational(lhs.n * rhs.n, lhs.d * rhs.d*);
    return *result;
}

Rational w, x, y, z;
w = x * y *z;

class WebBrowser{
    void clearCache();
    void clearHistory();
    void removeCookies();
    void clearBrowser() {
        clearCache();
        clearHistory();
        removeCookies();
    }
};

namespace WebBrowserStuff{
    class WebBrowser{
        void clearCache();
        void clearHistory();
        void removeCookies();
    };
    void  clearBrowser(WebBrowser& wb){
        wb.clearCache();
        wb.clearHistory();
        wb.removeCookies();
    }
}

class Rational {
pulic:
    //...
    // NOT work for result = 2 * oneHalf
    const Rational operator*(const Rational& rhs) const;
};

class Rational {
    //...
};

const Rational operator*(lhs.numberator() * rhs.numberator(),
                         lhs.denominator() * rhs.denominator()) {
    return Rational(lhs.numberator() * rhs.numberator(),
                    lhs.denominator() * rhs.denominator());
}

class Widget {
public:
    //...
    void swap(Widget& other) {
        using std::swap;
        swap(pImpl, other.pImpl);
    }
    //...
};
namespace std {
    template<>
    void swap<Widget>(Widget& a, Widget& b) {
        a.swap(b);
    }
}

(T)expression   //将expression 转型为T
T(expression)   //将expression 转型为T

class Widget {
public:
    explicit Widget(int size);
    // ...
};

void doSomeWork(const Widget& w);
// 以一个int加上"旧式函数风格"的转型动作创建了一个Widget
doSomeWork(Widget(15));
// 以一个int加上"新式C++风格"的转型动作创建了一个Widget
doSomeWork(static_cast<Widget>(15));

int x, y;
// ...
double d = static_cast<double>(x) / y;

#include <iostream>
using namespace std;

class B1 {
    int i;
};

class B2 {
    int i;
};

class D : public B1, public B2 {
    int i;
};

int main(int argc, char *argv[])
{
    D aD;
    B1* pb1 = &aD;
    B2* pb2 = &aD;

    cout << &aD << endl;
    //////////////////////////////////////////////////////
    // There's no possible way for the B1 sub-object to //
    // have the same address as the B2 sub-object.      //
    //////////////////////////////////////////////////////
    cout << pb1 << endl;
    cout << pb2 << endl;
    return 0;
}

///////////////////////////////////////////////
// <==========running the test.out=========> //
//                                           //
// 0x28fecc                                  //
// 0x28fecc                                  //
// 0x28fed0                                  //
//                                           //
// <==========test.out ends here===========> //
///////////////////////////////////////////////

class Point {
public:
    Point(int x, int y);
    // ...
    void setX(int newVal);
    void setY(int newVal);
};

struct RectData {
    Point ulhc; // ulhc = "upper left-hand corner"
    Point lrhc; // lrhc = "lower right-hand corner"
};

class Rectangle {
    // ...
private:
    std::tr1::shared_ptr<RectData> pData;
};

class Rectangle {
public:
    // ...
    Point& upperLeft() const {
        return pData->ulhc;
    }
    Point& lowerRight() const {
        return pData->lrhc;
    }
};

Point coord1(0.0);
Point coord2(100, 100);
const Rectangle rec(coord1, coord2);

// rec is const, but rec.upperLeft() is Point&, and
// can be changed
rec.upperLeft().setX(50);

class Rectangle {
public:
    // ...
    const Point& upperLeft() const {
        return pData->ulhc;
    }
    const Point& lowerRight() const {
        return pData->lrhc;
    }
};

class GUIObject {
    // ...
};

// 以 by value方式返回, 一定要声明为const, 可以防止不小心被'='赋值
const Rectangle boundingBox(const GUIObject& obj);

// 用户可能会如下使用, 因为临时对象的产生,所以会导致dangling handles
GUIObject* pgo;
// ...
const Points* pUpperLeft = &(boundingBox(*pgo).upperLeft());