C++中不同类对象创建计数结果与预期不符的原因咨询

Great question—this is such a common gotcha when counting object instances in C++. Let’s walk through the most likely reasons your count isn’t aligning with what you expected:

1. You’re not counting copy/move constructors #

The most probable issue is that your counting logic only tracks the default constructor, but ignores copy and move constructors. When you pass an object by value to fooX, C++ creates a copy of the original object using the copy constructor (or move constructor if the object is a temporary or you use std::move).

If you didn’t explicitly define these constructors with counting logic, the compiler generates default versions that don’t update your object count. For example:

// Incomplete X class (missing copy/move counting)
class X {
public:
    static size_t total_created;
    X() { total_created++; } // Only counts default-constructed objects
    // No copy constructor defined—compiler makes one that doesn't increment the count!
};

Fix this by adding counting logic to all constructors:

class X {
public:
    static size_t total_created;

    X() { total_created++; }
    X(const X&) { total_created++; } // Count copies
    X(X&&) noexcept { total_created++; } // Count moves (C++11+)
};

size_t X::total_created = 0;

2. Compiler copy elision might be skipping copies #

C++ allows compilers to perform copy elision—an optimization that skips unnecessary copy/move operations entirely. While this is less likely for named objects (like your x variable being passed to fooX), it’s still possible in some edge cases.

To test this, compile your code with optimizations disabled (e.g., using -O0 with GCC/Clang or /Od with MSVC). If the count matches your expectation after disabling optimizations, copy elision was the culprit.

3. You’re counting "alive objects" instead of "total created" #

If your class has a destructor that decrements the count, you’ll only track the number of currently alive objects—not the total number created during the program’s lifecycle. For example:

// Wrong for counting total created objects
~X() { total_created--; }

When fooX exits, the parameter copy is destroyed, and the count drops back to 1. To fix this, remove the decrement from the destructor and only increment the count in constructors.

Working Example #

Here’s a complete code snippet that correctly counts total X objects created:

#include <iostream>

class X {
public:
    static size_t total_created;

    X() {
        total_created++;
        std::cout << "Default constructor called\n";
    }

    X(const X&) {
        total_created++;
        std::cout << "Copy constructor called\n";
    }

    X(X&&) noexcept {
        total_created++;
        std::cout << "Move constructor called\n";
    }
};

size_t X::total_created = 0;

void fooX(X param) {}

int main() {
    X x;
    fooX(x);
    std::cout << "Total X objects created: " << X::total_created << "\n";
    return 0;
}

This will output:

Default constructor called
Copy constructor called
Total X objects created: 2

Which matches your original expectation.

内容的提问来源于stack exchange，提问作者Tryer