Effective C++ 学习笔记（四）设计与声明

2021/4/19 22:28:31

编程Tag： type const class 笔记 C++ Effective swap std Rational

本文主要是介绍Effective C++ 学习笔记（四）设计与声明，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

title: Effective C++ 学习笔记（四）设计与声明
date: 2021-03-15 09:20:42
tags:

  • cpp

参考书籍《Effective C++：改善程序与设计的 55 个具体做法（第三版）》

18. 让接口容易被正确使用，不易被误用

  • 为什么要？

    • 接口被误用
    class Date {
public:
    Date(int month, int day, int year);
}

    • 接口的不一致性对开发人员造成的心理和精神上的摩擦与争执。

    • 任何接口如果要求客户必须记得做某些事情，就是有着“不正确使用”的倾向，因为客户可能会忘记做那件事。如下面例子，就要求用户使用智能指针，否则当用户忘记delete就会造成资源泄露

      Investment* createInvestment();

    • cross-DLL problem：对象在动态连接程序库（DLL）中被 new创建，却在另一个 DLL 内被 delete销毁。在许多平台上，这一类“跨 DLL 之new/delete成对运用”会导致运行期错误。

  • 示例

    • 使用外覆类型（wrapper types）限制参数
    struct Day {
    ...
}
struct Month {
    ...
}
struct Year {
    ...
}

class Date {
public:
    Date(const Month& m, const Day& d, const Year& y);
}
    • 使用函数获取对象
    class Month {
public:
    static Month Jan() {return Month(1);}
    static Month Feb() {return Month(2);}
    ...
private:
    explicit Month(int m);
};

Date d(Month::Mar(), ...);

    • 除非有好理由，否则应该尽量令你的types的行为与内置types一致，提供行为一致的接口

    • 在接口设计时，将返回指针接口用智能指针作为返回值,tr1::shared_ptr有一个特别好的性质是：它会自动使用它的“每个指针专属的删除器”，因而消除另一个潜在的客户错误：所谓的 "cross-DLL problem"。

      std::tr1::shared_ptr<Investment> createInvestment();

    ■ 好的接口很容易被正确使用，不容易被误用。你应该在你的所有接口中努力达成这些性质。

    ■ “促进正确使用”的办法包括接口的一致性，以及与内置类型的行为兼容。

    ■ “阻止误用”的办法包括建立新类型、限制类型上的操作，束缚对象值，以及消除客户的资源管理责任。

    ■ tr1：：shared_ptr支持定制型删除器（custom deleter）。这可防范DLL问题，可被用来自动解除互斥锁（mutexes；见条款14）等等。

19. 设计class犹如设计type

  • 为什么要？

    • C++就像在其他OOP（面向对象编程）语言一样，当你定义一个新class，也就定义了一个新type。身为C++程序员，你的许多时间主要用来扩张你的类型系统（type system）。这意味你并不只是class设计者，还是type设计者。重载（overloading）函数和操作符、控制内存的分配和归还、定义对象的初始化和终结……全都在你手上。因此你应该带着和“语言设计者当初设计语言内置类型时”一样的谨慎来研讨class的设计。

  • 示例

    • 想设计一个好的class，需要回答下面问题：
      1. 新type的对象应该如何被创建和销毁？
      2. 对象的初始化和对象的赋值该有什么样的差别？
      3. 新type的对象如果被passed by value（以值传递），意味着什么？
      4. 什么是新type的“合法值”？
      5. 你的新type需要配合某个继承图系（inheritance graph）吗？
      6. 你的新type需要什么样的转换？
      7. 什么样的操作符和函数对此新 type 而言是合理的？
      8. 什么样的标准函数应该驳回？
      9. 谁该取用新 type 的成员？
      10. 什么是新type的“未声明接口”（undeclared interface）？
      11. 你的新type有多么一般化？
      12. 你真的需要一个新type吗？

    ■ Class的设计就是type的设计。在定义一个新type之前，请确定你已经考虑过本条款覆盖的所有讨论主题。

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

  • 为什么要？

    • pass-by-value会花费很多成本用来copy
      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);
// 当调用这个函数函数，会产生6次copy
// 一次Student copy，一次Person copy，四次string copy
      • slicing 对象切割问题
      class Window {
public:
    virtual void display() const;
};
class WindowWithScrollBars: public Window {
public:
    virtual void display() const;
}
void printNameAndDisplay(Window w)
{
    w.display();
    ...
}
WindowWithScrollBars wwsb;
printNameAndDisplay(wwsb);  // 将使用Window的display()!

  • 示例

    • 使用pass by reference to const。声明为const是必要的，因为不这样做的话调用者会忧虑 validateStudent 会不会改变他们传入的那个Student。
      bool vaildateStudent(const Student& s);
    • 使用pass by reference to const的方式传递参数解决切割（slicing）问题
      void printNameAndDisplay(const Window& w)
{
    w.display();
}

