variable size?

[TheMadHatter]

yello,

Quick Q:
With regards to ram use, there really isnt any memory savings if I use type
bool, vs int....... is there? If I remmeber correctly from a microcontroller
course, the smallest addressable unit is an int. All rules still apply for
todays machines, right?

Thanks in advance.

[jeremiah johnson]

TheMadHatter wrote:

yello,

Quick Q:
With regards to ram use, there really isnt any memory savings if I use type
bool, vs int....... is there? If I remmeber correctly from a microcontroller
course, the smallest addressable unit is an int. All rules still apply for
todays machines, right?

Thanks in advance.

well I don't know that, but I would imagine that when you create a bool,
the compiler allocates a single bit, and when you create an int, the
compiler allocates 8 bits, but i honestly don't know.

what I *do* know is that it is a very good idea to use the right types
in the right places, because it makes reading your code later much
easier. "why did he use an int to hold a true or a false (0 or 1)?
idiot" is heard often in places i've worked.

Strongly typed means strongly typed. Use Perl if you don't like typed
languages.

That's just my opinion.

[Brendan Grant]

In .NET, a Boolean value takes up 8 bits, even though only 1 bit is really
being used.

There are ways to address a single bit at a time and can be used by either
the programmer or the runtime, quite often that involves using a larger
variable (such as a 32 bit int) as a bit field and giving a meaning to each
bit and bit-masking each off as needed for reading and writing.

Brendan

"TheMadHatt er" wrote:

yello,

Quick Q:
With regards to ram use, there really isnt any memory savings if I use type
bool, vs int....... is there? If I remmeber correctly from a microcontroller
course, the smallest addressable unit is an int. All rules still apply for
todays machines, right?

Thanks in advance.

[Peter Rilling]

Also, compilers may opitmize the code. For instance, there is nothing
preventing the compiler from creating an int that represents 32 boolean
values and then just use pointer arithmetic and AND/OR operations to extract
the bit before casting it to a bool.

I don't know how the CLR is implemented, but I usually do not worry about
small details like you were asking.
"jeremiah johnson" <na*******@gmai l.com> wrote in message
news:OC******** ******@TK2MSFTN GP09.phx.gbl...

TheMadHatter wrote:

yello,

Quick Q:
With regards to ram use, there really isnt any memory savings if I use
type bool, vs int....... is there? If I remmeber correctly from a
microcontroller course, the smallest addressable unit is an int. All
rules still apply for todays machines, right?

Thanks in advance.

well I don't know that, but I would imagine that when you create a bool,
the compiler allocates a single bit, and when you create an int, the
compiler allocates 8 bits, but i honestly don't know.

what I *do* know is that it is a very good idea to use the right types in
the right places, because it makes reading your code later much easier.
"why did he use an int to hold a true or a false (0 or 1)? idiot" is heard
often in places i've worked.

Strongly typed means strongly typed. Use Perl if you don't like typed
languages.

That's just my opinion.

[Michael C]

"jeremiah johnson" <na*******@gmai l.com> wrote in message
news:OC******** ******@TK2MSFTN GP09.phx.gbl...

well I don't know that, but I would imagine that when you create a bool,
the compiler allocates a single bit, and when you create an int, the
compiler allocates 8 bits, but i honestly don't know.
This isn't correct. An int is stored in 32 bits and a boolean is stored as
8, 16 or 32 bits depending on the language. I think C# uses 32bits but I'm
not certain. I doubt it will use any optimisations to reduce that number of
bits, especially when that bool value is in an array.
what I *do* know is that it is a very good idea to use the right types in
the right places, because it makes reading your code later much easier.
"why did he use an int to hold a true or a false (0 or 1)? idiot" is heard
often in places i've worked.

That's true although the op may save much memory by using a byte instead of
bool if it's a large array.

Michael

[Mattias Sjögren]

> I think C# uses 32bits but I'm not certain.

No, a bool in C# (and in general a System.Boolean in any .NET language) is
one byte...

That's true although the op may save much memory by using a byte instead of
bool if it's a large array.

.... so there's no point in using byte over bool.
Mattias

[Willy Denoyette [MVP]]

"Michael C" <mc*****@NOSPAM optushome.com.a u> wrote in message
news:uQ******** *****@tk2msftng p13.phx.gbl...

"jeremiah johnson" <na*******@gmai l.com> wrote in message
news:OC******** ******@TK2MSFTN GP09.phx.gbl...

well I don't know that, but I would imagine that when you create a bool,
the compiler allocates a single bit, and when you create an int, the
compiler allocates 8 bits, but i honestly don't know.

This isn't correct. An int is stored in 32 bits and a boolean is stored as
8, 16 or 32 bits depending on the language. I think C# uses 32bits but I'm
not certain. I doubt it will use any optimisations to reduce that number
of bits, especially when that bool value is in an array.

This isn't correct also, the CLI Boolean type is 8 bits, the language has
nothing to do with this, this is the whole point of the Common Type System.
Willy.

[Marcus Andrén]

On Mon, 3 Oct 2005 14:24:02 -0700, TheMadHatter
<Th**********@d iscussions.micr osoft.com> wrote:

yello,

Quick Q:
With regards to ram use, there really isnt any memory savings if I use type
bool, vs int....... is there? If I remmeber correctly from a microcontroller
course, the smallest addressable unit is an int. All rules still apply for
todays machines, right?

