Question about sizeof a class.

[Abubakar]

Hi,
lets say I have the following class:

class AAA{};

if I do:
sizeof(AAA)
it gives me 1. Why is the size 1 ?

Regards,

Ab.

[Carl Daniel [VC++ MVP]]

Abubakar wrote:

Hi,
lets say I have the following class:

class AAA{};

if I do:
sizeof(AAA)
it gives me 1. Why is the size 1 ?

Because the minimum size of a class is required to be 1 by the C++ standard.

-cd

[Abubakar]

And why does the standard says that it should be 1?

Ab.

"Carl Daniel [VC++ MVP]" <cp************ *************** **@mvps.org.nos pam>
wrote in message news:uD******** ******@TK2MSFTN GP03.phx.gbl...

Abubakar wrote:

Hi,
lets say I have the following class:

class AAA{};

if I do:
sizeof(AAA)
it gives me 1. Why is the size 1 ?
Because the minimum size of a class is required to be 1 by the C++

standard.
-cd

[Arnaud Debaene]

Abubakar wrote:

And why does the standard says that it should be 1?

Because you should always be able to take the address of an object, and the
addresses of 2 distincts objects should always be different. This is
fundamental to be able to write generic code (template or otherwise) that
use pointers. The only way to fullfill those requirements is to always have
sizeof(somethin g) >=1

Arnaud
MVP - VC

[Mihajlo Cvetanoviæ]

So that the object can exist, have its place in memory, and be
identified as unique from other objects of the same class.

And why does the standard says that it should be 1?

Because the minimum size of a class is required to be 1 by the C++
standard.

[Abubakar]

Ok, got it. Thanks all.

Ab.

"Arnaud Debaene" <ad******@clu b-internet.fr> wrote in message
news:#4******** ******@TK2MSFTN GP04.phx.gbl...

Abubakar wrote:

And why does the standard says that it should be 1?
Because you should always be able to take the address of an object, and

the addresses of 2 distincts objects should always be different. This is
fundamental to be able to write generic code (template or otherwise) that
use pointers. The only way to fullfill those requirements is to always have sizeof(somethin g) >=1

Arnaud
MVP - VC

[Vladimir Nesterovsky]

>> And why does the standard says that it should be 1?

Because you should always be able to take the address of an object, and
the addresses of 2 distincts objects should always be different. This is
fundamental to be able to write generic code (template or otherwise) that
use pointers. The only way to fullfill those requirements is to always
have sizeof(somethin g) >=1

This in not always true taking unioun(s), or object containment, or
threading into account. Two different objects of the union can have same
address, or contained object can have the same address as a container
object.

After all, why should this be so fundamental for the generic code writing
(that uses pointers)? I believe generic code could survive without it.

I'd rather thought of "sizeof(somethi ng) >=1" as of heritage.
--
Vladimir Nesterovsky

[Nikolaos D. Bougalis]

Vladimir Nesterovsky wrote:

After all, why should this be so fundamental for the generic code writing
(that uses pointers)? I believe generic code could survive without it.
I'd rather thought of "sizeof(somethi ng) >=1" as of heritage.

What is the size of an array of zero-sized classes? How does one go
about accessing the 5th element of an array of such a class? How does
one go about incrementing a pointer to an array of such a class? How
does one compare two pointers to of such a class, to determine if they
are pointing to the same object? What does 'new' when applied to such a
class?

-n

[Arnaud Debaene]

"Vladimir Nesterovsky" <vl******@neste rovsky-bros.com> a écrit dans le
message de news: um************* @TK2MSFTNGP04.p hx.gbl...

And why does the standard says that it should be 1?
Because you should always be able to take the address of an object, and
the addresses of 2 distincts objects should always be different. This is
fundamental to be able to write generic code (template or otherwise) that
use pointers. The only way to fullfill those requirements is to always
have sizeof(somethin g) >=1

This in not always true taking unioun(s), or object containment, or
threading into account. Two different objects of the union can have same
address, or contained object can have the same address as a container
object.

- union is precisely the explicit exception tat allow 2 objects to overlap
(though I believe it is undefined to apply an unin to anything but primitive
types).
- One could argue that in the container/contained case, the contained object
*is* a sub-part of the container, and therefore thay can be seen as being
only one object (I agree this is dubious, especially in case of private
members).
- Concerning threading.... What's your point? My assertion has a meaning
only at one given point in time. Besides, the C++ language as, for now, no
notion of threads so the point is moot from a language definition point of
view.

After all, why should this be so fundamental for the generic code writing
(that uses pointers)? I believe generic code could survive without it.

I'd rather thought of "sizeof(somethi ng) >=1" as of heritage.

Heritage of what? Are you speaking about empty base optimization?

Arnaud
MVP - VC

[Vladimir Nesterovsky]

>> After all, why should this be so fundamental for the generic code writing

(that uses pointers)? I believe generic code could survive without it.

I'd rather thought of "sizeof(somethi ng) >=1" as of heritage. Heritage of what?

The issue could be resolved either way, but obviously not now.
Are you speaking about empty base optimization?

I'm speaking about the fact that many contemporary std:basic_strin g
implementations have "allocator" instance field, which mostly is an instance
of an empty class, and just wastes the space.
--
Vladimir Nesterovsky