c gurus: whats the diff? "var[]" and "*var"?

kourama · 03-24-2007, 07:30 PM

I have used "char *var" and "char var[]" more or less interchangeably until it stopped working recently. I have seen the following problem on two occasions. The first time I thought it was a buggy compiler, now I think I might be missing a crucial piece of knowledge.

I have a function which refers to an external array of chars, very plan and boring. The following works:

extern volatile char myvar[];
.
.
char myothervar=myvar[0];

...and the following does not work:

extern volatile char *myvar;
.
.
char myothervar=myvar[0];

...Why aren't they equivalent? For example, why doesn't this fail:

char myvar[]="something";

char myfunc( char *ptr) { return ptr[0]; }
.
.
char myothervar=myfunc(myvar);

. Not a life-or-death problem, but it's something I'd like to understand.

thanks.

cjcox · 03-24-2007, 10:35 PM

Quote:

Originally Posted by kourama

I have used "char *var" and "char var[]" more or less interchangeably until it stopped working recently. I have seen the following problem on two occasions. The first time I thought it was a buggy compiler, now I think I might be missing a crucial piece of knowledge.

I have a function which refers to an external array of chars, very plan and boring. The following works:

extern volatile char myvar[];
.
.
char myothervar=myvar[0];

...and the following does not work:

extern volatile char *myvar;
.
.
char myothervar=myvar[0];

It's a subtle difference, but the first one says myvar is
a char array. The second says that myvar is a pointer
to character array.

Without the full context, it's hard to know what exactly
is failing. Both examples compile just fine for me.

Can you provide a bit more detail?

Quote:

...Why aren't they equivalent? For example, why doesn't this fail:

char myvar[]="something";

char myfunc( char *ptr) { return ptr[0]; }
.
.
char myothervar=myfunc(myvar);

. Not a life-or-death problem, but it's something I'd like to understand.

thanks.

How is it failing? More detail please.

slzckboy · 03-25-2007, 04:21 AM

Code bugs are nearly always down to the programmer.

You should always assume that the fault is with your code until you have exhausted every possibility.

char buffer[]="hello mum" allocates enough memory to store the string plus its null terminator.
thus you can reference buffer[0] or buffer[1] or buffer[4]

