What is the size of a char pointer?

What is the maximum size of a pointer to a char?

I went to allocate a char pointer using malloc to the size of 49,152 bytes, but for some reason, when I looked at a memory dump, it only allocated ~1300 bytes in memory.

Heres my code: (buffer is the pointer that is only allocated this meager amount of ~1300 bytes. I'm opening a file thats 49Kb and for some reason my compiler wont give it that amount of memory to work with. Is this some limitation of C?)

Code:

char * store(char filename[])
{
	char * buffer;
	long fileSize = 0;
	image = fopen(filename,"r");
	
	// Obtain the file size
	fseek(image, 0, SEEK_END);
	fileSize = ftell(image);
	rewind(image);

	buffer = malloc(sizeof(char) * fileSize);
	fread(buffer,1,fileSize,image);
	fclose(image);
	
	buffer = strToHexStr(buffer);
	
	return formatOuput(buffer);
}

You might be confusing yourself here. The size of a char * is probably 4 bytes on a 32-bit machine and 8 bytes on a 64-bit machine, etc. etc..

How much data a char * can point to is theoretically infinite. When you malloc() memory, all you know is that you're getting a block of memory that is contiguous (or NULL if the allocation failed). How much is allocated depends upon the underlying system.

What you should be doing is checking to see if fopen() and malloc() fail. To not check those return values is rather silly and just inviting problems to occur.

The amount of memory you can malloc() is operating-system dependent. Most operating systems let you allocate at least a few tens of megabytes, if your system has that much free. If your compiler/runtime won't let you do that, you're probably using a very old one. (Turbo C?)

But perhaps it's something wrong with your code. What happens when you run this program?

Code:

#include <stdio.h>

int main(void) {
    size_t size = 1;
    char *p = 0, *temp;

    for(;;) {
        temp = realloc(p, size);
        if(!temp) break;
        p = temp;

        printf("\rGot &#37;lu bytes", (unsigned long)size);

        size *= 2;
    }

    free(p);
    printf("\nFailed to get %lu bytes\n", (unsigned long)size);

    return 0;
}

sizeof(char) is always 1, and so you can leave it out.

/me slaps dwks for forgetting to #include <stdlib.h>.

Oops, I forgot my standard disclaimer:

This code has not been tested nor proved correct*. I have not tried to run it, I have not even tried to compile it. In fact, I made it up on the spur of the moment in the Quick Reply box.

It's probably full of bugs, like missing header files. I take no responsibility for bugs with it, e.g. your computer running vvveeeeeeerrrryyyy slowly after executing it.

* Donald E. Knuth once said: "Beware of bugs in the above code; I have only proved it correct, not tried it.''

> Is this some limitation of C?)
Lemme guess, another XP user trying to use Turbo C.

If 1GB is the size of a football field, then the 640K(max) that Turbo C will let you use is the size of a large table.

No, it's not a limitation of C at all, only of the poor choice of implementation of C.
Choose one which gives you full access to the whole machine.

> Is this some limitation of C?)
Lemme guess, another XP user trying to use Turbo C.

That's what I thought at first -- but even Turbo C should let the user allocate "49,152 bytes" of memory, assuming the machine has that much free. Unless the memory model is set to some very small value or something.

Code:

buffer = strToHexStr(buffer);

What function is this? Is the problem in there, perhaps?

If your code is messing up the memory, then it's entirely possible that you did get 49152 bytes of memory, but that size got corrupted by a buffer overrun or something. In fact, this is almost certainly what happened, assuming malloc() didn't return 0.

So, post the code to strToHexStr().