Hi All


I am relatively new to the C++ world . Facing some problem , while initializing an array of objects .

Suppose i have a class Rectangle . I want to have a pointer to an array of objects to the class . How do i invoke the Class Constructor , for a paricular object in the arraylist.

class Rectangle
{

public :

int side1 , side2;
Rectangle(int,int);
Rectangle();
void get_area();

private :
protected :

};

Rectangle::Rectangle(int x, int y)
{

side1=x;
side2=y;

}


void Rectangle::get_area()
{
  cout<<"Area :"<< side1*side2<<endl;
}


Rectangle *ptr_arr;
 ptr_arr=new Rectangle[2] ;                 // pointer to an array of objects to the class

 // Now how do i initialize the dimensions for the ptr_arr[1] object , using the constructors ???

<< moderator edit: added [code][/code] tags >>


Pplz Help


Best Regards

Varun

Hi Varun,
Just try this:

Rectangle *ptr_arr[2];
ptr_arr[0] = new Rectangle(10,20);
ptr_arr[1] = new Rectangle(15,5);

Thnx a lot Sir !!!

That definately worked ......But just wanna know thw diff b/n

Approach 1
---------------

Rectangle * ptr_arr;
ptr_arr=new Rectangle[2];


Approach 2
---------------

Rectangle * ptr_arr[2];
ptr_arr[0]=new Rectangle;
ptr_arr[1]=new Rectangle;


Are the two approaches same ???

Rectangle * ptr_arr;
ptr_arr=new Rectangle[2];

The above code creates an array of 2 Rectangles by calling the constructor:
Rectangle::Rectangle();
But if u want to call the constructor:
Rectangle::Rectangle(int x, int y)
u should use

ptr_arr[0] = new Rectangle(10,20);
ptr_arr[1] = new Rectangle(15,5);

Actually what i meant was , that is there any diff b//n the memory allocation / meathod scheme of the two ..leave alone the first query of constructors


The first approach shows an array of objects being pointed to ..by the ptr_arr pointer .
Does the second one , signify a pointer array or an object array initialization ....

Wat's the difference . (just suppose that , no constructor is involved0
I hope i am clear .....

Best Regards
Varun

Look Varun, the main difference between these 2 is that the 1st one allocates the memory at the time of running (dynamic memory allocation). But the 2nd one does the same at both compile and run time. First it creates memory at the time of compilation (ie, static memory allocation) for the line :
Rectangle * ptr_arr[2];
and after that it again creates the memory at run time for :
ptr_arr[0]=new Rectangle;
ptr_arr[1]=new Rectangle;
So I think if there is no specific reason, the 2nd approach should be avoided.

Amit

This article has been dead for over six months. Start a new discussion instead.