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，因此我没有其他选择，但也没有使用它）也给了我一个错误（非法）结构操作）在＆＃34;案例2：~objectCounter（）;＆＃34;部分。我浏览了书籍并意识到我忘记了构造函数也需要一个对象声明。（objectCount OC;）

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

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

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

你们中的任何人，尊敬的，善良的，温柔的，知识渊博的社区能帮助我吗？

编辑：理想输出：

--------------- || 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

欢迎！

~objectCount()的问题基本上是它说＆＃34;删除objectCount对象＆＃34; ...并且编译器说＆＃34;哪一个？＆＃34;如果你不以某种方式跟踪你创建的对象，你可能会记忆泄漏这些对象。

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

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

如何内存管理单个objectCount对象。为了保留这些对象中的许多对象，您可能希望维护这些指针的数组或std::vector。

Answer 2

您的计数逻辑的实现是正确的（只要您保持在单线程方案中），但您的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进行手动内存管理非常容易出错。

正如您在堆栈示例中所看到的，范围由花括号定义。如果您需要对对象的生命周期进行更细粒度的控制，则可以使用一组“独立”曲线。即您的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。没有合适的范围可以提供相同的效果。但在此之前，请考虑可能出错的事情。例如，如果用户决定连续创建两次......或者连续两次删除，会发生什么。

修改

要让用户创建和销毁任意数量的对象，您需要保持包含现有对象的列表a.k.a std::vector。那时TurboC成为一个真正的问题，因为它早于C ++标准模板库（STL），该载体是其中的一部分。而且你现在不想自己实现矢量。

我要说的是，令人难以置信的是，你的国家教育委员会的决定令人难以置信的是强迫你从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上可以在创建/销毁时进行打印。

使用Constructor和Destructor在C ++中的对象计数器

2 个答案: