effective c++读书笔记4

设计class犹如设计type

新type的对象应该如何被创建和销毁？：这会影响到你的class的构造函数和析构函数以及内存分配函数和释放函数的设计。

对象的初始化和对象的赋值有什么样的区别？这答案决定你的构造函数和赋值操作符的行为，以及其间的差异。很重要的是别混淆了“初始化”和“赋值”，因为它们对应不同的函数调用。

新type的对象如果被passed by value（以值传递），意味着什么？记住，copy构造函数用来定义一个type的pass-by-value该如何实现。

什么是新type的“合法值”？对于class的成员变量而言，通常只有某些数值集是有效的。那些数值决定了你的class必须维护的约束条件，也就决定了你的成员函数必须进行的错误检查工作，它也影响函数抛出的异常、以及函数异常明细列。

你的新type需要配合某个继承体系吗？如果你继承自某些既有的classes，你就受到那些classes的设计的束缚，特别是受到“它们的函数是virtual或non-virtual”的影响。如果你允许其他classes继承你的class，那会影响你所声明的函数--尤其是析构函数，是否为virtual。

你的新type需要什么样的转换？如何你允许类型T1之物被隐式转换为类型T2之物，就必须在class T1内写一个类型装换函数或者在class T2内写一个non-expliccit-noe-argument(可被单一实参调用)的构造函数。如果你允许explicit构造函数存在，就得写出专门负责执行转换的函数，且不得为类型转换操作符或non-explicit-one-argument构造函数。

什么样的操作符合函数对此新type而言是合理的？这个取决于你将为你的class声明哪些函数。

什么样的标准函数应该驳回？那些正是你必须声明为private者。

谁该采用新type的成员？这个跟设计成员函数有关。你可以决定哪个成员为private，哪个为protected，哪个为private。

你的新type有多么一般化？或许你其实并非定义一个新type，而是定义一整个types家族。果真如此你就不应该定义一个新class，而是定义一个新的class template。

你真的需要一个新的type吗？如果只是定义新的派生类以便为既有的class添加机能，那么说不定单纯定义一或多个非成员函数或模板，更能够达到目标

宁以pass-by-reference-to-const替换pass-by-value

传值调用会造成代码执行效率低

例如：

class Person
{
public:
    Person();
    virtual ~Person();
private:
    std::string name;
    std::string address;
};
 
class Student :public Person
{
public:
    Student();
    ~Student();
private:
    std::string schoolName;
    std::string schoolAddress;
};
 
bool validateStudent(Student s);


int main()
{
    Student plato;          //定义Student对象
    validateStudent(plato); //传值调用
    return 0;
}

可以看下传值过程中做了那些事情？

①执行6次构造函数：plato传入进函数的时候，需要调用1次Student的构造函数，Student构造函数执行前需要先构造Person ，因此还会调用1次Person类的构造函数。Person和Student两个类中共有4个string成员变量，因此还需要调用string的构造函数4次
②执行6次析构函数：当函数执行完成之后，传入validateStudent函数中的plato副本还需要执行析构函数，那么执行析构函数的时候分别要对应执行6次析构函数（Student+Person+4个string成员变量）

改进：

这种传递方式的效率高得多:没有任何构造函数或析构函数被调用，因为没有任何新对象被创建

以by reference方式传递参数也可以避免slicing(对象切割)问题

例如：

class Window
{
public:
    std::string name()const;
    virtual void display()const;
};
 
class WindowsWithScrollBars :public Window
{
public:
    virtual void display()const;
};
 
void printNameAndDisplay(Window w)
{
    std::cout << w.name();
    w.display();
}

当执行下面代码时：

int main()
{
    WindowsWithScrollBars wwsb;
    printNameAndDisplay(wwsb);  //WindowsWithScrollBars对象会被截断
    return 0;
}

因为printNameAndDisplay函数的参数为Window类型，所以即使我们传入的是WindowsWithScrollBars类型的对象，那么这个对象会被截断，只取WindowsWithScrollBars对象中属于基类（Window）的内容，然后传递给函数
因此被截断之后，不论如何调用，printNameAndDisplay函数中调用的display函数总是Window的display虚函数，不会是WindowsWithScrollBars中的display虚函数。因为多态只会发生在基类指针/引用指向于派生类的情况下，此处没有指针/引用

改进：

对于内置类型建议传值调用

C++编译器的底层，是把引用以指针的形式实现，因此引用传递就是指针的传递

如果你使用的对象属于内置类型（例如int），内置类型都相当小，传值调用往往比引用传递的效率高些

这条规则在STL的迭代器和函数对象中都被广泛引用

请记住：

1.尽量以pass-by-reference-to-const替换 pass-by-value。前者通常比较高效，并可避免切割问题(slicing problem)。
2. 以上规则并不适用于内置类型，以及STL的迭代器和函数对象。对它们而言，pass-by-value往往比较适当。

必须返回对象时，别妄想返回其reference

自己要记住，任何时候看到一个reference声明式，你都应该立刻问自己,它的另一个名称是什么？

看下面一段代码：我们有一个用来变现有理数的class，内含一个函数用来计算两个有理数的乘积

下面的那一段代码是合理的：

但如果返回值是引用，会存在什么问题呢？看下面的一些调用：

最后的那段代码存在问题，期望“原本就存在一个其值为3/10的Rational对象”并不合理。如果operator*要返回一个reference指向如此数值，它必须自己创建那个Rational对象。

方案1：

stack 空间或在 heap空间创建对象，例如：

friend const Rational&
    operator*(const Rational& lhs, const Rational& rhs)
{
    Rational result(lhs.n*rhs.n, lhs.d*rhs.d);
    return result; //虽然编译器不报错，但是逻辑上是错误的
}

原因：由于result是局部对象，函数结束之后局部对象（栈空间）就释放了，引起返回其引用是无效的，也就是说该函数返回了一个已经无效的对象的引用。

friend 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; //相当于operator*(operator*(x,y),z);

原因：在函数内，我们在堆上申请了一个对象，然后返回对象的引用，虽然函数结束之后对象仍存在，我们使用起来不会出错，但是这个函数内部建立的对象我们无法释放（因为我们无法获取其指针，不能进行delete操作）。因此会造成内存泄漏

方案2：返回一个静态局部变量

例如：

friend const Rational&
    operator*(const Rational& lhs, const Rational& rhs)
{
    static Rational result; //静态局部变量
 
    //result=...; 将lhs乘以rhs，然后将结果保存在result中
 
    return *result; //虽然编译器不报错，但是逻辑上是错误的
}

再看下面的代码：先不管多线程安全的问题

bool operator==(const Rational& lhs,const Rational& rhs);
int main()
{
    Rational a,b,c,d;
    //...
    if((a*b)==(c*d)){ //此if永远为真，因为operator*返回的都是同一个对象的引用

    }
    else{
    }
}

表达式((a*b) =- (c*d))总是被核算为true，不论a, b, c和d的值是什么!

原因：在operator== 被调用前，已有两个operator*调用式起作用，每一个都返回reference指向operator*内部定义的static Rational对象。因此operator==被要求将“operator*内的 static Rational对象值”拿来和“operator*内的 staticRational对象值”比较，那么当我们每回调用operator*函数的时候，每回返回的都是同一个静态局部变量的引用。

请记住：

绝不要返回pointer或reference指向一个local stack对象，或返回reference指向一个heap-allocated对象，或返回pointer或reference指向一个local static对象而有可能同时需要多个这样的对象。

宁以non-member，non-friend替换member函数

象有个class用来表示网页浏览器。这样的 class可能提供的众多函数中，有一些用来清除下载元素高速缓存区(cache of downloaded elements)、清除访问过的URLs的历史记录等，例如：

许多用户会想一整个执行所有这些动作，因此webBrowser也提供这样-一个函数：

