2

在更有效的 C++ 中，迈耶斯描述了一种使用对象计数基类（第 26 项）来计算对象实例化的方法。是否可以使用如下组合技术来实现相同的功能。使用私有继承是否有特定的优势，在这种情况下使用组合有什么缺点。

ps:- 我已经重用了来自更有效的 C++ 的代码，并进行了少量修改。

    #ifndef COUNTERTEMPLATE_HPP_
    #define COUNTERTEMPLATE_HPP_
    #include <iostream>
    #include <stdio.h>
    #include <stdlib.h>

    template <class BeingCounted>
    class Counted {
    public:
        static int ObjectCount(){return numOfObjects;}
        Counted();
        Counted(const Counted& rhs);
        ~Counted(){--numOfObjects;}
    protected:
    private:
        static int numOfObjects;
        static int maxNumOfObjects;
        void init();
    };

    template<class BeingCounted> Counted<BeingCounted>::Counted()
    {
        init();
    }

    template<class BeingCounted> Counted<BeingCounted>::Counted(const Counted& rhs)
    {
        init();
    }

    template<class BeingCounted> void Counted<BeingCounted>::init()
    {
        if(numOfObjects>maxNumOfObjects){}
        ++numOfObjects;
    }

    class Printer
    {
            public:
        static Printer* makePrinter(){return new Printer;};
        static Printer* makePrinter(const Printer& rhs);
        Counted<Printer>& getCounterObject(){return counterObject;}
        ~Printer();
            private:
        Printer(){};
        Counted<Printer> counterObject;
        Printer(const Printer& rhs){};
    };

    #endif /* COUNTERTEMPLATE_HPP_ */

4

2 回答 2

2

这个问题与

在这两个中，一个可能是另一个的副本。但两者都没有回答这个问题，而且我有点不愿意将我的答案发布给其中一个。

私有继承可以利用空基类优化：

class Printer0
{
    Counted<Printer0> counterObject;
    int m;
};

class Printer1 : Counter<Printer1>
{
    int m;
};

Clang++ 和 g++ 都说sizeof(Printer0) == 8和sizeof(Printer1) == 4.

原因是数据成员必须有不同的地址，但单个空基类不需要用完对象中的内存。所以counterObject是一个字节大，并int与 4 个字节对齐，因此Printer0看起来像这样：

  | | XX | |
  0 1 2 3 4 5 6 7 8 9
          ^~~~~~~~~ 米
      ^~~~ 填充
  ^~~~ 计数器对象
于 2014-05-31T13:20:38.983 回答
0

组合迫使您使用与其主要业务无关的元数据（即计数器对象）“污染”类的代码，在我看来，这会使代码在这种情况下的可读性降低。另请参阅@dyp 关于空类优化技术方面的回答。

于 2014-05-31T13:22:17.143 回答