本文主要是介绍【Effective C++】第四章 设计与声明(上),希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!
第四章 设计与声明
条款18:让接口容易被正确使用,不易被误用
考虑客户可能做出什么样的错误。
除非有好理由,否则应该尽量令你的types的行为与内置types一致。
tr1::shared_ptr有一个特别好的性质是:它会自动使用它的“每个指针专属的删除器”,因而消除另一个潜在的客户错误:所谓的“cross-DLL problem”。这个问题发生于“对象在动态连接程序库(DLL)中被new创建,却在另一个DLL内被delete销毁”。在许多平台上,这一类“跨DLL之new/delete成对运用”会导致运行期错误。tr1::shared_ptr没有这个问题,因为它缺省的删除器是来自“tr1::shared_ptr诞生所在的那个DLL”的delete。
请记住:
好的接口很容易被正确使用,不容易被误用。你应该在你的所有接口中努力达成这些性质。
“促进正确使用”的办法包括接口的一致性,以及与内置类型的行为兼容。
“阻止误用”的办法包括建立新类型、限制类型上的操作,束缚对象值,以及消除客户的资源管理责任。
tr1::shared_ptr支持定制删除器。这可防范DLL问题,可被用来自动解除互斥量等等。
条款19:设计class犹如设计type
如何设计高效的classes呢?首先你必须了解面对的问题。几乎每一个class都要求面对以下提问,而你的回答往往导致你的设计规范:
新type的对象应该如何被创建和销毁?构造函数和析构函数以及内存分配函数和释放函数的设计。
对象的初始化和对象的赋值该有什么样的差别? 决定于构造函数和赋值操作符的行为,以及其间的差异。
新type的对象如果被passed by value(以值传递),意味着什么? copy构造函数用来定义一个type的passed by value该如何实现。
什么是新type 的“合法值”? 对class的变量而言,通常只有某些数值集是有效的。那些数值集决定了你的class必须维护的约束条件,也就决定了你的成员函数必须进行错误检查工作。它也影响函数抛出异常、以及函数异常明细列。
你的新type需要配合某个继承图系(inheritancegraph)吗? 如果你的class是从别的基类继承下来的,那么会受到基类的束缚。反之,如果你允许其他classes继承你的class,会影响你声明的函数尤其是析构函数是否是virtual。
你的新type需要声明样的转换?显示or隐式。
什么样的操作符和函数对此新type而言是合理的? 这个问题答案决定你将为你的class声明哪些函数。其中某些该是member函数,某些则否。
什么样的标准函数应该驳回? 声明为private者。
谁该取用新type的成员?
什么是新type的“未声明接口”(undeclared interface)
你的新type有多么一般化? 并非定义一个新type,而是定义一个types家族,应该定义为class template。
你真的需要一个新type吗? 如果只是定义新的derived class以便为既有的class添加机能,那么说不定单纯定义一个或多个non-member函数或templates,更能够达到目标。
请记住:
Class的设计就是type的设计。在定义一个新的type之前,请确定你已经考虑过本条款覆盖的所有讨论主题。
条款20:宁以pass-by-reference-to-const替代pass-by-value
1、缺省情况下C++以by value方式传递对象至函数。除非你另外指定,否则函数参数都是以实际实参的副本为初值,而调用端所获得的亦是返回值的一个副本。这些副本由对象的拷贝构造函数产生,这可能使得pass by value成为昂贵的操作。
using namespace std;class Person {public: Person() { cout << "Person()" << endl; } Person(const Person& p) :name(p.name), address(p.address) { cout << "Person copy construct" << endl; } ~Person() { cout << "~Person()" << endl; }private: string name; string address;};class Student :public Person {public: Student() { cout << "Student()" << endl; } Student(const Student& s):Person(s), schoolName(s.schoolName), schoolAddress(s.schoolAddress) { cout << "Student copy construct" << endl; } ~Student() { cout << "~Student()" << endl; }private: string schoolName; string schoolAddress;};//pass-by-valuebool validateStudent(Student s) { return true;}int main() { Student s; cout << "------------------" << endl; bool b = validateStudent(s); return 0;}
运行结果:
Person()Student()------------------Person copy constructStudent copy construct~Student()~Person()~Student()~Person()
说明:从运行结果我们可以对validateStudent函数的参数的传递成本是“一次Student拷贝构造函数调用和一次Student析构函数调用”。其实远不止这些,因为上述两个类都含有两个string,他们也相应的调用拷贝构造函数,就是说四次string拷贝构造动作,还有四次析构函数。所以最终结果是以by value方式传递一个Student对象会导致一次Student拷贝构造函数、一次Person拷贝构造函数、四次string拷贝构造函数。当函数内的那个Student副本被销毁时,都要调用对应的析构函数。因此,以by value方式传递一个Student对象总体成本是“六次构造函数和六次析构函数”。
避免构造和析构的方法,就是pass by reference-to-const。
bool validateStudent(const Student& s){ return true; }
运行结果:
Person() Student() ------------------ ~Student() ~Person()
说明:这种传递方式的效率高得多:没有任何构造函数或析构函数被调用,因为没有任何新对象被创建。将它声明为const是必要的,防止传入的Student对象被改变。
2、以by reference方式传递参数可以避免slicing(对象切割)问题。当一个derived class对象以by value方式传递并视为一个base class对象,base class的copy构造函数会被调用,而“造成此对象的行为像个derived class对象”的那些特化性质全被切割掉了,仅仅留下一个base class对象。
以by reference方式传递参数可以避免切割问题。如果窥视c++编译器的底层,references往往以指针实现出来,因此pass by reference通常意味着这真正传递的是指针。对内置类型(例如int)而言,pass by value或pass by reference-to-const时,选择pass by value并非没有道理。这个忠告也适用于STL的迭代器和函数对象,因为习惯上它们都被设计为pass by value。
slicing(对象切割)例子:
using namespace std;class Window {public: virtual void display()const { cout << "window display()" << endl; }};class WindowWithScrollBars :public Window {public: virtual void WindowWithScrollBars::display() const { cout << "WindowWithScrollBars display()" << endl; }};void pintNaandWind(Window w) { w.display();}int main() { WindowWithScrollBars wwsb; pintNaandWind(wwsb); return 0;}
输出结果:
window display()
说明:从运行结果可以看出,我们得到的是Window的display(),而我们本想得到WindowWithScrollBars的display()。它调用的是window对象的display(),而不是子类的,因为pintNaandWind中的参数传递是by value,WindowWithScrollBars的所有特化信息都会被切除。解决办法是 pass by reference-to-const。
void pintNaandWind(Window& w){ w.display(); }
运行结果:
WindowWithScrollBars display()
请记住:
尽量以pass-by-reference-to-const替换pass-by-value。前者通常比较高效,并可避免切割问题(slicingproblem)。
以上规则并不适合与内置类型,以及STL的迭代器和函数对象。对它们而言,pass-by-value往往比较适合。
条款21:必须返回对象时,别妄想返回其reference
在坚定追求pass-by-value(传值)的纯度中,一定会犯下一个致命的错误:开始传递一些references执行其实并不存在的对象。这可不是什么好事。任何时候看到一个reference声明式,都必须立刻问自己,它的另一个名称是什么?因为它一定是某物的另一个名称。
函数创建新对象的途径有二:在栈空间或在堆空间创建。
在stack空间创建对象例子:
class Rational{ public: Rational(int numerator, int denominator); ... private: int n, d; friend const Rational operator*(const Rational& lhs, const Rational& rhs); }; const Rational& operator*(const Rational& lhs, const Rational& rhs){ Rational result(lhs.n * rhs.n, lhs.d * rhs.d); return result; }
你可以拒绝这种做法,因为你的目标是避免调用构造函数,而result却必须像任何对象一样地由构造函数构造起来。更严重的是:这个函数返回一个reference指向result,但result是个local对象,而local对象在函数退出前就被销毁了。
在heap空间创建对象例子:
const Rational& operator*(const Rational& lhs, const Rational& rhs){ Rational* result = new Rational(lhs.n * rhs.n, lhs.d * rhs.d); return result; }
在堆上构造一个对象,并返回reference指向它。会出现问题:谁该对着被你new出来的对象实施delete呢?还有一个问题:如果有计算:Rational result = xyz,其中x、y、z都是Rational类型的对象,此时就会产生内存泄露的问题。因为同一语句内调用了两次operator*,因而使用两次new,也就需要两次delete,但却没有合理的办法让` operator * 使用者进行那些delete调用,因为没有办法取得operator*返回的references背后隐藏的那个指针。
请记住:
绝不要返回pointer或reference指向一个local stack对象,或返回reference指向一个heap-allocated对象,或返回pointer或reference指向一个local static对象而有可能同时需要多个这样的对象。
这篇关于【Effective C++】第四章 设计与声明(上)的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!