WindowWithScrollBars wwsb;
printNameAndDisplay(wwsb);  // ✔可以使用WindowWithScrollBars的display()
    • 当使用内置类型、STL的迭代器和函数对象时，可以认为pass by value花费成本不大，甚至往往比pass by reference更高效。因为references往往以指针实现出来，因此pass by reference通常意味真正传递的是指针。

    ■ 尽量以pass-by-reference-to-const替换pass-by-value。前者通常比较高效，并可避免切割问题（slicing problem）。

    ■ 以上规则并不适用于内置类型，以及 STL 的迭代器和函数对象。对它们而言，pass-by-value往往比较适当。

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

  • 为什么要？

    • 返回reference对象前，可将对象在stack(局部变量)或heap(使用new)中构建。在stack(局部变量)中构建时，局部变量将在函数退出前被销毁，将返回一个已经被销毁的对象的引用！

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

    • 在heap(使用new)中构建时，返回的对象极易被忘记delete!

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

    ■ 绝不要返回pointer或reference指向一个local stack对象，或返回reference指向一个heap-allocated对象，或返回pointer或reference指向一个local static对象而有可能同时需要多个这样的对象。条款 4 已经为“在单线程环境中合理返回 reference指向一个local static对象”提供了一份设计实例。

22. 将成员变量声明为private

  • 为什么要？

  • 示例

    ■ 切记将成员变量声明为private。这可赋予客户访问数据的一致性、可细微划分访问控制、允诺约束条件获得保证，并提供class作者以充分的实现弹性。

    ■ protected并不比public更具封装性。

23. 宁以non-member、non-friend替换member函数

  • 为什么要？

    • member函数会破坏class中private成员的封装性

  • 示例

    • 对于C++最佳做法是，将non-member函数和class放到同一个namespace中
      namespace WebBrowserStuff{
    class WebBrowser { ... };
    void clearBrowser (WebBrowser& wb);
}
    • 对于只能将函数放到class的语言，可以将函数放到另一个class中(通常就是某某Utils类)
      // java
class WebBrowserUtils {
    public static void clearBrowser (WebBrowser wb);
};

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

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

  • 为什么要？

    • 只有当参数被列于参数列（parameter list）内，这个参数才是隐式类型转换的合格参与者。
      class Rational {
public:
    Rational (int numerator = 0, int denominator = 1);  // non-explicit!
    int numerator() const;
    int denominator() const;

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

private:
    int numerator;
    int denominator;
};

Rational oneHalf(1, 2);
Rational result = oneHalf * 2;  
// 隐式转换：Rational result = oneHalf * Rational(2); 
// 调用 oneHalf.operator(Rational(2));

result = 2 * oneHalf;   // 错误！
// 尝试operator*(2， oneHalf);

  • 示例

    • 让operator*成为一个non-member函数
      class Rational {
    ...
};

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

    ■ 切记将成员变量声明为private。这可赋予客户访问数据的一致性、可细微划分访问控制、允诺约束条件获得保证，并提供class作者以充分的实现弹性。

    ■ 如果你需要为某个函数的所有参数（包括被 this指针所指的那个隐喻参数）进行类型转换，那么这个函数必须是个non-member。

25. 将成员变量声明为private

  • 为什么要？

    • 当std::swap对于你的对象来说效率不够高时，比如pimpl(pointer to implementation)对象，swap只需要交换两个指针便可。std::swap的典型实现：
      namespace std {
    template<typename T>
    void swap(T &a, T &b)
    {
        T temp(a);
        a = b;
        b = temp;
    }
}
    • pimpl:
      class WidgetImpl {
private:
    int a, b, c;
    std::vector<double> v;
};

class Widget {
private:
    WidgetImpl* pImpl;
};

  • 示例

    • 对于普通类，重写特化std::swap
      class Widget {
public:
    void swap(Widget& other)
    {
        using std::swap;
        swap(pImpl, other.pImpl);
    }
};
namespace std {
    template<>
    void swap<Widget>(Widget& a, Widget& b) // 特化std::swap
    {
        a.swap(b);
    }
}
    • 对于模板类(template class)，添加一个non-member的swap函数并将其与类放到同一命名空间(namespace)下。
      namespace WidgetStuff{
    template<typename T>
    class Widget { ... };

    template<typename T>
    void swap(Widget<T>& a,Widget<T>& b)
    {
        a.swap(b);
    }
}

■ 当std：：swap对你的类型效率不高时，提供一个swap成员函数，并确定这个函数不抛出异常。

■ 如果你提供一个member swap，也该提供一个non-member swap用来调用前者。对于classes（而非templates），也请特化std：：swap。

■ 调用swap时应针对std：：swap使用using声明式，然后调用swap并且不带任何“命名空间资格修饰”。

■ 为“用户定义类型”进行std templates全特化是好的，但千万不要尝试在std内加入某些对std而言全新的东西。



这篇关于Effective C++ 学习笔记（四）设计与声明的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！


相关编程文章

更多>
本站官方QQ
官方QQ:
23002807

沪ICP备2023033072号-1

     

扫一扫关注最新编程教程