1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

class Date {
public:
    Date(int month, int day, int year);
};

// v2 with builder
struct Day {
    explicit Day(int d): val(d){}
int val;
};
struct Month {
    explicit Month(int d): val(d){}
int val;
};
struct Year {
    explicit Year(int d): val(d){}
int val;
};
class Date {
public:
    Date(const Month&, const Day&, const Year&);
};

Date d(Month(12), Day(31), Year(2020));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

class Person {
public:
    Person();
    virtual ~Person();
private:
    std::string name;
    std::string addr;
};
class Student : public Person {
public:
    Student();
    ~Student();
private:
    std::string schoolName;
    std::string className;
};

bool validate(Student s);

// 一次Student copy构造函数、一次Person copy构造函数
// 四次string copy构造函数 => 六次析构函数
int main() {
    Student plato;
    bool ok = validate(plato);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

class Window {
public:
    std::string name() const;
    virtual void display() const;
};

class CircleWindow : public Window {
public:
    virtual void display() const;
};

// 在printName函数内，不论传递过来的对象原本是什么类型
// 参数w总是一个Window对象 (调用的总是Window::display)
void printName(Window w) {
    std::cout << w.name();
    w.display();
}

// 引用传递没有上述问题
void printName(const Window& w) {
    std::cout << w.name();
    w.display();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

class Rational {
public:
    Rational(int numerator = 0, int denominator = 1);
private:
    int n, d;
    friend const Rational operator*(const Rational& lhs, const Rational& rhs);
};

// 函数返回一个reference指向result，
// 但result是local对象，在函数退出前就被销毁了。
const Rational& operator*(const Rational& lhs, const Rational& rhs) {
    Rational result(lhs.n*rhs.n, lhs.d*rhs.d); // bad code
    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;
// 同一个语句内调用了两次operator*，却没有合理的办法调用delete
w = x * y * z; // operator*(operator*(x,y), z)

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

bool operator==(const Rational& lhs, const Rational& rhs);
Rational a, b, c, d;

if ((a*b) == (c*d)) {
    // always return true
}
if (operator==(operator*(a,b), operator*(c,d))) {
    // 中间返回相同的result对象，所以始终返回true
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

class WebBrowser {
public:
    void clearCache();
    void clearHistory();
    void removeCookies();
};

// member function
class WebBrowser {
public:
    ...
    void clearEverything();
};

// non member function
void clearBrowser(WebBrowser &wb) {
    wb.clearCache();
    wb.clearHistory();
    wb.removeCookies();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

Rational oneHalf(1, 2);

// 隐式类型转换
Rational result = oneHalf * 2; // ok
result = 2 * oneHalf; // error

// non member
const Rational operator*(const Rational& lhs, const Rational& rhs) {
    return Rational(lhs.numerator() * rhs.numerator(), lhs.denominator() * rhs.denominator());
}