You are currently offline, waiting for your internet to reconnect

How To Difference Between Arrays and Pointers in C

This article was previously published under Q44463
SUMMARY
The text below presents an example of a common programming mistake, thatis, 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.
MORE INFORMATION
The following declarations are NOT the same:
   char *pc;   char ac[20];				
The first declaration allocates memory for a pointer; the secondallocates memory for 20 characters.

A picture of pc and ac in memory might appear as follows:
    pc  +--------+        |   ???  |        +--------+    ac  +-----+-----+-----+-----+     +-----+        |  ?  |  ?  |  ?  |  ?  | ... |  ?  |        +-----+-----+-----+-----+     +-----+				
Neither are the following the same:
   extern char *pc;   extern char ac[];				
The first declaration indicates that another module allocated either two orfour bytes for a pointer to char named pc while the second indicates thatanother module allocated an array (of some unspecified length) named ac.

The steps required to address pc[3] and ac[3] are different. The onesimilarity is that the expression "ac" is a constant pointer to char thatpoints to &ac[0].

To evaluate pc[3], load the value of the pointer pc from memory and add 3.Then load the character stored ad this location (pc + 3) into a register.Assuming the small memory model, the appropriate MASM code might look likethe following:
   MOV     BX, pc          ; move *CONTENTS* of pc into BX                           ; BX contains 1234   MOV     AL, [BX + 3]    ; move byte at pc + 3 (1237) into AL                           ; ==> AL contains 'd'				
An appropriate diagram might appear as follows, provided that pc has beenset to point to an array at location 1234 and that the first four positionsof the array contain the string "abcd":
address:   1000                  1234  1235  1236  1237    pc  +--------+--->>>>>------v-----v-----v-----v-----+        |  1234  |          *pc |  a  |  b  |  c  |  d  | ...        +--------+              +-----+-----+-----+-----+                                 pc[0] pc[1] pc[2] pc[3]                                 *pc   *(pc+1) and so on				
NOTE: If you use pc without first initializing it properly causes yourapplication to access random memory which can cause undesired behavior. Toinitialize the pointer, include a line of code such as "pc = malloc(5);" or"pc = ac;".

Because ac is a constant, it can be stored in the final MOV instruction,which eliminates two MOV instructions. The MASM code might look like thefollowing:
   MOV     AL, [offset ac + 3]     ; move byte at ac + 3 into AL                                   ; offset ac is 1100, so move                                   ; byte at 1103 into AL                                   ; ==> AL contains 'd'				
The corresponding picture might appear as follows:
address: 1100  1101  1102  1103        1119    ac  +-----+-----+-----+-----+     +-----+        |  a  |  b  |  c  |  d  | ... |  \0 |        +-----+-----+-----+-----+     +-----+        ac[0] ac[1] ac[2] ac[3]       ac[19]        *ac   *(ac+1)  and so on				
NOTE: If you first initialize pc to point to ac (by including the line "pc= ac;" in your application), then the end result of the two statements isidentical. To see this in the picture, set pc to contain the address of ac,1100. However, the instructions used to generate these effects are quitedifferent.

If you declare ac as follows, the compiler generates code to performpointer-type addressing rather than array-type addressing:
   extern char *ac;  // WRONG!				
The compiler uses the first few bytes of the array as an address (ratherthan as characters) and accesses the memory stored at that (unintended)location.
8.00
Properties

Article ID: 44463 - Last Review: 07/05/2005 22:25:00 - Revision: 2.2

  • Microsoft C Professional Development System 6.0a
  • Microsoft Visual C++ 1.0 Professional Edition
  • Microsoft Visual C++ 1.5 Professional Edition
  • Microsoft Visual C++ 1.51
  • Microsoft Visual C++ 1.52 Professional Edition
  • Microsoft Visual C++ 2.0 Professional Edition
  • Microsoft Visual C++ 2.1
  • Microsoft Visual C++ 4.0 Standard Edition
  • Microsoft Visual C++ 5.0 Enterprise Edition
  • Microsoft Visual C++ 6.0 Enterprise Edition
  • Microsoft Visual C++ 5.0 Professional Edition
  • Microsoft Visual C++ 6.0 Professional Edition
  • Microsoft Visual C++, 32-bit Learning Edition 6.0
  • kbhowto kblangc KB44463
Feedback