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函数

  • 2
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值