C++中使用构造函数和析构函数的对象计数器

Question

所以，我是新来的，如有错误请多多包涵。

我是一名正在学习 C++ 的大学生，并且不熟悉构造函数和析构函数。

我想要做的是：我需要创建一个程序来维护对象的实时计数，即，每当创建或销毁该类的对象时，对象计数器就会分别递增/递减并显示（无论如何，这是我的逻辑，建议会让我感激不尽）。

这意味着创建一个静态变量，我做了这个：

class objectCount
{
    protected:
    static int count;

    public:
    objectCount()
    {
        count++;
        cout<<"Object of type class created. \nNo. of objects of type class currently: "<<count<<endl;
    }

    ~objectCount()
    {
        count--;
        cout<<"Latest object of type class deleted. \nNo. of objects of type class currently: "<<count<<endl;
    }
};

int objectCount::count=0;

void main()
{
    int ch;
    clrscr();
    cout<<"--------------- || OBJECT COUNTER || ----------------"<<endl;

    do {
        cout<<"1. Create Object\n2. Delete Object\n3.Exit";
        cout<<endl<<"Enter your choice: ";
        cin>>ch;

        switch(ch)
        {
            case 1: objectCount();
                break;

            case 2: ~objectCount();
                break;

            case 3: break;

            default: cout<<endl<<"Invalid Choice.";
                break;
        };
    }while(ch!=3);
    getch();
}

所以，我以为我已经准备好出发了，但是 TurboC（是的，我的大学强迫我们使用 TC，因此我没有其他选择但也可以使用它）给了我一个错误（非法结构操作）在“案例 2：~objectCounter();”部分。我翻阅了书籍并意识到我忘记了构造函数也需要对象声明。 (objectCount OC;)

但现在我对如何更改代码以使其正常工作感到困惑。

我需要它，以便根据用户选择创建一个对象，不。更新和打印的对象，否则删除对象，否。打印和更新的对象数量，完成后退出。

我四处搜索，但通常发布示例的人只是声明有限数量的对象，例如“objectCount c1; objectCount c2;”并完成它，这不是我的情况。

请各位尊敬的、善良的、温和的和知识渊博的社区中的任何人帮助我吗？

编辑：理想输出：

--------------- || OBJECT COUNTER || ----------------
1. Create Object
2. Delete Object
3. Exit
Enter your choice:  1
Object of type class created. 
No. of objects of type class currently: 1 //Static variable incremented & displayed here.

1. Create Object
2. Delete Object
3. Exit
Enter your choice:  1
Object of type class created. 
No. of objects of type class currently: 2 //Static variable incremented & displayed here.

1. Create Object
2. Delete Object
3. Exit
Enter your choice:  2
Object of type class deleted 
No. of objects of type class currently: 1 //Static variable decremented & displayed here.

1. Create Object
2. Delete Object
3. Exit
Enter your choice:  3

编辑 2：我想我会按照 besc 的建议使用包含 100 个对象的数组，现在应该可以了。

但感谢大家的回答，是的，我肯定会超越 TC 并了解真正的交易。

Answer 1

您的计数逻辑实现是正确的（只要您停留在单线程场景中），但您的 main() 不正确。

在case 1 的开关中，您正在做的是创建一个未命名的临时objectCount 对象，该对象会立即再次被销毁。您会看到 ctor 立即被调用，然后是对 dtor 的调用。为什么会立即销毁？因为你没有给它起名字。所以，这不是特别有用，但有效；虽然这显然不是你想要的。

case 2 无法编译，因为您在没有对象的情况下调用 dtor。这里实际上有两个问题。

(1) dtor 需要知道它应该销毁哪个objectCount 对象。在这方面，它的行为与任何其他非静态成员函数一样。这会起作用：

// Creates an object, ctor gets called.
objectCount obj;

// Calls the destructor on obj.
// DO NOT DO THIS! See (2).
obj.~objectCount();  

