saito@sdr.slb.com (Naoki Saito) (02/10/90)
A long time ago, there was a discussion about the initializing the array of objects. My question is slightly different from that. Suppose I want to declare an array of object Cell. There are two ways to declare this. (1) array of pointers to objects Cell** ppc = new Cell*[N]; // null constructor. for (int i = 0; i < N; i++) ppc[i] = new Cell(i); // constructor with some argument. (2) array of objects Cell* pc = new Cell[N]; // null constructor. for (int i = 0; i < N; i++) pc[i] = *(new Cell(i)); // constructor with some argument. Now, the differences of these two approaches look like o The approach (1) needs N x (sizeof(Cell*) + sizeof(Cell)) memory space whereas (2) only needs N x sizeof(Cell). o The approach (2) creates temporary objects and calls assignment operator = i.e., pc[i] = *(new Cell(i)); is equivalent to Cell temp(i); pc[i] = temp; // assignment operator. ~temp(); whereas (1) simply copies the address to the pointers. So these are the trade-off. Am I missing something here? Does anyone has an idea which is better than which? Should the decision be made based on whether memory space or computation time is important? -- Naoki Saito (saito@sdr.slb.com) Schlumberger-Doll Research
starr-page@CS.YALE.EDU (Page Starr) (02/10/90)
>(2) array of objects > Cell* pc = new Cell[N]; // null constructor. > for (int i = 0; i < N; i++) > pc[i] = *(new Cell(i)); // constructor with some argument. > You could consider: (2.0) array of objects Cell* pc = new Cell[N]; // null constructor. for (int i = 0; i< N; i++) new (pc[i]) Cell(i); // constructor with some argument. I believe the syntax is correct, but am not positive. This is known as in-place initialization, and avoids the creation of temporaries. -Page ----------------------------------------------------------------------------- Charismatic Services for you and me. ----------------------------------------------------------------------------- CSnet: starr@cs.yale.edu BITNET: starr@yalecs.BITNET ARPAnet: starr%cs.yale.edu@relay.cs.net Phone: (203)432-1215 USmail: Page Starr, Box 2158 Yale Station, New Haven, CT 06520
shopiro@alice.UUCP (Jonathan Shopiro) (02/11/90)
In article <1990Feb9.201223.14332@sdr.slb.com>, saito@sdr.slb.com (Naoki Saito) writes:
= Suppose I want to declare an array of object Cell. There are two ways to
= declare this.
=
= (1) array of pointers to objects
= Cell** ppc = new Cell*[N]; // null constructor.
= for (int i = 0; i < N; i++)
= ppc[i] = new Cell(i); // constructor with some argument.
=
= (2) array of objects
= Cell* pc = new Cell[N]; // null constructor.
= for (int i = 0; i < N; i++)
= pc[i] = *(new Cell(i)); // constructor with some argument.
This is surely not what you want to do. Each invocation of ``new Cell(i)''
creates an object on the free store that will never be deleted. Instead
you can use a temp on the stack with the code
pc[i] = Cell(i); // constructor with some argument.
=
= Now, the differences of these two approaches look like
= o The approach (1) needs N x (sizeof(Cell*) + sizeof(Cell)) memory space
= whereas (2) only needs N x sizeof(Cell).
Also approach (1) costs you an extra indirection each time you reference an
array element.
= o The approach (2) creates temporary objects and calls assignment operator =
= i.e., pc[i] = Cell(i); is equivalent to [corrected by JES]
= Cell temp(i);
= pc[i] = temp; // assignment operator.
= ~temp();
= whereas (1) simply copies the address to the pointers.
=
What I would do in this case is the following
(2.5) array of objects with re-constructor
Cell* pc = new Cell[N]; // null constructor.
for (int i = 0; i < N; i++)
pc[i].re_init(i); // re-constructor with some argument.
That is, I would be sure that the default (i.e., no-arg) constructor
is empty, or as inexpensive as possible, and I would provide a member
function, Cell::re_init(<arg_type>) which would modify the product of
the default constructor so that the result was what I originally
intended. This may be less than elegant, but it works and is more
efficient that either of the Naoki's suggestionns.
Assignment operations can be expensive, and can often be avoided.
--
Jonathan Shopiro
AT&T Bell Laboratories, Warren, NJ 07060-0908
research!shopiro (201) 580-4229sakkinen@tukki.jyu.fi (Markku Sakkinen) (02/13/90)
saito@sdr.slb.com (Naoki Saito) writes: > A long time ago, there was a discussion about the initializing the > array of objects. My question is slightly different from that. > Suppose I want to declare an array of object Cell. There are two ways to > declare this. > [largest part of article deleted] ================== starr-page@CS.YALE.EDU (Page Starr) replies: > You could consider: > (2.0) array of objects > Cell* pc = new Cell[N]; // null constructor. > for (int i = 0; i< N; i++) > new (pc[i]) Cell(i); // constructor with some argument. > > I believe the syntax is correct, but am not positive. This is known as > in-place initialization, and avoids the creation of temporaries. ================== shopiro@alice.UUCP (Jonathan Shopiro) replies to the original question (probably without having seen the second posting): > ... >= (2) array of objects >= Cell* pc = new Cell[N]; // null constructor. >= for (int i = 0; i < N; i++) >= pc[i] = *(new Cell(i)); // constructor with some argument. > This is surely not what you want to do. Each invocation of ``new Cell(i)'' > creates an object on the free store that will never be deleted. Instead > you can use a temp on the stack with the code > pc[i] = Cell(i); // constructor with some argument. > ... > What I would do in this case is the following > > (2.5) array of objects with re-constructor > Cell* pc = new Cell[N]; // null constructor. > for (int i = 0; i < N; i++) > pc[i].re_init(i); // re-constructor with some argument. > [some useful advice avoided] ================== Presumably the first poster has been accustomed to some other OO language, in which objects can be created only by calling "new" or some similar procedure. The case is quite opposite in C++: even objects of class types can, and normally should, belong to the automatic or the static (incl. external) storage class; they should be created in the heap (i.e. using "new") only when necessary. Remember that C++ has no garbage collection! That's what Shopiro hints at above. I suggest an improvement still over Shopiro's proposal in two ways: 1. There was no explicit reason given originally why the array should be allocated from the heap, so make the first line something like Cell cell_array [N]; (prepend 'static' if needed). Of course, this works only if N is a compile-time constant - if it's a variable, you must use "new". 2. As far as I understand from the new C++ Release 2.0 Reference Manual, it is now possible to initialise an array of class objects even with constructors that take arguments, _if_ the array is not created by "new". Thus a separate re-initialisation function will not be needed in a typical case. About Starr's proposal: The implications of additional arguments to "new" are hardly mentioned at all in the new Reference Manual, and only a little better in Stroustrup's paper, "The Evolution of C++: 1985 to 1989". What I surmise from that is that Starr's suggestion would _almost_ achieve its intended purpose, but it would allocate and initialise "unreachable" new objects on the second round. To avoid that, the additional argument to "new" should be cast to a _non-class_ type. Is this guess correct? Markku Sakkinen Department of Computer Science University of Jyvaskyla (a's with umlauts) Seminaarinkatu 15 SF-40100 Jyvaskyla (umlauts again) Finland SAKKINEN@FINJYU.bitnet (alternative network address)