在默认构造函数中可见的继承类的 c++ 计数器的实现

Question

所以我尝试了多种方法来为我的类创建一个计数器，该计数器在构造函数中传递数字

我希望它输出这样的东西：

input the amount of base class objects: 2
The A# 1:
input SomeVar_one: 3
input SomeVar_two: 2
The A# 2:
input SomeVar_one: 2
input SomeVar_two: 3
input the amount of derived class objects: 2
The A# 1:
input SomeVar_one: 23
input SomeVar_two: 32
The A# 2:
input SomeVar_one: 12
input SomeVar_two: 42
total # of base objects is: 4
total # of derived objects is: 4

我在哪里得到这个：

input the amount of base class objects: 2
The A# 1:
input SomeVar_one: 3
input SomeVar_two: 2
The A# 2:
input SomeVar_one: 2
input SomeVar_two: 3
input the amount of derived class objects: 2
The A# 3:
input SomeVar_one: 23
input SomeVar_two: 32
The A# 4:
input SomeVar_one: 12
input SomeVar_two: 42
total # of base objects is: 4
total # of derived objects is: 4

注意用户提示输入从new运算符调用的构造函数调用的值之间的区别

ofc 需要给他们单独的名字，这也是我想解决的问题。 你可能提出的任何建议都是可以接受的。

主要目标是在调用new运算符时立即实例化对象，而无需进入 i ofc 可以调用"The (A/B) # (i)"的for循环

这是我使用过的代码：它使用“奇怪的重复模板模式”（顺便说一句，这个名字是一个杀手！）

//sample
#include<iostream>
template <typename T>
class counter
{
public:
    counter(bool do_count = true) : counted(do_count)
    {
        if (counted) get_count()++;
    }
    ~counter()
    {
        if (counted) get_count()--;
    }
    static unsigned long GetInstancesCount()
    {
        return get_count();
    }

private:
    bool counted;
    static unsigned long& get_count()
    {
        static unsigned long count = 0;
        return count;
    }
};


class base:public counter<base>
{
protected:
    int m_SomeVar_one = 0, m_SomeVar_two = 0;
    unsigned long ObjectNumber = 0;
public: 
    base(bool count=true):counter<base>(count),ObjectNumber(counter<base>::GetInstancesCount())
    {
        std::cout << "The A# " << ObjectNumber <<": " << std::endl;
        std::cout << "input SomeVar_one: ";
        std::cin >> m_SomeVar_one;
        std::cout << "input SomeVar_two: ";
        std::cin >> m_SomeVar_two;
    }
    virtual int get_count()
    {
        return counter<base>::GetInstancesCount();
    }
};

class derived :public base, public counter<derived>
{
protected:
    int m_SomeVar_three = 0;

public:
    derived(bool count = true) :base(false), counter<derived>(count)
    {
        std::cout << "input SomeVar_three: ";
        std::cin >> m_SomeVar_three;
    }
    virtual int get_count() override
    {
        return counter<derived>::GetInstancesCount();
    }
};

int main()
{
    std::cout << "input the amount of base class objects: ";
    int amountOfBaseObjects;
    std::cin >> amountOfBaseObjects;
    base* BaseArray = new base[amountOfBaseObjects];


    std::cout << "input the amount of derived class objects: ";
    int amountOfDerivedObjects;
    std::cin >> amountOfDerivedObjects;
    base* DerivedArray = new base[amountOfDerivedObjects];

    std::cout <<"total # of base objects is: "<< BaseArray->get_count() << std::endl;
    std::cout << "total # of derived objects is: " << DerivedArray->get_count() << std::endl;
}

Answer 1

CRTP 并不能很好地与虚拟多态性结合起来——虚拟多态性涉及一个公共基类，而 CRTP 为每个派生类型生成一个不同的基类。

无论如何，您可以通过组合来破解它。 这是带有工厂方法模板的计数器的非模板版本。 请注意，要进行准确的引用计数，必须使用 3 规则：

class counter
{
public:
    template <typename T>
    static counter create()
    {
        static unsigned long count = 0;
        return { &count };
    }
    counter(const counter& that) : count_addr(that.count_addr)
    {
        (*count_addr)++;
    }
    counter& operator =(const counter& that)
    {
        (*count_addr)--;
        count_addr = that.count_addr;
        (*count_addr)++;
        return *this;
    }
    ~counter()
    {
        (*count_addr)--;
    }
    unsigned long GetInstancesCount()
    {
        return *count_addr;
    }

private:
    unsigned long* count_addr;
    counter(unsigned long* count_addr) : count_addr(count_addr)
    {
        (*count_addr)++;
    }
};

然后您可以嵌入一个计数器作为基类的成员，派生类可以选择通过受保护的构造函数提供自己的计数器。 公共构造函数转发工厂方法而不是计数器的一点是确保没有活的临时副本，这可能会在分配ObjectNumber时意外增加计数。

class base
{
public: 
    base() : base(counter::create<base>)
    {
    }
    int get_count()
    {
        return ctr.GetInstancesCount();
    }
private:
    counter ctr;
protected:
    base(counter(*ctr)()) : ctr(ctr()), ObjectNumber(this->ctr.GetInstancesCount())
    {
        std::cout << "The A# " << ObjectNumber <<": " << std::endl;
    }
    unsigned long ObjectNumber; // important - must come after counter
};

class derived : public base
{
public:
    derived() : base(counter::create<derived>)
    {
    }
};

之后，我可以大致复制您的预期输出： https : //godbolt.org/z/eonfb9