When do you declare a member of a class static?

Answer 1

Static members should be used whenever you have a member that is logically considered part of the class, but is not associated with any instance of the class. They are bit like global variables and functions but there's more control over their visibility outside of the class.

Static member methods can be thought of as being global functions that are scoped to the class (rather than to each instance of the class). As such, they do not inherit an implicit this pointer and can therefore be called without instantiating an instance of the class (access specifier permitting). However, any and all instances of the class have unrestricted access to all the static member methods of the class.

Static member variables can be thought of as being global variables that are scoped to the class (rather than to each instance of the class). That is, all instances of the class share the same set of static member variables amongst them, rather than each having their own (as they would with non-static member variables). Static member variables are also accessible to static member functions. As with all other static variables, they are initialised at compile time (which must be done outside of the class declaration), and will remain in scope for the entire lifetime of the program.

All static members are subject to the public, protected or private access specifiers, so while they can act like global variables and functions if declared public, their visibility outside of the class can be limited to private or protected access.

Possible uses for static members are many and varied. By way of an example, suppose you want to maintain a read-only count of all instances of a class. The following framework demonstrates how this can be done with static members:

class Object

{

public:

Object(){++s_instances;}

~Object(){--s_instances;}

static unsigned int GetInstances(){return(s_instances);}

private:

static unsigned int s_instances;

};

// Static member variable initialiser (evaluated at compile time):

unsigned int Object::s_instances=0;

int main()

{

cout<<"Current instances:\t"<

Object * p1 = new Object();

cout<<"Current instances:\t"<

Object * p2 = new Object();

cout<<"Current instances:\t"<

delete( p1 );

cout<<"Current instances:\t"<

delete( p2 );

cout<<"Current instances:\t"<

}

Output:

Current instances: 0

Current instances: 1

Current instances: 2

Current instances: 1

Current instances: 0

Previous Answer

In the code, if you want to have only one instance of the member variable irrespective of the number of objects created for that class. In these kind of scenarios static members are used

Answer 2

In C++, a static class member is common to all instances of that class. A static class method is a method that can only access static class members. Non static methods can also access static members, but remember that there is only one instance of that member amongst all instances of the class. One advantage of a static method is that you do not have to instantiate the class to use the static member or static method.

Answer 3

You declare a member of a class to be static when the member is local to the class as a whole, rather than to an instance of the class. Static members are a bit like global variables or functions, but their scope is limited to class scope rather than global scope (although public static members are essentially global). As members of the class, however, static member functions also have private access to the class, including other static members as well as class instance members. But they do not have access to the implicit this pointer since they are not associated with any instance. To access a class instance member, a static member function must either accept one or more class instances via the function's arguments, and/or instantiate one or more new instances within the body of the function.

Answer 4

When all objects share a common private data variable, it is declared as static. Look at the example here

Class example

{

private:

static int counter;

int sales;

public:

example();

~example();

void example(...);

void increment();

void decrement();

};

static int counter=0; // initialized only once.

void example :: void increment()

{

counter++;

}

void example:: void decrement()

{

counter--;

}

----

Answer 5

If you declare a field static, there will only be one copy of it in the entire program, even if several objects are created based on the corresponding class. It is up to the programmer to decide when this would be appropriate.

Answer 6

Whenever the member should be local to the class rather than local to every instance of the class. All non-static members are instance members. As such, instance member methods have access to the this pointer. Static member methods do not. However, static members exist for the duration of a program's life-cycle and are accessible even when no instances of the class exist.

Private static members are visible to all members of the class as well as to friends of the class. Protected static members are also visible to derivatives of the class. Public static members are akin to global variables and functions, but are localised to the class namespace.

Static member data can also be thought of as being shared data that is common to all instances of the class. For instance, if you need to maintain a count of all instances of a class, a private static size_t member could be used, initialised to zero. Every constructor increments the member while the destructor decrements the member. A public static accessor (getter) method can be used to return the value of the static member as a read-only variable.

Note that all static member data must be initialised outside of the class declaration and outwith the class' implementations. Typically, initialisation code is placed in a corresponding source file immediately after including the class header but before defining the class implementations. However, if the class is a template class, the declaration and definition, including static data initialisation, must be completely visible to the compiler. In this case, the header must include the file containing the source file rather than the other way around. Alternatively, all code may be placed in the header itself, but this makes it more difficult to hide the implementation details from consumers.

Answer 7

We declare a member static when the member is to be regarded as being local to the class rather than local to each instance of the class. That is; there is only ever one instance of the member rather than one per object. We use static member variables for data that is shared amongst all instances of the class. Fort that reason, non-static member variables are often called instance variables since each instance has its own discrete set of non-static member data. Static member functions, on the other hand, are the same as non-static member functions except that they do not have access to an implicit this pointer. As such, public static member functions can be invoked even when there are no objects of the class in memory.

Answer 8

If a member field (variable) of a class is static, a single copy of the field exists for the entire class, no matter how many objects you create for the class.

Apart from saving space, this makes it possible to share data among different objects. For a simple example, you might want to assign each object a serial number - the first object created will be #1, the second #2, etc. This requires some variable, that will be incremented every time an object is created. An instance (object) variable doesn't work in this case, because each instance (object) will have a separate copy of the instance variable, and set it to a default value, such as zero.

In languages where no static members (or something equivalent) exist, this would require having a variable, separate from the class. This works, but it is a little more messy - the whole idea of classes is to keep things organized; so variables that are related to the class should logically be defined in the class.

Answer 9

yes u can declare a class static if static class is present in ur program then it should be executed first