3

I read the below piece of information in a microsoft article;

https://support.microsoft.com/en-us/kb/44463

The text below presents an example of a common programming mistake, that is, confusing an array and a pointer declaration: Consider an application divided into several modules. In one module, declare an array as follows:

  signed char buffer[100];

In another module, declare the following variables to access the array:

 extern signed char *buffer;           // FAILS  
 extern signed char buffer[];          // WORKS

If you view the code in the CodeView debugger, it indicates that the *buffer declaration produces a different address than the buffer[] declaration does.

  1. But I can't understand why we cannot access that array using *buffer and we can access it using buffer[] .

  2. Someone please explain me what is the difference between those two types?

Andrew Flemming
  • 187
  • 8
  • 2
    This has to be a duplicate –  Jun 18 '15 at 17:51
  • I've always used them interchangeably. Getting different addresses makes no sense to me. – donjuedo Jun 18 '15 at 17:52
  • @Isaiah [A good read](http://stackoverflow.com/q/30892206/2173917) – Sourav Ghosh Jun 18 '15 at 17:53
  • 2
    possible duplicate of [C: differences between char pointer and array](http://stackoverflow.com/questions/1335786/c-differences-between-char-pointer-and-array) –  Jun 18 '15 at 17:54
  • 2
    Ok, pointers and arrays ARE NOT THE SAME. You're trying to tell the compiler to look for a pointer when its an array –  Jun 18 '15 at 17:56
  • It's not too humble, but I would reference [my own question](http://stackoverflow.com/questions/30533439/string-literals-vs-array-of-char-when-initializing-a-pointer) especially the accepted answer to it. – Eugene Sh. Jun 18 '15 at 17:57
  • 1
    In a nutshell: dereferencing a pointer is **one more indirection** than accessing an array. Code using the pointer declaration (when the identifier is an array) bombs because of the extra indirection. There's a super clear explanation of exactly this in Peter van der Linden's *"Expert C Programming - Deep C Secrets"*. – Jens Jun 18 '15 at 17:59
  • @Isaiah, You're right, and I do understand how to be careful with them. Does the different addresses comment puzzle you? – donjuedo Jun 18 '15 at 17:59
  • No, An array begins at the first location and ends at the last location, all contigious. A pointer lives in one location that stores the address of another location which could be completely different. @donjuedo –  Jun 18 '15 at 18:03
  • Can you please elaborate it @Isaiah – Andrew Flemming Jun 18 '15 at 18:04
  • Can you please tell me the page number where the topic is found @Jens – Andrew Flemming Jun 18 '15 at 18:05
  • @Isaiah, Yes, I understand that part. But both declarations are `extern`, so I'd expect both to link to the same symbol, and therefore same address. That's what I have trouble with. – donjuedo Jun 18 '15 at 18:13
  • @RelevationsSajith Chapter 4, **The Shocking Truth: C Arrays and Pointers Are NOT the Same!**, page 95pp. – Jens Jun 18 '15 at 18:22

5 Answers5

4
extern signed char buffer[];

is a chunk of memory that has an address.

extern signed char *buffer;

is a variable that may or may not point to a chunk of memory - it's a variable that contains an address that may or may not be valid.

Andrew Henle
  • 32,625
  • 3
  • 24
  • 56
2

In one module, you define an array of signed char of size 100 named buffer. This object will use 100 bytes of memory:

signed char buffer[100];

In another module, you declare buffer to be something else, a pointer to signed char, that is 4 or 8 bytes of memory that may hold the address of an array or that of a single char.

extern signed char *buffer;

The compiler only knows one module at a time, so it cannot check whether this declaration is consistent with the actual definition. It compiles code consistently with this declaration, emitting machine code that refers to an external symbol buffer that will be resolved at link time.

At link time, the linker does not know about types, it only relies on names. Therefore it resolves the references to buffer from one module with the actual address of the definition from the other module.

At runtime, you get undefined behaviour, because one module uses buffer as an array of signed char, which it is, and the other loads the value of a pointer from the same address, interpreting the bytes completely differently.

Declarations belong in header files and should always be included in the source file that actually defines the object declared in the header.

chqrlie
  • 131,814
  • 10
  • 121
  • 189
1

The differences between

extern signed char *buffer;
extern signed char buffer[];

is the same as you would see when you have

signed char *buffer;
signed char buffer[100];

in a function.

I see the following differences:

Difference 1

When you have:

extern signed char *buffer;

you can use:

buffer = malloc(10);

When you have:

extern signed char buffer[];

you cannot do that.

Difference 2

In the first case, it is possible for buffer to be NULL. In the second case, it is not.

Difference 3

&buffer result in different types. For example, you can use:

printf("pointer 1: %p\n", &buffer+1);

in the first case but you cannot use that in the second case. For &buffer+1 to work in the second case, you'll have to know the size of the array.

R Sahu
  • 204,454
  • 14
  • 159
  • 270
1

This question is more about C linker than about C language.

Although there is a context where signed char *buffer and signed char buffer[] mean the same thing, extern is not one of them. Using extern asks the compiler to defer resolving of the external definition to linker. Linker has to be very particular about the difference between pointers and arrays, because the two have different structure in memory, and cannot be treated interchangeably.

Note that although these declarations are different to the linker, they do not change what a programmer could do with such an external array: in both cases you have no access to the size of the declared array (i.e. 100), the syntax to access array elements stays the same, and the pointer arithmetic remains the same.

Sergey Kalinichenko
  • 714,442
  • 84
  • 1,110
  • 1,523
1

See these questions in the C FAQ List:

Steve Summit
  • 45,437
  • 7
  • 70
  • 103