Thanks in advance.

If you need to save memory by storing boolean values in a more compact
way use System.BitArray . It only uses 1 bit per boolean plus the usual
overhead for being a class.

Here is the size in bytes of the basic value types:

1 sbyte,byte,bool
2 short,ushort,ch ar
4 int,uint,float
8 long,ulong,doub le

The following may vary depending on Hardware/Implementation, but I
will use my computer, an ordinary PC running in 32-bit mode using .Net
2.0 Beta 2.

IntPtr,Referenc e: 4 (On a PC running in 64-bit mode it would be 8)

Object Instance: 8 + size of fields (Minimum total size of 12, Always
divideable by 4)

Struct: size of fields (Minimum of 1)

Array: 12 bytes + size of content (Total size always divideable by 4,
Much like an object instance)

Examples:

// 8+4+2+2+1 = 18 => Round up to 20 bytes per instance
class Test
{
int A; short B; char c; byte d; byte e;
}

Test[] t = new Test[1000000]; // 12 + 4 * 1 000 000 bytes (references)
for(int i=0;i<t.Length; i++)
t[i] = new Test() // 20 * 1 000 000 bytes (instances)

//For a total of 24 000 012 bytes

// 4 + 2 + 2 + 1 = 9
struct Test2
{
int A; short B; char c; byte d; byte e;
}

Test2[] = new Test2[1000000] //12 + 10 000 000 bytes

// For a total of 10 000 012 bytes

--
Marcus Andrén

[Willy Denoyette [MVP]]

Some small corrections (***).

Willy.

"Marcus Andrén" <a@b.c> wrote in message
news:o3******** *************** *********@4ax.c om...

On Mon, 3 Oct 2005 14:24:02 -0700, TheMadHatter
<Th**********@d iscussions.micr osoft.com> wrote:

yello,

Quick Q:
With regards to ram use, there really isnt any memory savings if I use
type
bool, vs int....... is there? If I remmeber correctly from a
microcontroll er
course, the smallest addressable unit is an int. All rules still apply for
todays machines, right?

Thanks in advance.
If you need to save memory by storing boolean values in a more compact
way use System.BitArray . It only uses 1 bit per boolean plus the usual
overhead for being a class.

Here is the size in bytes of the basic value types:

1 sbyte,byte,bool
2 short,ushort,ch ar
4 int,uint,float
8 long,ulong,doub le

The following may vary depending on Hardware/Implementation, but I
will use my computer, an ordinary PC running in 32-bit mode using .Net
2.0 Beta 2.

IntPtr,Referenc e: 4 (On a PC running in 64-bit mode it would be 8)

Object Instance: 8 + size of fields (Minimum total size of 12, Always
divideable by 4)

Struct: size of fields (Minimum of 1)

Array: 12 bytes + size of content (Total size always divideable by 4,
Much like an object instance)

Examples:

// 8+4+2+2+1 = 18 => Round up to 20 bytes per instance

*** 8+4+2+2+1+1 = 18 => Round up to 20 bytes per instance
class Test
{
int A; short B; char c; byte d; byte e;
}

Test[] t = new Test[1000000]; // 12 + 4 * 1 000 000 bytes (references)
for(int i=0;i<t.Length; i++)
t[i] = new Test() // 20 * 1 000 000 bytes (instances)

//For a total of 24 000 012 bytes

// 4 + 2 + 2 + 1 = 9
*** // 4 + 2 + 2 + 1 + 1 = 10
struct Test2
{
int A; short B; char c; byte d; byte e;
}

Test2[] = new Test2[1000000] //12 + 10 000 000 bytes

// For a total of 10 000 012 bytes

*** Test2 is 12 bytes in total : 4 + 2 + 2 + 1 + 1 = 10 rounded up to the
nearest multiple of int size, makes 12

So total size of Test2 array of 1000000 elements is 120012 bytes.

Note that this is valid for the current versions of the (32bit) CLR but is
in no way guaranteed, the CLR is free to map field elements as it sees fit.

Willy.

[Marcus Andrén]

On Tue, 4 Oct 2005 13:26:23 +0200, "Willy Denoyette [MVP]"
<wi************ *@telenet.be> wrote:

Some small corrections (***).

** Cut correction of typos **

struct Test2
{
int A; short B; char c; byte d; byte e;
}

Test2[] = new Test2[1000000] //12 + 10 000 000 bytes

// For a total of 10 000 012 bytes

*** Test2 is 12 bytes in total : 4 + 2 + 2 + 1 + 1 = 10 rounded up to the
nearest multiple of int size, makes 12

So total size of Test2 array of 1000000 elements is 120012 bytes.

Note that this is valid for the current versions of the (32bit) CLR but is
in no way guaranteed, the CLR is free to map field elements as it sees fit.

Willy.

Aah.. Did some more tests with structs. The current CLR apparently
aligns structs to the biggest primitive in the struct.

So if you only have shorts and bytes, total struct memory size is
divideable by 2, but if you add a single long the total struct memory
size has to be dividable by 8.

Classes memory size however seem to only have to be dividable by 4
even though it contains long fields. Should have tested a little more
before posting I guess :)

As you said, and as I noted in my first post, this is all for the
current CLR and may differ between implementations .

--
Marcus Andrén