Just as variables of pre-def data type are dynamically allocated, same way
objects of class can also be dynamically allocated. While the method of doing
this is no different but the way members of such objects are accessed is a bit
different. This is why I thought of writing a separate article on it.
Before discussing any further, look at the program below:
// Example Program in C++
#include<iostream.h>
// class
class myclass
{
// by default everything is
// private to the class
int var1, var2;
void add();
public:
int sum;
void input(int,int);
};
// function definitions
void myclass::input(int a, int b)
{
var1=a;
var2=b;
add();
}
void myclass::add()
{
sum=var1+var2;
}
// main function starts
void main(void)
{
myclass obj; // simple object
myclass *pobj; // pointer
// of type 'myclass'
pobj=&obj; // now 'pobj' pointer
// points to the object 'obj' of
// class 'myclass'
// members are accessed by the '.'
// operator
obj.input(10,20);
cout<<obj.sum;
cout<<endl;
// in case of pointers of class,
// members are accessed by the
// '->' arrow operator
pobj->input(30,40);
cout<<pobj->sum;
cout<<endl;
}
Did you notice the difference?
Members of the object of the class as you know are accessed like this:
object.membername;
While, in case of pointers of the class, the members are accessed like this:
objectptr->membername;
This is the difference I wanted to show you!
As in case of dynamic memory allocation, we have to declare pointer of the
class, therefore members of the dynamically allocated objects will be accessed
by the (->) arrow operator.
Arrays and pointers are closely related. While the members of the pointers
of objects are accessed by the (->) operator, in case of arrays of objects,
we have to use ‘.’ operator instead.
The example program below will clear the confusion, if any:
// Example Program in C++
#include<stdio.h>
#include<iostream.h>
#include<process.h>
class employee
{
private:
char name[30];
int emp_no,age;
float salary, net_salary, tax;
void calculate();
public:
void input();
void output();
};
//----FUNCTION DEFINITION STARTS----
void employee::input()
{
printf("Enter Name: ");
gets(name);
printf("Enter Employee Number: ");
cin>>emp_no;
printf("Enter Age: ");
cin>>age;
printf("Enter Salary: ");
cin>>salary;
printf("Enter Tax Paid: ");
cin>>tax;
printf("\n\n");
calculate();
}
void employee::output()
{
printf("Name: %s\n", name);
printf("Age: %d\n", age);
printf("Employee Number: %d\n", emp_no);
printf("Net Salary: %f\n", net_salary);
printf("\n\n");
}
void employee::calculate()
{
net_salary=salary-tax;
}
//----FUNCTION DEFINTION ENDS----
// main function starts
void main(void)
{
employee *emp_obj;
int num_emp;
printf("Enter Number of Employees: ");
cin>>num_emp;
emp_obj=new employee[num_emp];
// terminate if memory allocation
// failed
if(emp_obj==NULL) exit(1);
// take input
for(int i=0;i<num_emp;i++)
// object are accessed as arrays
// so '.' operator is used
// we can also write
// (emp_obj+i)->input(); to do the
// same thing
emp_obj[i].input();
printf("\n\n EMPLOYEE DETAILS\n");
// give output
for(i=0;i<num_emp;i++)
emp_obj[i].output();
}
As in the comments, we can either use
emp_obj[i].input();
or
(emp_obj+i)->input();
to do the same thing, in the first case the object is referenced as an array
while in the other case, it is referenced as pointer. So the appropriate operator
is used in each case.
Hope this article helps!
