读书笔记五

• 尽可能的延后变量定义式出现的时间
  • 　　产生问题：定义一个变量，其含有构造函数和析构函数。那么当代码运行到它的时候，就必须会产生构造成本和析构成本，如果这个变量最终未使用，那么就是浪费了资源空间，所以应该尽可能的延后变量定义式的时间
  • 　　解决方法：不只是应该延后变量的定义，知道非得使用该变量的前一刻为止，甚至应该尝试延后这份定义知道能够给他初值实参为止。这样可以避免构造析构函数和默认构造函数
  • 　　对于循环体中的变量：一般定义在循环体外部所需要的开销要少的多，不是定义在循环体中的局部变量
• 尽量少做转型动作
  • 　　C++的四种转型手法：http://www.cnblogs.com/jerry19880126/archive/2012/08/14/2638192.html
  • 　　如果可以尽量避免转型特别是在注重效率的代码中避免dynamic_casts,如果有个动作需要转型，试着写一个无需转型的动作代替
  • 　　如果非得转型，试着将它藏在某个函数之后，客户可以随后调整该函数，而不是必须的将它放在代码中
  • 　　宁可使用新型的转型方式也不要去使用旧的转型方式
• 避免返回handles指向对象内部成分
  • 　　问题产生：

    

    class point{
        point(int x,int y);
        ...
        void setx(int newval);
        void sety(int newval);
    };
    struct rectdata{
        point u;
        point l;
    };
    class rectangle{
    public:
        point & upperleft()const{return pdata->u;}
        point & upperright()const{return pdata->l;}
    private:
        std::str1::shared_ptr<rectdata> pdata;
    };
    int main()
    {
        point coord1(0,0);
        point coord2(100,100);
        const rectangle rec(coord1,coord2);
        rec.upperleft().sety(50);
    }
    这里我们能够通过最后的这个函数去修改private成员的值，那么私有成员变量就不是私有的了而是public的。
    最根本的原因是由于upperleft函数返回的是一个reference 指向rectangle对象的，所以私有变量就不是私有的了，失去了安全性和封装性

  • 　　reference，指针，迭代器都是handles中的一类，都是用来取得某个对象的一种工具，而返回代表一个内部对象的handles，他们很有可能修改成员变量和const成员函数，降低了类的封装性
    • 　　解决方法：让函数加上const，这样就不能修改值，只能读取值了。

      const point & upperleft()const{return pdata->u;}
          const point & upperright()const{return pdata->l;}

      但是这又会产生一个新的问题，就是point&返回的对象可能发生它所指的东西不存在了。这个例子感觉比价深啊。详见书P126

  • 　　避免返回handles（包括reference，指针，迭代器）指向对象内部。可以增加封装性，帮助const成员函数的行为像个const，并发生虚掉号码牌的可能性降至最低。
• 为异常安全努力是值得的
  • 　　问题的产生

    class prettymenu{
    public:
        void changebackground(std::instream & imgsrc);
    private:
        Mutex mutex;
        Image *bgimage;
        int imagechanges;
    };
    void prettymenu::changebackground(std::istream&imgsrc){
        lock(&mutex);
        delete bgimage;
        ++imagechanges;
        bgimage=new image(imgsrc);//这个异常会导致unlock无法调用，资源泄漏；new异常原互斥器没有解锁，然而imagechanges还是++了，但是并没有一个新的image产生，数据被破坏了
        unlock(&mutex);
    }
    //这个例子没有遵守异常安全的两个条件
    //①不泄露任何的资源，②不允许数据的破坏//unlock的资源泄漏问题可以很容易解决：利用lock class类就能解决，所以把最后一句删除即可。

  • 　　解决方法：
    • 　　异常安全提供三个保证：
      • 　　强烈保证：如果异常被抛出了，程序中的所有东西仍然保持有效状态，任何数据结构或者对象会被破坏，抛出异常前后并没有发生变化。
      • 　　基本保证：异常抛出，程序状态不改变。函数成功，就是完全成功，函数失败，程序回复到调用函数之前的状态。
      • 　　承诺绝不抛出异常，总是能够完成要承诺完成的事情。
    • 　　一般而言，只能够做到第一条和第二条。一个好的操作方法是：pimpl idiom方法：copy and swap，将所有隶属对象的数据从原对象放进另一个对象内，然后赋予原对象一个指针，指向那个所谓的实现对象（副本）。实现所有操作后在进行swap，这个提供的是强烈保证

      struct PMImpl{
          std::tr1::shared_ptr<image> bgimage;
          int imagechanges;
      };
      class prettymenu{
      public:
          void changebackground(std::instream & imgsrc);
      private:
          Mutex mutex;
          std::tr1::shared_ptr<PMImpl> pimpl;//防止内存泄漏
      };
      void prettymenu::changebackground(std::istream&imgsrc){
          lock m1(&mutex);//获得mutex的副本数据
          str::tr1::shared_ptr<PMImpl> pnew(new PMImpl(*pimpl));//
          pnew->bgimage.reset(new image(imgsrc));//修改副本
          ++pnew->imagechanges;
      
          swap(pimpl,pnew);//置换数据，释放mutex
      }

    • 　　让函数具备异常安全性的方法步骤：①以对象管理资源：防止内存泄漏。②挑选三个异常安全保证中的一个实施与函数中，保证异常安全性，选择上应该选择第二个。
• 透彻了解inlining的里里外外（内联函数）
  • 　　inline函数的表示
    • 　　隐式的:声明在类体内部，有些friend也可以是inline函数

      class person{
      public:
          int age()const{return theage;}
      private:
          int theage;
      };

    • 　　显示的，在函数前面加上inline关键字
  • 　　inline函数通常都是置于头文件中的，在编译过程中进行inlining，必须知道函数本体长什么样子，才能将函数所有本体代码替换执行的inline函数。所以inlining一般都是编译期的行为。
  • 　　由于inline是在编译期执行的，而虚函数时在运行的时候才将该函数具体化执行的。所以凡是虚函数一般都不是inline函数。所以，一个表面上看起来inline‘的函数是否真的inline，取决于环境，主要屈居于编译器。如果无法inline，会发出一个警告信息。
  • 　　class类中的构造函数和析构函数一般是不能使用inline的，因为成本开销可能非常的大，但是表面上看不到它的开销，所以不适合使用。
  • 　　将大多数inlining限制在小型的，频繁调用的函数上。不要只因为function出现在头文件，就将他们声明为inline。
• 将文件间的编译依存关系降至最低
  • 　　

。