Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > C++ > C++ Objects, Stack or Heap? [Noob question]

Reply
Thread Tools

C++ Objects, Stack or Heap? [Noob question]

 
 
Olumide
Guest
Posts: n/a
 
      09-18-2004
In the following C++ class,

MyClass{
// Members
}


From which I create two objects (using the default constructor),
(1) MyClass *object1 = new MyClass(); // Stack
(2) MyClass object2 = MyClass(); // Stack or Heap?

Are both objects (1) and (2) created on the heap or is (1) only? I suspect
this is the case, but I'm not 100% sure because I have not read this
anywhere.

Thanks,

- Olumide

 
Reply With Quote
 
 
 
 
E. Robert Tisdale
Guest
Posts: n/a
 
      09-18-2004
Olumide wrote:

> In the following C++ class,
>
> class MyClass{
> // Members
> };
>
>
> From which I create two objects (using the default constructor),
> (1) MyClass *pobject1 = new MyClass(); // Free Storage
> (2) MyClass object2 = MyClass(); // Automatic Storage
>
> Are both objects (1) and (2) created on the heap or is (1) only?
> I suspect this is the case,
> but I'm not 100% sure because I have not read this anywhere.


You are wrong either way.
Storage is allocated from *free storage* for the object
to which pobject1 points in the first case and
storage is allocated from *automatic storage* for object2
in the second case.

In the *typical implementation*,
the *program stack* is used for automatic storage and
a *free list* is used to manage free storage.
The whimsical term *heap* is a pun used by IBM programmers
to contrast their implementation of a free list
with a stack data structure.
 
Reply With Quote
 
 
 
 
Baalbek
Guest
Posts: n/a
 
      09-18-2004
Olumide wrote:
> In the following C++ class,
>
> MyClass{
> // Members
> }
>
>
> From which I create two objects (using the default constructor),
> (1) MyClass *object1 = new MyClass(); // Stack
> (2) MyClass object2 = MyClass(); // Stack or Heap?
>
> Are both objects (1) and (2) created on the heap or is (1) only? I suspect
> this is the case, but I'm not 100% sure because I have not read this
> anywhere.
>
> Thanks,
>
> - Olumide
>


The MyClass *object1 pointer is created on the stack, but the object it
points to is created on the heap. That is, the pointer is automatically
destroyed, but the object on the heap is not (necessitating "delete
object1", that is deleting the object on the heap object1 points to).

MyClass object2 is an object created on the stack.

So, creating many (large) objects like object2 can lead to stack-overflow.

Baalbek

 
Reply With Quote
 
aaaaa
Guest
Posts: n/a
 
      09-19-2004
You area Java guy huh?

Better that you read something like "Thinking in C++" freely available
on the web. Your ideas about C++ are somewhat confused (by Java).


> From which I create two objects (using the default constructor),
> (1) MyClass *object1 = new MyClass(); // Stack


^^^^ stack ^^^^ heap

^^^ an object

^^^ a pointer,not an object

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
remember to do
delete object1;
at a certain point, below, when you don't need it anymore. You have no
garbage collector in C++!!


> (2) MyClass object2 = MyClass(); // Stack or Heap?


^^^^ stack ^^^^ stack
^^^ an object
^^^ an object (temporary and
immediately destroyed)
^^^ value of object copied from the temporary on the right

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ DON'T DO THIS (2) STUFF IN C++!!
do simply:
MyClass object2(....possible params...);



 
Reply With Quote
 
JKop
Guest
Posts: n/a
 
      09-19-2004
> DON'T DO THIS (2) STUFF IN C++!!


I always do it with POD types.

For instance, Microgay, opps I mean Microsoft, have the
likes of the following in their documentation:

FIND_DATA find_data;
memset(&find_data,sizeof(FIND_DATA),0);


While I, being a proficient C++ programmer, do:

FIND_DATA find_data = FIND_DATA();


Benefits of my method:

A) You don't mess with padding, which I believe is taboo...

B) If you have any pointers in there, then they'll get the
null pointer value, as opposed to simply "all bits zero".

C) YOu don't have the overhead of calling memset.


2 of my benefits are moot with Windows because:

A) You're allowed mess with padding
B) The null pointer value *is* "all bits zero"

But still, you don't have to call memset.

After that, the main advantage is that my code is fully
portable!

-JKop
 
Reply With Quote
 
Dave Townsend
Guest
Posts: n/a
 
      09-19-2004

>
> While I, being a proficient C++ programmer, do:
>
> FIND_DATA find_data = FIND_DATA();
>
>



Its a bit early on a Sunday for me to remember the distinction between
default initialization and the other sort, but the line of code
above, isn't it the same as

FIND_DATA find_data;

or for that matter....
FIND_DATA find_data( FIND_DATA() );

The original requires that you have a assignment operator, whereas
the second form does not. ( Well, I suppose the last one requires you
have a copy constructor).

yawn..


 
Reply With Quote
 
JKop
Guest
Posts: n/a
 
      09-19-2004
Dave Townsend posted:

>
> >
>> While I, being a proficient C++ programmer, do:
>>
>> FIND_DATA find_data = FIND_DATA();
>>
>>

>
>
> Its a bit early on a Sunday for me to remember the distinction between
> default initialization and the other sort, but the line of code
> above, isn't it the same as
>
> FIND_DATA find_data;
>
> or for that matter....
> FIND_DATA find_data( FIND_DATA() );


BULLSHIT.

Okay here goes:

int i;
char* p_blah;

