Thread: size of a char pointer (*)

Originally posted by Garfield
Okay, I had this tid-bit of code and this output:

Code:

char *name;
fgets(name, sizeof(name), stdin);
printf("name = %s\n", name);

When I entered the string, "Garfield", the output was:
"Gar" (and this is NOT including the \n char). Why is this? Why not the whole string? What is the size of this pointer anyway and what is the problem with this code? Thanks...

--Garfield

one of the differnces between arrays and pointers is wrt to the sizeof operator
while
if you declare
char a[100];
sizeof(a) will be 100
so you in this case do
if you declare
char *a;
sizeof(a) will depend on your system , it will be usually around 4 bytes
just declaring
char *a; doesnt do anything ,a points to a randomly located memory location , accessing which may cause segment fault , you must allocate memory for it,
if you think that 100 is sufficient for your purpose
a=malloc(100);
then
fgets(a,100,stdin);


char *fgets(char *s, int n, FILE *stream);
char *s the string that will hold the result.
int n the maximum number of characters to read.
FILE *stream is an already existing stream.

Originally posted by Garfield
how do you make it more bytes?

I am sorry , in the above case it should be
fgets(a,99,stdin)
I forgot about the trailing '\0'

char name[20];
fgets(name, sizeof(name), stdin);
printf("name = %s\n", name);
return 0;

buffer being passed to the fgets is not big enough to store the
whatever u entering at command prompt

venu
[email protected]

Originally posted by Garfield
Oh, I see. So, I have to allocate the neccessary memory that I want (if I don't want 32 bits - 4 bytes) to be explicit. Thanks!

--Garfield

With a pointer, you ALWAYS must allocate memory, no matter the size.

When you do this:

char * charPtr;

you tell the program to allocate 4 bytes to store the ADDRESS of a string. The actual memory that the string will eventually go in is NOT yet allocated, and charPtr contains a RANDOM (aka garbage) address. You need to allocate memory to make this address point to an area of memory that has been allocated, otherwise you're writing your string into an unallocated section of memory, which isn't really a good idea (read: very very bad).

Also, when you allocate memory, you must free this memory when you're done with it.

A pointer, regardless of 'char*', 'int*' 'struct mystruct *', is the same size. A pointer is a variable that stores the memory address of whatever type it is designed to point at. Thus, a "char pointer" is designed to point-at a character. Since it is a pointer to a memory location, it stores the value of that memory location (it's address).

Code:

#include <stdio.h>

int main ( void ) {

    printf("char*  = %d bytes", sizeof ( char* ) );
    printf("int*   = %d bytes", sizeof( int* ) );
    printf("float* = %d bytes", sizeof( float* ) );
    return 0;
}

See? This is different than when you're comparing the 'sizeof' the actual variable.

To use a pointer, you declare one:

char *c; //character pointer, currently points to random memory address

Give it a value. Always do this first. You _have to_ initialize a pointer before using it, or bad things happen:

c = NULL;

You can generally do this in one shot:

char *c = NULL;

Now, if we have this:

char *c = NULL;
char array[10] = "Hello Bob";

We can do something like:

c = array;

Which sets c to store the value of the memory address that the array holds. (Maybe not the best explanation, but basicly, we're "pointing at" our array now.)

Now you can do something like:

puts( c );

Which should print "Hello Bob". (Less quotes.)

Quzah.

Originally posted by Garfield
Okay, I hate to beat a dead horse, but I'm still a little dazed and confused. I understand exactly what you are telling me about allocating, 4 bytes, etc. But what I don't understand can be found here in this code:

Code:

char *string;  /* This is legal, by my compiler */
string = "Garfield";

/* But if I would do this, then it would flag an error */
int *int_ptr;
*int_ptr = 4; /* This flags an error */

I know that I would have to allocate memory for the int_ptr to use it, but why wouldn't you have to do that for the char *? What I'm trying to say is why don't you treat char * and int * as the same way?

--Garfield

This is because of how strings are treated by the compiler.

When you say:

string = "Garfield";

you tell the compiler to include, in the data section of the program, the literal string "Garfield\0". Like all the data section, when you run the program, it is loaded into memory. So, the command string = "Garfield"; tells string to point at the memory location where the string "Garfield\0" is sitting in your program's data section. You need not allocate memory for "Garfield\0" because this is automatically allocated, and loaded into memory, when your program runs.

By contrast, a numeric literal is not loaded into the data section, it is used as an immediate operand. So,

*int_ptr = 4;

will segfault you because you never allocated memory for the int.

In general, memory is allocated automatically if:

1) You create a variable or an object.
2) You use a string literal

But it is not allocated if:

1) You create a pointer to a primitive or object. (Memory for the POINTER will be allocated automatically, but the memory it points AT is not allocated).