Static Variables, Separate Compilation

Question

Hi, I wrote a program out, which was all in one file, and the methods were forward declared in a header. The program initially worked perfectly when it was in one file. But when I separated the program, I kept getting random occurrences for the destructor of one of the classes which was declared in the header file.

I have a static variable in my header to count the number of objects of a particular class. Whenever I construct the object I increment this variable. Then in my destructor I subtract 1 from that variable, check if it's 0 (meaning it's the last object) and do something. The value seems to be off sometimes, I'm not sure why. I do have random calls in my application but I don't see why that would effect what I have described above, thanks. Any help or insight is appreciated!

[Update]: have a base class, which contains the destructor.. which is implemented in the header, then I have two derived classes, which in their constructor increment the static var.. so what can I do?

What I am trying to do is the following: In my header I have this:

class A {
public:
    virtual ~A() {
        count --;
        if (count == 0) { /* this is the last one, do something */ }
    }

class B : public A {
public:
    B();
}

Then in Class B I have

B::B() { 
    count++;
}

Where can I define count so I don't get misleading counts? Thanks.

Answer 1

Can you elaborate what you mean by the "value seems to be off"? Do you get too many constructions? Not enough destructions? If you get too many constructions and not enough destructions, it would not have anything to do with the statics.

Also, what do you mean by a static variable? Do you mean a static member field or an actual static variable ?

If you declare just a static variable in the header (which I doubt that you do), then each C file that includes that header would have a separate instance of that variable (since static before a global variable means that it is limited to that object file).

Answer 2

Where is your static variable defined? Perhaps you are accidentally defining it in the header file, and the inlining is confusing things (and the compiler doesn't catch the multiple definitions, which would be odd, but you never know).

Make sure a class-static variable is defined in exactly one translation unit. You define it like this:

int MyClass::static_var;

This is also the place you put the initializer, if any.

Answer 3

class A {
public:
    virtual ~A() {
        count --;
        if (count == 0) { // this is the last one, do something }
    }
protected:
    static int count;
};

class B : public A{
public:
B();
};

And then, in one and only one of your source files you need to put the following. It should go in the source file that contains the code for class A.

int A::count(0);

You need to do this, because the header file declared that there was going to be a variable named count, but didn't allocate any storage for it. If you didn't put it in a source file, the linker would complain that it wasn't found.

Answer 4

You must define the constructor in A (all of them) to increment the count.

Note unless you define them the compiler automatically generate the following four methods:

• Default Constructor (if no other constructor is defined)
• Default Destructor
• Copy Constructor
• Assignment operator

The following code overrides the compiler defaults so that you should get an accurate count.

 class A
 {
    static int count;

    public:
        A()   // Default constructor.
        {
            ++count;
        }
        A(A const& copy)  // Copy constructor/
        {                 // Note If you do not define it the compiler
            ++count;      // will automatically do it for you
        }
        virtual ~A()
        {
            --count;
            if (count == 0)
            {  // PLOP
            }
        }
        // A& operator=(A const& copy)
        // do not need to override this as object has
        // already been created and accounted for.
};

//// In source file:

int A::count = 0;