In c plus plus program using class to represent the static data structure?

Answer 1

#include<iostream>

#include<trace.h> // user-defined trace macro

using namespace std;

class X

{

public:

X (int data=0)

: m_data (new int (data))

{

TRACE ("creating X @ 0x%x\n", this);

}

~X ()

{

delete m_data;

TRACE ("destroying X @ 0x%x\n", this);

}

X& operator += (int data)

{

*m_data += data;

return *this;

}

private:

int* m_data;

};

static X x = 0;

void foo()

{

TRACE ("entering foo()\n");

static X x = 0;

x += 1;

TRACE ("exiting foo()\n");

}

int main()

{

TRACE ("entering main()\n");

foo();

TRACE ("exiting main()\n");

}

Output:

1: creating X @ 0x24f698

2: entering main()

3: entering foo()

4: creating X @ 0x24f69c

5: exiting foo()

6: exiting main()

7: destroying X @ 0x24f69c

8: destroying X @ 0x24f698

Explanation of output:

1: The static global variable x is instantiated and initialised with the value 0. Note that instantiation occurs before entering main, even though main is the entry point of the application. The compiler has simply inserted the required code at the entry point, immediately in front of the main function code. Note also that this has nothing to do with x being declared static: if you remove the static keyword x would still be instantiated before main was invoked. Therefore x is implicitly static because it was declared at file scope.

2: The main function is invoked.

3. The foo function is invoked from main.

4. The static function variable foo::x is instantiated and initialised with the value 0.

Note that although foo:x is declared static, it does not physically exist until the function is called for the first time. This is because foo::x is scoped to the function.

5. Exit from the foo function.

Note that although foo::x is no longer in scope it is not destroyed at this point. This is because it was declared static. The function also incremented foo::x so foo:x will still have the value 1 if we call foo again, and will increment its value to 2.

6. Exit from the main function.

Normally the program would exit at this point. However, because we have 2 statics still in memory, the compiler has inserted code in place of the main function's closing brace to destroy the static objects.

7. foo::x is destroyed.

8. Global x is destroyed.

At this point the program can exit.