Difference between member functions and static member functions?

Answer 1

difference between static data member and static member function

Answer 2

c: A static function is visible only in the source file containing it. A static member is not defined. c++: A static function is visible only in the source file containing it. A static member variable is common to all instances of a class. A static member function is used to access static members.

Answer 3

Static member functions are used to provide functionality that is closely associated with the class but are not associated with any one instance of the class. Static member functions do not have access to a this instance pointer, and can therefore be called without instantiating any instances of the class. By contrast, non-static member functions are associated with a specific instance of the class and therefore have access to the this instance pointer.

Static member functions can be likened to friend functions (with the same access rights), but are scoped to the class itself. They are often used in conjunction with static member variables.

By way of example, consider the following class:

class MyClass

{

int instance_variable;

static int class_variable;

public:

int GetInstanceVariable() const { return( instance_variable ); }

static int GetClassVariable() const { return( class_variable ); }

};

// initialise static member variable.

int MyClass::class_variable = 0;

Here, every instance of the class shares class_variable and we can access it without even instantiating an instance of MyClass:

int x = MyClass::GetClassVariable(); // x == 0

However, because class_variable is shared amongst all instances of MyClass, any instance of MyClass can alter its value. This can be useful if you need to know how many instances of MyClass have been instantiated, for example, simply by incrementing class_variable in every constructor, and decrementing it in the destructor. Thus the value returned by MyClass::GetClassVariable() tells you exactly how many instances exist at that moment in time.

Static members functions are also useful when dealing with singleton classes. The typical model is as follows:

class MySingleton

{

private:

MySingleton(); // default constructor

MySingleton(const MySingleton&) {}; // copy disabled

MySingleton& operator=(const MySingleton&) {} // assignment disabled

static MySingleton *instance; // the one and only instance of MySingleton

public:

static MySingleton& Instance(){

if(!instance)instance=new MySingleton(); return( *instance );}

static void Destroy(){

if(instance)delete(instance);}

}

// Initialise static member.

MySingleton * MySingleton::instance = 0;

Here, an instance of MySingleton is created the first time you call MySingleton::Instance() and that one instance exists for the entire duration of the program or until you call the MySingleton::Destroy() static member function. This then guarantees that only one instance of MySingleton is ever instantiated at any one time. The class can then be fleshed out with non-static member methods that are only accessible via calls to MySingleton::Instance().

Answer 4

A constructor is called during the creation of an instance of that class and it does not have a return type as a member function. It is not a property of the created object and the constructor can not be accessed by the object. It is like a static method that only gets called during object creation.

Answer 5

When you declare a virtual member function you are implying that your class is intended to act as a base class, and that derivatives of your class can override the virtual function, thus ensuring that no matter which class within the hierarchy you refer to, the most-derived override will always be invoked. In other words, it assures polymorphic behaviour. Non-virtual functions do not act polymorphically. This is why destructors must always be declared virtual in a base class, to ensure derived objects are destroyed in the reverse order of construction, from the most-derived class to the least derived class (construction always begins with the least-derived class). Once a function is declared virtual in a base class, it remains virtual in all its derivatives; the virtual keyword is implied from that point on, but it's good practice to explicitly include the virtual keyword, if only to remind consumers of your derivatives that the function can be overridden.