Right now those two variables contain white noise, no particular value. A
piece of memory was just allocated, it wasn't zeroed.

struct Poo
{
int i;
char* p_blah;
};

Poo black;


Right now, "black.i" and "black.p_blah" contain white noise.

Here's how to get things set to their default value:

int i = int();
char* p_blah = char*();

Poo black = Poo();


Note that the above are all POD types.

When you're dealing with classes, then:

std::string k;
std::string k = string();

are identical, because the Constructor takes over.


> The original requires that you have a assignment operator, whereas
> the second form does not. ( Well, I suppose the last one requires you
> have a copy constructor).


As regards assignment operator... BULLSHIT, it's not involved at all.

std::string k = std::string();

is identical in every way to:

std::string k( std::string() );

As regards Copy Constructor, you're correct. If there's no copy contructor
defined, then the miranda one takes over.
If there's a copy constructor defined but it's private, then it doesn't
work.

So if you do:

FIND_DATA find_data;

Then it contains white noise. While if you do:

FIND_DATA find_data = FIND_DATA();

Then everything gets their default values, which for ints is 0, and for
pointers is the NULL pointer value, which may or may not be "all bits zero".


-JKop
 
Reply With Quote
 
mbcf78
Guest
Posts: n/a
 
      09-20-2004
JKop wrote:

> While I, being a proficient C++ programmer, do:
>
> FIND_DATA find_data = FIND_DATA();


Doesn't this have a *very bad* performance overhead?

You are first creating a temporary FIND_DATA type (the one on the right
side of = sign), so a space is created on the stack for it and then its
memory is zeroed.

Then you create a space also for the one on the left side and you call
the (implicit) copy constructor to copy the one on the right to the one
on the left, member by member (so there are N reads and N writes which
are just to copy zeroes...)

Seems very bad to me, compared to the Microsoft proposed way of just
writing zeroes once.

Or you can guarantee to me that some of these steps are optimized away
because of some specific known optimizations I am not aware of? Please tell.
 
Reply With Quote
 
Ioannis Vranos
Guest
Posts: n/a
 
      09-20-2004
JKop wrote:

> Okay here goes:
>
> int i;
> char* p_blah;
>
> Right now those two variables contain white noise, no particular value. A
> piece of memory was just allocated, it wasn't zeroed.
>
> struct Poo
> {
> int i;
> char* p_blah;
> };
>
> Poo black;
>
>
> Right now, "black.i" and "black.p_blah" contain white noise.



Unless they are declared global, static in a function, or in a
namespace.




> Here's how to get things set to their default value:



As it is written in TC++PL3:

"void f(double d)
{
int j = int() ; // default int value
complex z = complex() ; // default complex value
// ...
}

The value of an explicit use of the constructor for a built-in
type is 0 converted to that type (4.9.5).

Thus, int() is another way of writing 0. For a user-defined
type T, T() is defined by the default constructor (10.4.2), if any.

The use of the constructor notation for built-in types is particularly
important when writing templates. Then, the programmer does not know
whether a template parameter will refer to a built-in type or a
user-defined type (16.3.4, 17.4.1.2)."


So basically, its importance for built in types is when they are used
with templates.




> int i = int();
> char* p_blah = char*();



What about this:


int i=0;

char *p=0;


> Poo black = Poo();



This one is using the provided constructor (in this case the built in),
which does not necessarily initialise to 0.

For example:


struct Poo
{
int i;
char *p;

Poo() { i=1, p=new char[10]; }
};


int main()
{
Poo b;
}



--
Ioannis Vranos

http://www23.brinkster.com/noicys
 
Reply With Quote
 
E. Robert Tisdale
Guest
Posts: n/a
 
      09-21-2004
mbcf78 wrote:

> JKop wrote:
>
>> While I, being a proficient C++ programmer, do:
>>
>> FIND_DATA find_data = FIND_DATA();

>
> Doesn't this have a *very bad* performance overhead?


No.

> You are first creating a temporary FIND_DATA type
> (the one on the right side of = sign),
> so a space is created on the stack for it and then its memory is zeroed.
>
> Then you create a space also for the one on the left side and you call
> the (implicit) copy constructor to copy the one on the right to the one
> on the left, member by member


No.
A good optimizing C++ compiler will call the default constructor
to initialize find_data directly. The copy constructor will be elided.

> (so there are N reads and N writes which are just to copy zeroes...)
>
> Seems very bad to me
> compared to the Microsoft proposed way of just writing zeroes once.
>
> Or you can guarantee to me that some of these steps are optimized away
> because of some specific known optimizations I am not aware of?


This optimization is well known.
I used Google

http://www.google.com/
to search for

+"copy constructor" +"elided" +"C++"

and found lots of stuff.

> Please tell.

 
Reply With Quote
 
 
 
Reply

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off


Similar Threads
Thread Thread Starter Forum Replies Last Post
Why does std::stack::pop() not throw an exception if the stack is empty? Debajit Adhikary C++ 36 02-10-2011 08:54 PM
C/C++ compilers have one stack for local variables and return addresses and then another stack for array allocations on the stack. Casey Hawthorne C Programming 3 11-01-2009 08:23 PM
stack frame size on linux/solaris of a running application stack Surinder Singh C Programming 1 12-20-2007 01:16 PM
Why stack overflow with such a small stack? Kenneth McDonald Ruby 7 09-01-2007 04:21 AM
"stack level too deep"... because Threads keep their "starting" stack Sam Roberts Ruby 1 02-11-2005 04:25 AM



Advertisments