(2) 在 C++ 中，只有极少数情况下显式调用 dtor。只要您处于学习 C++ 的早期阶段，它们就无关紧要。所以这是一条有效的规则：如果你明确地调用一个 dtor，你就做错了。当对象死亡时，Dtors 会被隐式调用。死亡的发生方式取决于您的对象被分配的位置。

在堆栈上：

void func() {
    objectCount obj;
} // obj goes out of scope here: dtor is called

在堆上：

objectCount* obj = new objectCount;
// ...
delete obj; // dtor is called

尽可能选择堆栈，因为使用 new/delete 进行手动内存管理非常容易出错。

正如您在堆栈示例中看到的，范围由花括号定义。如果您需要对对象的生命周期进行更细粒度的控制，您可以使用一组“独立”卷曲。 IE。您的 main() 可能如下所示：

//...

do {
    cout << "1. Create/destroy on the stack\n"
    cout << "2. Create/destroy on the heap\n
    cout << "3.Exit";
    cout<<endl<<"Enter your choice: ";
    cin>>ch;

    switch(ch)
    {
        case 1: {
            {
                // Note the standalone set of curlies.
                objectCount obj;
            }
            break;
        }

        case 2: {
            objectCount* obj = new objectCount;
            delete obj;
            break;
        }

        case 3: break;

        default: cout<<endl<<"Invalid Choice.";
            break;
    };
}while(ch!=3);

// ...

要让您的用户选择明确地创建和销毁，您需要在此处使用 new/delete。没有合适的范围可以提供相同的效果。但在你这样做之前，想想可能出错的事情。例如，如果用户决定连续创建两次......或连续删除两次会发生什么。

编辑：

要让用户创建和销毁任意数量的对象，您需要保留一个包含现有对象的列表，即std::vector。在这一点上，TurboC 成为一个真正的问题，因为它早于 C++ 标准模板库 (STL)，vector 是其中的一部分。而且此时您不想自己实现向量。

我只想说，您的州教育委员会的决定是多么令人难以置信地脑死，将 DOS 时代的 IDE 强加给您。你不会以这种方式学习任何有用的 C++。如果您只是为了功劳而使用 C++，请完成它，然后忘记经验。但是，如果您对这门语言感兴趣，请为自己准备一个现代编译器和 IDE，并在自己的时间里做一些真正的 C++。你选择什么并不重要：免费版的 Visual Studio、Clang 或 GCC 以及 Qt Creator、Eclipse、CLion：任何东西都可以在与 TurboC 完全不同的世界中运行。 [叹息现在感觉好多了，我的胸膛已经消失了；）。]

好的，如何解决您眼前的问题？让它更简单。使用 C 风格的固定长度数组，该数组包含指向已创建对象的拥有指针和一个保存当前已分配对象数量的变量。

// ... in main() outside the loop ...
// 100 objects should be enough for everybody :)
// DO NOT DO THIS IN REAL C++! Use std::vector instead!
objectCount* object_ptrs[100];
int current_max_idx = 0;

现在您可以使用new/delete 创建和销毁多达 100 个对象，同时递增和递减 current_max_idx。确保在程序退出时 delete 所有剩余的对象，并记住数组是从零开始的，即 object_ptrs 的索引为 0 到 99。

还可以考虑从 ctor 和 dtor 中删除计数逻辑。这是多余的，因为 current_max_idx 变量执行相同的工作，并且在创建/销毁时打印可以在 switch 中发生。

Answer 2

欢迎！

~objectCount() 的问题本质上是它说“删除 objectCount 对象”......而编译器说“哪个？”如果您不以某种方式跟踪您创建的对象，那么您可能会泄漏这些对象的内存。

我建议使用new 和delete 关键字，而不是直接调用构造函数和析构函数。它们对 objectCount 指针进行操作，例如，您可以编写如下代码：

objectCount * my_object = new objectCount(); // allocates memory, calls constructor
delete my_object; // calls destructor, frees memory

这就是内存管理单个 objectCount 对象的方法。要保留许多这些对象，您可能需要维护一个数组或这些指针的std::vector。