How does member function of class define?

Answer 1

Static member functions (or static member methods) are local to the class in which they are declared but, unlike non-static member functions, they are not attached to any instance of the class. That is, they have no access to an implicit this pointer.

Static member functions are often used to declare global functions in conjunction with private static member variables. The variables are not global as they are only accessible to the class itself, but because they are static they exist for the lifetime of the application.

The best possible example of a static member function relates to singleton classes. A singleton class is typically a global class for which one instance (and one instance only) must be guaranteed to remain in scope for the entire duration of the program. A typical usage for such a class might be to enable logging (writing a log of all program activity), and we'd only need one logger.

This means we must actively prevent new instances from being created once the first instance is created, and must ensure it cannot be destroyed while the program is active, intentionally or otherwise. In order to achieve this, the default constructor, the copy constructor and the assignment operator must be declared private with no implementation. This then means that only the class itself can instantiate the one and only instance of the class, and the only way to achieve that is with a static member function and a static member variable.

The following demonstrates the skeleton of a singleton declaration. In a real-life singleton, you would design the remainder of the class just as you would an ordinary class, with instance variables and methods that permit it to carry out its role (whether as a logger or as some other global class for which only one instance is ever required). The example includes simple code to demonstrate its usage as a container for an int using dynamic memory.

Note how the static variable Singleton::instance is initialised to NULL outside of the class declaration (at file scope). This ensures correct initialisation at compile time. This line is typically placed in the class cpp file (implementation file), while the class declaration itself is placed in the class hpp file (header). The one and only instance of the Singleton class is created upon the first call to Singleton::Instance(), which returns a reference to the instance thus permitting access to the instance members.

Since the instance is static, it is guaranteed to remain in scope for the entire life-cycle of the program. It doesn't matter that the static Singleton::instance variable is instantiated dynamically but is never actually released. Since it is a static variable, the memory it points to will be released automatically when the program terminates. The same can also be said of the Singleton::instance->pointer member variable, but it's always good practice to release all non-static members in the private destructor.

The design is such that it would be impossible to inadvertently create two or more instances of the Singleton class, and impossible to destroy the one and only instance until the program terminates.

While there are many other examples of static member functions, the majority merely demonstrate usage that could be far better implemented as a non-static member function or even a friend function. Demonstrations of any practical merit are few and far between (although they do exist), but the Singleton usage is by far the most ingenious and practical usage you will encounter. Microsoft may not agree (a Microsoft singleton isn't strictly a singleton), but the framework shown below is tried and tested, is robust, and does exactly what it says on the tin!

#include

using namespace std;

class Singleton{

private:

Singleton():pointer(new int(100)){} // No creation outside the class.

Singleton(Singleton const&){} // No copying outside the class.

Singleton& operator=(Singleton const&){} // No assignment outside the class.

~Singleton(){delete(pointer);} // No destruction outside the class.

static Singleton* instance; // The only instance there can ever be.

int * pointer; // Dynamic memory allocation (for illustrative purpose).

public:

// Static member function:

static Singleton& Instance(){

if( !instance ) // Creates the instance on first usage only.

instance = new Singleton();

VERIFY(instance != NULL); // Not essential, but prudent.

return(*instance);

}

// A member function (for illustrative purposes).

void foo(void){

cout<<"Singleton::instance resides at memory address 0x"<

cout<<"Singleton::instance->pointer resides at memory address 0x"<

}

// A member accessor and mutator (for illustrative purposes).

int GetValue(void){return(*pointer);}

void SetValue(const int value){*pointer=value;}

};

// Static member initialisation (occurs at compile time). Not optional!

Singleton* Singleton::instance = NULL;

int main(void)

{

// Call singleton methods:

Singleton::Instance().foo(); // The one and only instance is instantiated at this point, just prior to calling foo().

Singleton::Instance().SetValue(3); // Mutate the member variable.

Singleton::Instance().foo(); // Call foo() again.

Singleton::Instance().SetValue(15); // Mutate the member variable.

// Call the member variable accessor:

cout<<"Singleton variable: "<

// It is not possible to delete the instance by accident (the destructor is inaccessible outside of the class):

//delete(&Singleton::Instance()); // Causes compiler error C2248! (MSVC++).

return( 0 );

}

Answer 2

First, it has to be declared.

class myClass {

...

type myMember(...);

...

}

Second, it has to be defined.

type myClass::myMember(...) {

...

}

You can also declare and define it at the same time.

class myClass {

...

type myMember(...) {

...

}

...

}

Answer 3

Instance methods, or object behaviors.

Member, most of time is referred to the one of "instance" (vs static/class member).

Functions are methods. Any method in OOP must be defined and/or implemented by (within) a class, like a member (part) of that class.

Answer 4

A member function of a class defines a method or operation that may be performed upon the class member data, such as returning values from the data, mutating the data, or performing a calculation from the data.

Answer 5

A member function is simply a function (or method in Java) that is part of a class.

Answer 6

When you declare a class and define a function inside the class, that function is called a member function.

Answer 7

Member functions are the methods associated with a class or structure. They are more commonly referred to as member methods.

Answer 8

the internal data of a class is called data members.

the internal function of a class is called as member function.member functions are used to manipulate the data.

rama jyotsna

Answer 9

Method.