up until buffer[strlen(buffer)] where buffer[(strlen(buffer)]

will = '\0'

however...

Code:

extern volatile char *myvar;

you havn't inititialised *myvar to point to any memory within the memory space of your program.

Unless you have done so somewhere else in your code???

Thus it is a wild pointer pointing to some random location in memory,most probably a locaton in memory that your pogram dosn't have access to.

If you declare a pointer to char you have to make sure that it then points to something meaningful,i.e legal memory.

kourama · 03-25-2007, 10:01 AM

Here is an example with details (Sorry, the editor gobbled up my tabs, so the formatting is not pretty):

system details:
$ uname -a
Linux fnort 2.4.33.3 #1 Fri Sep 1 01:48:52 CDT 2006 i686 pentium4 i386 GNU/Linux

compiler:
$ gcc -v
Reading specs from /usr/lib/gcc/i486-slackware-linux/3.4.6/specs
Configured with: ../gcc-3.4.6/configure --prefix=/usr --enable-shared --enable-threads=posix --enable-__cxa_atexit --disable-checking --with-gnu-ld --verbose --target=i486-slackware-linux --host=i486-slackware-linux
Thread model: posix
gcc version 3.4.6

makefile:

Code:

$ cat Makefile
CC=gcc
COPTS=-Wall -g
SRCLIST=a.c b.c
OBJLIST= $(SRCLIST:.c=.o)
TARGET=a

$(TARGET) : $(OBJLIST)
        $(CC) $(COPTS) $(OBJLIST) -o $(TARGET)

$(OBJLIST) : %.o : %.c
        $(CC) $(COPTS) -c $<

clean :
        rm -f *.o

source1:

Code:

$ cat a.c
#include <stdio.h>
#include <stdlib.h>

char myarray0[]="foo";
char myarray1[]="bar";

extern void b( void );

void aa( char *arg0, char *arg1) {
  printf("aa says:\n");
  printf("&arg0=0x%08x\n",(int) arg0);
  printf("&arg1=0x%08x\n",(int) arg1);
  printf("\n");
}

int main(int argc, char **argv) {

  printf("a says:\n");
  printf("&myarray0=0x%08x\n",(int) myarray0);
  printf("&myarray1=0x%08x\n",(int) myarray1);
  printf("\n");
  aa(myarray0,myarray1);
  b();

  return 0;
}

source2:

Code:

$ cat b.c
#include <stdio.h>

extern char *myarray0;
extern char myarray1[];

void b( void ) {
  printf("b says:\n");
  printf("&myarray0=0x%08x\n",(int) myarray0);
  printf("&myarray1=0x%08x\n",(int) myarray1);
}

execution log:
$ a
a says:
&myarray0=0x0804974c
&myarray1=0x08049750

aa says:
&arg0=0x0804974c
&arg1=0x08049750

b says:
&myarray0=0x006f6f66
&myarray1=0x08049750

I've written functions like aa many times, but somehow, in 20+ years of C programming, I've never had occasion to use the "extern char *" line before. Actually I know why I've never used it before, I purposely avoided allowing one module to meddle with another's variables, but in the situation I'm in now, I can't avoid it.

So, the question is, why is there a semantic difference between the "char *" reference in the aa function's arglist and the "char *" reference in b's extern var list?

slzckboy · 03-25-2007, 12:37 PM

I would just do it like this,although I guess its not going to answer your question to your satisfaction?!!

a.c

Code:

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

char myarray0[]="foo";
char myarray1[]="bar";

void b( void );

void aa( char *arg0, char *arg1) {
        printf("aa says:\n");
        printf("&arg0=0x%08x\n",(int) arg0);
        printf("&arg1=0x%08x\n",(int) arg1);
        printf("\n");
}

int main(int argc, char **argv) {

        printf("a says:\n");
        printf("&myarray0=0x%08x\n",(int) myarray0);
        printf("&myarray1=0x%08x\n",(int) myarray1);
        printf("\n");

        aa(myarray0,myarray1);
        b();

        return 0;
 }

b.c

Code:

#include <stdio.h>


 void b( void ) {

 extern char myarray0[];
 extern char myarray1[];

 printf("b says:\n");
 printf("&myarray0=0x%08x\n",(int) myarray0);
 printf("&myarray1=0x%08x\n",(int) myarray1);
 }

output log

Code:

a says:
&myarray0=0x080495f4
&myarray1=0x080495f8

aa says:
&arg0=0x080495f4
&arg1=0x080495f8

b says:
&myarray0=0x080495f4
&myarray1=0x080495f8

p.s

pls try and use format tags wen posting your code.Thnks

slzckboy · 03-25-2007, 12:39 PM

I guess the way you were doing it the compiler was interpreting it as your declaring another external variable instead of referencing it against the previously declared one?!!

kourama · 03-25-2007, 04:57 PM

Quote:

Originally Posted by slzckboy

I guess the way you were doing it the compiler was interpreting it as your declaring another external variable instead of referencing it against the previously declared one?!!

If you look at the value that b gives for the address of myarray0, it is in fact the contents of the array (0x006f6f66 is "foo\0" in little-endian format). For some reason it dereferences the variable and returns value instead of address. If I refer to "&myarray0" instead of just "myarray0" I'll get the correct address of myarray0; this seems wrong to me.

Quote:

Originally Posted by slzckboy

p.s

pls try and use format tags wen posting your code.Thnks

Sorry for the ugliness, will fix.

bigearsbilly · 03-26-2007, 03:02 AM

Quote:

20+ years of C programming,

and you don't know the difference?
are you sure?

it's quite simple,

char buffer[100] is a buffer of memory that can store 100 bytes.
char *p is a pointer that typically points at a char buffer or array.

you must make sure that what *p points at is a valid buffer.

IBall · 03-26-2007, 06:52 AM

Don't you have to use malloc() if you want to create an array using *ptr?

I think this is equivalent:

Code:

char *string1 = "Hello World";
char string2[] = "Hello World";

But this is not allowed, as you have not assigned memory to the pointer:

Code:

char *string3;
*string3 = "Hello World";

--Ian

kourama · 03-26-2007, 09:24 AM

Quote:

Originally Posted by IBall

Don't you have to use malloc() if you want to create an array using *ptr?

I think this is equivalent:

Code:

char *string1 = "Hello World";
char string2[] = "Hello World";

But this is not allowed, as you have not assigned memory to the pointer:

Code:

char *string3;
*string3 = "Hello World";

--Ian

actually, what you're doing is valid, you just have a syntax error, what you want is:

char *string3;
string3="Hello World";

when you link, the "Hello World" string is stored in the .rodata section, and the variable string3 points to it. no problemo. Remeber that "Hello World" returns a pointer to that string, which is why your example above with string1 and string2 work. When you are declaring the variable, the '*' indicates that you mean a pointer. In the body of the code '*' means that your are derefrencing that pointer.

Quote:

Originally Posted by bigearsbilly

and you don't know the difference?
are you sure?

it's quite simple,

char buffer[100] is a buffer of memory that can store 100 bytes.
char *p is a pointer that typically points at a char buffer or array.

you must make sure that what *p points at is a valid buffer.

Yes, there's a conceptual difference in your example, but in the compiled code both are simply pointers to locations in memory. The "[100]" tells the linker to allocated enough space in the .bss or .data sections of your program (depending on whether or not it's initialized) and tells the compiler how many elements exist so that it can check to see if you do something bad like make a reference to buffer[125].

