Thread: arrays dimensioning: malloc and sizeof

I'm not sure whether I'm doing this wrong or sizeof can't read arrays dimensioned with the memory allocation functions. Here's what I have:

Code:

#include <stdio.h>
#include <stdlib.h>

void main()
{	char *NEW_ARRAY;
	char NEW_ARRAY2[5];

	NEW_ARRAY = malloc(5 * sizeof(char));

	if(NEW_ARRAY != NULL)
	{	printf("&#37;d\n", sizeof(NEW_ARRAY));
		printf("%d\n", sizeof(NEW_ARRAY2));
	}

	free(NEW_ARRAY);
}

NEW_ARRAY returns 4 (no matter what I put in as the MALLOC size value)
NEW_ARRAY2 returns the correct number of 5 positions within the array.

Any ideas? The solution I'm using this in pulls characters from a static array. The amount of characters it pulls varies so I need to create a dynamic container character array.

What is NEW_ARRAY? Now look at what sizeof gives you.
What is NEW_ARRAY2? Now look at what sizeof gives you.

The sizeof operator gives you the size of what you pass it. You pass it a pointer, it tells you how big that pointer is.


Quzah.

ints are 2-bytes (2^16-1), doubles are 4 bytes(2^32-1), chars are one byte(2^8-1). All though ints are machine based and the OS can have them as for the current general standard is 2 bytes on a 32 bit machine.

Originally Posted by KoG Metalgod

ints are 2-bytes (2^16-1), doubles are 4 bytes(2^32-1), chars are one byte(2^8-1). All though ints are machine based and the OS can have them as for the current general standard is 2 bytes on a 32 bit machine.

Haven't seen the 2 byte ints for about 8 years... What time are you living in?

doubles are 8 bytes mostly, while floats are 4bytes length...

a 32 bit machine max is 2^32 -1, thats 32/8 (bytes/bits) which is 4 bytes max able to compuate on 1 variable on a 32 bit machine.

The required ranges for signed and unsigned int are identical to those for signed and unsigned short. On compilers for 8 and 16 bit processors (including Intel x86 processors executing in 16 bit mode, such as under MS-DOS), an int is usually 16 bits and has exactly the same representation as a short. On compilers for 32 bit and larger processors (including Intel x86 processors executing in 32 bit mode, such as Win32 or Linux) an int is usually 32 bits long and has exactly the same representation as a long.

A signed int can hold all the values between INT_MIN and INT_MAX inclusive. INT_MIN is required to be -32767 or less, INT_MAX must be at least 32767. Again, many 2's complement implementations will define INT_MIN to be -32768 but this is not required.

An unsigned int can hold all the values between 0 and UINT_MAX inclusive. UINT_MAX must be at least 65535. The int types must contain at least 16 bits to hold the required range of values.

A signed long can hold all the values between LONG_MIN and LONG_MAX inclusive. LONG_MIN is required to be -2147483647 or less, LONG_MAX must be at least 2147483647. Again, many 2's complement implementations will define LONG_MIN to be -2147483648 but this is not required.

An unsigned long can hold all the values between 0 and ULONG_MAX inclusive. ULONG_MAX must be at least 4294967295. The long types must contain at
least 32 bits to hold the required range of values.

and the proof is here:

Code:

#include <stdio.h>
#include <limits.h>

volatile int char_min = CHAR_MIN;

int main(void)
{
    printf("\n\n\n\n\n        Character Types\n");
    printf("Number of bits in a character: &#37;d\n",
        CHAR_BIT);
    printf("Size of character types is %d byte\n",
        (int)sizeof(char));
    printf("Signed char min: %d max: %d\n",
        SCHAR_MIN, SCHAR_MAX);
    printf("Unsigned char min: 0 max: %u\n",
        (unsigned int)UCHAR_MAX);

    printf("Default char is ");
    if (char_min < 0)
        printf("signed\n");
    else if (char_min == 0)
        printf("unsigned\n");
    else
        printf("non-standard\n");

    printf("\n        Short Int Types\n");
    printf("Size of short int types is %d bytes\n",
        (int)sizeof(short));
    printf("Signed short min: %d max: %d\n",
        SHRT_MIN, SHRT_MAX);
    printf("Unsigned short min: 0 max: %u\n",
        (unsigned int)USHRT_MAX);

    printf("\n           Int Types\n");
    printf("Size of int types is %d bytes\n",
        (int)sizeof(int));
    printf("Signed int min: %d max: %d\n",
        INT_MIN, INT_MAX);
    printf("Unsigned int min: 0 max: %u\n",
        (unsigned int)UINT_MAX);

    printf("\n        Long Int Types\n");
    printf("Size of long int types is %d bytes\n",
        (int)sizeof(long));
    printf("Signed long min: %ld max: %ld\n",
        LONG_MIN, LONG_MAX);
    printf("Unsigned long min: 0 max: %lu\n",
        ULONG_MAX);

    return 0;
}

Originally Posted by KoG Metalgod

a 32 bit machine max is 2^32 -1, thats 32/8 (bytes/bits) which is 4 bytes max able to compuate on 1 variable on a 32 bit machine.

Max for what?
Variable of what type?
For example for double it is
DBL_MAX 1.7976931348623158e+308 Maximum value

And it is a little bit more than 2^32 -1