Static Functions in C++ –

In the STATIC example in before chapter, “Objects and Classes,” we introduced static data members. As you may recall, a static data member is not duplicated for each object; rather a single data item is shared by all objects of a class. The STATIC example showed a class that kept track of how many objects of itself there were. Let’s extend this concept by showing how functions as well as data may be static.

Besides showing static functions, our example will model a class that provides an ID number for each of its objects. This allows you to query an object to find out which object it is a capability that is sometimes useful in debugging a program, among other situations. The program also casts some light on the operation of destructors. Here’s the listing for STATFUNC:

// statfunc.cpp
// static functions and ID numbers for objects
#include  <iostream>
using namespace std;
class gamma
static int total; //total objects of this class
// (declaration only)
int id; //ID number of this object
gamma() //no-argument constructor
total++; //add another object
id = total; //id equals current total
~gamma() //destructor
cout << “Destroying ID number “ << id << endl;
static void showtotal() //static function
cout << “Total is “ << total << endl;
void showid() //non-static function
cout << “ID number is “ << id << endl;
int gamma::total = 0; //definition of total
int main()
gamma g1;
gamma g2, g3;
cout << “----------end of program----------\n”;
return 0;

Accessing static Functions

In this program there is a static data member, total, in the class gamma. This data keeps track of how many objects of the class there are. It is incremented by the constructor and decremented by the destructor.

Suppose we want to access total from outside the class. We construct a function, showtotal(), that prints the total’s value. But how do we access this function?

When a data member is declared static, there is only one such data value for the entire class, no matter how many objects of the class are created. In fact, there may be no such objects at all, but we still want to be able to learn this fact. We could create a dummy object to use in calling a member function, as in

gamma dummyObj; // make an object so we can call function
dummyObj.showtotal(); // call function

But this is rather inelegant. We shouldn’t need to refer to a specific object when we’re doing something that relates to the entire class. It’s more reasonable to use the name of the class itself with the scope resolution operator.

gamma::showtotal(); // more reasonable

However, this won’t work if showtotal() is a normal member function; an object and the dot member access operator are required in such cases. To access showtotal() using only the class name, we must declare it to be a static member function. This is what we do in STATFUNC, in the declarator

static void showtotal()

Now the function can be accessed using only the class name. Here’s the output:

Total is 1
Total is 3
ID number is 1
ID number is 2
ID number is 3
———-end of program——–
Destroying ID number 3
Destroying ID number 2
Destroying ID number 1

We define one object, g1, and then print out the value of total, which is 1. Then we define two more objects, g2 and g3, and again print out the total, which is now 3.

Numbering the Objects

We’ve placed another function in gamma() to print out the ID number of individual members. This ID number is set equal to total when an object is created, so each object has a unique number. The showid() function prints out the ID of its object. We call it three times in main(), in the statements


As the output shows, each object has a unique number. The g1 object is numbered 1, g2 is 2, and g3 is 3.

Investigating Destructors

Now that we know how to number objects, we can investigate an interesting fact about destructors. STATFUNC prints an end of program message in its last statement, but it’s not done yet, as the output shows. The three objects created in the program must be destroyed before the program terminates, so that memory is not left in an inaccessible state. The compiler takes care of this by invoking the destructor.

We can see that this happens by inserting a statement in the destructor that prints a message. Since we’ve numbered the objects, we can also find out the order in which the objects are destroyed. As the output shows, the last object created, g3, is destroyed first. One can infer from this last in first out approach that local objects are stored on the stack.

Read More Topics
Const member function in C++
Passing pointers to function
Static data member in C++
Three Level Addressing – Subnetting
Two Level Addressing in IPv4

About the author

Santhakumar Raja

Hi, This blog is dedicated to students to stay update in the education industry. Motivates students to become better readers and writers.

View all posts

Leave a Reply