Member Functions

-


Member Functions
1.   Defining Member Functions
The data members of a class must be declared within the body of the class, whereas member functions of the class can be defined in following ways:
·        Outside the class definition
·        Inside the class definition

·       Outside the Class Definition
Member functions that are declared inside a class have to be defined separately outside the class. Their definitions are very much like the normal functions. They should have function header and a function body.
An important difference between a member function and a normal function is that a member function incorporates a membership 'identity label' in the header. This label tells the compiler which class the function belongs to. The general form of a member function definition is:
return- type class-name :: function-name (argument declaration)
{
Function Body
}
The membership label class-name :: tells the compiler that the function function- name belongs to the class class-name. That is the scope of the function is restricted to the class- name specified in the header line. The symbol :: is called the scope resolution operator.

For Example:

void Item :: getdata (int a, float b)
{
number = a;
cost = b;
}

void Item :: putdata (void)
{
cout<<”Number:”<<number<<”\n”;
cout<<”Cost:”<<cost<<”\n”;
}
The member functions have some special characteristics which are: -
·        Several different classes can use the same function name. The membership label will resolve their scope.
·        Member functions can access the private data of the class. A non- member function
·        A member function can call another member function directly, without using the dot operator.


·       Inside the Class Definition
Another method of defining a member function is to replace the function declaration by the actual function definition inside the class. Normally small functions are defined inside the class definition. Example:

class Item
{
int number;
float cost;
public:
void getdata(int a, float b);               // declaration
void putdata(void)                            // definition inside the  & Inline Functionclass
{
cout<<numher<<"\n";
cout <<cost<<"\n";
}
};
When a function is defined inside the class, it is treated as inline function.

A C++ Program using Class

#include<iostream.h>
#include< conio.h>
class date
{
int day;                       // private by default
int month;                  // private by default
int year;                      // private by default
public:
void getdata(int x,int y,int z);                      // function declaration
void display()                                               // function defined inside the class
{
cout<< day<<month<<year <<endl;
}
};

void date :: getdata(int x,int y,int z)             // membership label
{                                                                       // member function definition
day=x;
month=y;
year=z;
}

void main()
{
clrscr();
date d1,d2;                              // object creation
d1.getdata(30,12,2012);         // call member function
d2.getdata(23,11,2011)          // call member function
cout<< “ you have entered following date”;
d1.display();
d2.display();
getch();
}


·       Making an Outside Function Inline

We can define a member function outside the class definition and still make it inline by just using the qualifier inline in the header line of function definition, Example:
class Item
{
 ……….
 ……….

public;
void getdata (int a, float b);                      // declaration

};

inline void Item :: getdata (int a, float b)           // definition
{
number = a;
cost = b;
}


 2.   Private Member Functions
Although it is normal practice to place all the data members in the private section and all the functions in public, some situations require certain functions to be hidden (like private data) from the outside calls.
A private member function only be called by another function that is a member of this class. Even an object cannot invoke private function using dot operator. Consider the following example:

class sample
{
int m;
void read();             // private member function
public:
void update();
void write();
};
If s1 is an object of class sample, then
s1.read();                             // won’t work
However, the function read() can be called by the function update() to update the value of m .

void sample :: update(void)
{
read();                                  // simple call; no object used
}


















Comments

Post a Comment

Popular posts from this blog

ASCII / ISCII / UNICODE

-
Image
     Internal storage of encoding characters   A computer is capable of handling numeric data but in addition to numerical data, a          computer must be able to handle non-numerical information . In other words, a              computer should recognize codes that represent letters of the alphabet,                            punctuation and other special characters as well as numbers. These codes are            called alphanumeric codes. 1.      ASCII (American Standards Code for Information Interchange) ASCII code is most widely used alphanumeric code used in computers. It is used extensively in small computers, peripherals, instruments and communication devices. ASCII-7 can represent 2 7 =128 characters. ASCII-8 can represent 2 8 =256 characters. It is...
Read more

CISC / RISC / EPIC

-
Classification of Microprocessors 1.     CISC Processors: CISC is known as Complex Instruction Set Computer . The CISC approach attempts to minimize the number of instructions per program, sacrificing the number of cycles per instruction. Computers based on the CISC architecture are designed to decrease the memory cost . The number of instructions per program can be reduced by embedding the number of operations in a single instruction, thereby making the instructions more complex. For example, MUL(Multiply) . It performs operations such as load from memory, an arithmetic operation and a memory store all in single instruction. Example: IBM 370/168, Intel 80486 etc. Advantages: a.      Microprogramming is as easy as assembly language to implement and much less expensive than hardwiring a control circuit. b.      Fewer instructions are needed to implement a particular computing task, which led to lower memory...
Read more

Evolution of Computers

-
Image
Evolution of Computers The growth of computer industry started with the need for performing fast calculations. The manual method of computing was slow and prone to errors. So attempts were made to develop faster calculating devices. The journey that started from the first calculating device i.e. Abacus has led us today to extremely high speed calculating devices. Let us first have a look at some early calculating devices and then we will explore various generations of computer. Abacus Abacus was discovered by the Mesopotamia’s in around 3000 BC. An abacus consisted of beads on movable rods divided into two parts. (Fig-1) Addition and multiplication of numbers was done by using the place value of digits of the numbers and position of beads in an abacus. Fig. Abacus The Chinese further improved on the abacus so that calculations could be done more easily. Even today abacus is considered as an apt tool for young children to do calculations. In an abacus, each row is thought o...
Read more