I appreciate the responses guys, but please pay attention to the example. There is no issue with initialization, the issue is that "char *" means something different when used to declare a reference to an external variable in b.c and when used to declare a reference to an argument in the aa function in a.c. Why is there a different meaning assigned when the context strongly suggests (IMHO) that they should be identical?

Maybe I should contact the GCC developers group on this one.

kourama · 03-26-2007, 03:26 PM

OK, a wiser sould than I pointed out the flaw in my thinking.

Here's what's going on:

In the declaration:

Code:

extern char *myarray0;

I am effectively casting the first 4 bytes of the array myarray0 from a.c to a pointer to an array, which is equivalent to

Code:

char *myarray0_in_b= (char *) (* (int *) myarray_in_a);

which is, of course, very wrong.

slzckboy · 03-26-2007, 05:11 PM

ouch...messy
well I'm glad you have satisfied your curiosity and got it clear in your head.

you can sleep easy now :0)

cheers

nmh+linuxquestions.o · 03-27-2007, 04:55 AM

Quote:

Originally Posted by slzckboy

ouch...messy
well I'm glad you have satisfied your curiosity and got it clear in your head.

you can sleep easy now :0)

cheers

I found the q&a enlightening (as one who does not usually work with c). Thanks for the question, answers and summary.

jim mcnamara · 03-27-2007, 08:46 AM

This is not good. Nobody mentioned the C99 standard and what it says:

1. char var[]="abc";
This creates an array of char which is modifable
2. char *var="abc";
This creates an array of char, the results of modifying it are unspecified.

FYI "unspecified" is a code word for "It may or may not work. But don't expect to be able to port the code just because some compiler writer was nice enough to make it work for your platform."
In short "don't modify it"

3. char *var=NULL; [ or char *var; ] is a pointer to char and is modifable.

bigearsbilly · 03-27-2007, 08:54 AM

of course,
"abc" is a constant string compiled in. which the compliler can put where it likes.
char *var is pointing to it.

some platforms may have read only data sections, which makes perfect sense, hence
it will spit it's dummy out if you write to it.

It's easy
char * should point at some previously allocated data.
char [] will have space allocated in your heap or stack space.

char [] is a buffer
char * is a pointer

you are responsible for not blowing holes in memory.