那么是成员函数好还是非成员函数呢？

解释：

1.提供non-member函数可允许对webBrowser 相关机能有较大的包裹弹性( packaging flexibility)，而那最终导致较低的编译相依度，增加 webBrowser的可延伸性。如果某些东西被封装，它就不再可见。愈多东西被封装，愈少人可以看到它。而愈少人看到它，我们就有愈大的弹性去变化它。
2.第二件值得注意的事情是,只因在意封装性而让函数“成为class 的 non-member”，并不意味它“不可以是另一个class 的member”

namespace和 classes不同，前者可跨越多个源码文件而后者不能。一个像webBrowser这样的class可能拥有大量便利函数，某些与书签(bookmarks>有关，某些与打印有关，分离它们的最直接做法就是将书签相关便利函数声明于一个头文件，将cookie相关便利函数声明于另一个头文件，以此类推。

这正是C++标准程序库的组织方式。

以此种方式切割机能并不适用于class成员函数，因为一个class必须整体定义，不能被分割为片片段段。一小部分。

将所有便利函数放在多个头文件内但隶属同一个命名空间，意味客户可以轻松扩展这一组便利函数。他们需要做的就是添加更多non-member non-friend函数到此命名空间内。

请记住：

宁可拿non-member non-friend 函数替换member函数。这样做可以增加封装性、包裹弹性（packaging flexibility）和机能扩充性

若所有参数皆需类型转换，请为此采用non-member函数

先看一段关于类型转换的代码：

如果这样去使用代码：

int main()
{
    Rational oneEighth(1, 8);
    Rational oneHalf(1, 2);
 
    Rational result = oneHalf*oneEighth;//正确
    result = result*oneEighth;          //正确
 
    return 0;
}

这里将operator*（）写成了成员函数，支持两个对象直接相乘

const Rational operator* (const Rational& rhs)const{*******};

由于可以进行隐式的类型转换，因此我们还可以进行下面的有理数相乘

int main()
{
    Rational oneHalf(1, 2);
 
    //2隐式转换为Rational类型
    //然后下面代码等价于result=oneHalf.operator*(2) 
    Rational result = oneHalf * 2; 
 
    return 0;
}

在上面的代码中，编译器知道你正传递一个int对象，但是operator*()需要的是Rational，因此它调用Rational构造函数并赋予你所提供的int，就可以构造出一个临时的Rational对象,但是如果这样使用：下面是错误的代码

  Rational oneHalf(1, 2);
 
   //代码相当于2.operator*(oneHalf)
   Rational result = 2 * oneHalf; //错误

oneHalf是一个内含operator*函数的class的对象，所以编译器调用该函数。然而整数2 并没有相应的class，也就没有operator*成员函数。编译器也会尝试寻找可被以下这般调用的non-member operator*（也就是在命名空间内或在global作用域内）:

从上面的例子我们可以看到，如果operator*()为成员函数，在某些情况下即使存在隐式转换也不能成功执行。只有当参数被列于参数列(parameter list）内，这个参数才是隐式类型转换的合格参与者。地位相当于“被调用之成员函数所隶属的那个对象”—--即 this对象—一的那个隐喻参数，绝不是隐式转换的合格参与者。

例如：

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

那么下面的调用都是正确的：

int main()
{
    Rational oneEighth(1, 8);
    Rational oneHalf(1, 2);
 
    Rational result;
 
    result = oneHalf*oneEighth;
    result = result*oneEighth;    
 
    result = oneHalf * 2;
    result = 2 * oneHalf;
    result = 2 * oneHalf*2;
    result = oneHalf * 2 * oneHalf;
 
    return 0;
}

请记住：

1.如果你需要为某个函数的所有参数（包括被this这指针很所指的那个隐喻参数）进行类型转换，那么这个函数必须是个non-member
2.如果一个函数不建议声明为member版本，那么就将该函数声明为non-member版本，而不是friend函数