Using pointer for crossing over all elements in INTEGER array

Is there a way to cross over all elements in integer array using po开发者_StackOverflow中文版inter ( similiar to using pointer to cross over string elements).I know that integer array is not NULL terminated so when I try to cross over array using pointer it overflows.So I added NULL as a last element of an array and it worked just fine.

int array[7]={1,12,41,45,58,68,NULL};
int *i;
for(i=array;*i;i++)
    printf("%d ",*i);

But what if one of the elements in array is 0 ,that will behave just as NULL.Is there any other way that will implement pointer in crossing over all elements in integer array?

In general, no unless you pick a sentinel value that's not part of the valid range of the data. For example, the valid range might be positive numbers, so you can use a negative number like -1 as a sentinel value that indicates the end of the array. This how C-style strings work; the NULL terminator is used because it's outside of the valid range of integers that could represent a character.

However, it's usually better to somehow pair up the array pointer with another variable that indicates the size of the array, or another pointer that points one-past-the-end of the array.

In your specific case, you can do something like this:

// Note that you don't have to specify the length of the array.
int array[] = {1,12,41,45,58,68};
// Let the compiler count the number of elements for us.
int arraySize = sizeof(array)/sizeof(int);
// or int arraySize = sizeof(array)/sizeof(array[0]);

int main()
{
    int* i;
    for(i = array; i != array + arraySize; i++)
        printf("%d ",*i);
}

You can also do this:

int arrayBegin[] = {1,12,41,45,58,68};
int* arrayEnd = arrayBegin + sizeof(arrayBegin)/sizeof(arrayBegin[0]);

int main()
{
    int* i;
    for(i = arrayBegin; i != arrayEnd; i++)
        printf("%d ",*i);
}

But given only a pointer, no you can't know how long the array it points to is. In fact, you can't even tell if the pointer points to an array or a single object! (At least not portably.)

If you have functions that must accept an array, either have your function require:

• the pointer and the size of the array pointed by the pointer,
• or two pointers with one pointing to the first element of the array and one pointing one-past-the-end of the array.

I'd like to give some additional advice: Never use some kind of sentinel/termination value in arrays for determining their bounds. This makes your programs prone to error and is often the cause for security issues. You should always store the length of arrays to limit all operations to their bounds and test against that value.

In C++ you have the STL and its containers.

In C you'll effectively end up using structures like

typedef struct t_int_array 
{
    size_t length;
    int data[1]; /* note the 1 (one) */
} int_array;

and a set of manipulation functions like this

int_array * new_int_array(size_t length)
{
    int_array * array;
    /* we're allocating the size of basic t_int_array 
      (which already contains space for one int)
      and additional space for length-1 ints */
    array = malloc( sizeof(t_int_array) + sizeof(int) * (length - 1) );
    if(!array)
        return 0;
    array->length = length;
    return array;
}

int_array * concat_int_arrays(int_array const * const A, int_array const * const B);
int_array * int_array_push_back(int_array const * const A, int const value);
/* and so on */

This method will make the compiler align the t_int_array struct in a way, that it's optimal for the targeted architecture (also with malloc allocation), and just allocating more space in quantities of element sizes of the data array element will keep it that way.

The reason that you can iterate across a C-style string using pointers is that of the 256 different character values, one has been specifically reserved to be interpreted as "this is the end of the string." Because of this, C-style strings can't store null characters anywhere in them.

When you're trying to use a similar trick for integer arrays, you're noticing the same problem. If you want to be able to stop at some point, you'll have to pick some integer and reserve it to mean "this is not an integer; it's really the end of the sequence of integers." So no, there is no general way to take an array of integers and demarcate the end by a special value unless you're willing to pick some value that can't normally appear in the string.

C++ opted for a different approach than C to delineate sequences. Instead of storing the elements with some sort of null terminator, C++-style ranges (like you'd find in a vector, string, or list) store two iterators, begin() and end(), that indicate the first element and first element past the end. You can iterate over these ranges by writing

for (iterator itr = begin; itr != end; ++itr)
    /* ... visit *itr here ... */

This approach is much more flexible than the C-string approach to defining ranges as it doesn't rely on specific properties of any values in the range. I would suggest opting to use something like this if you want to iterate over a range of integer values. It's more explicit about the bounds of the range and doesn't run into weird issues where certain values can't be stored in the range.

Apart from the usual suggestion that you should go and use the STL, you can find the length of a fixed array like this:

int array[6]={1,12,41,45,58,68};
for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
{ }

If you use a templated function, you can implicitly derive the length like this:

template<size_t len> void func(int (&array)[len])
{
    for (int i = 0; i < len; ++i) { }
}

int array[6]={1,12,41,45,58,68};
func(array);

If 0 is a value that may occur in a normal array of integers, you can specify a different value:

const int END_OF_ARRAY = 0x80000000;
int array[8]={0,1,12,41,45,58,68,END_OF_ARRAY};
for (int i = 0; array[i] != END_OF_ARRAY; ++i)
{ }

If every value is a possibility, or if none of the other approaches will work (for example, a dynamic array) then you have to manage the length separately. This is how strings that allow embedded null characters work (such as BSTR).

In your example you are using (or rather abusing) the NULL macro as a sentinel value; this is the function of the NUL('\0') character in a C string, but in the case of a C string NUL is not a valid character anywhere other than as the terminal (or sentinel) value .

The NULL macro is intended to represent an invalid pointer not an integer value (although in C++ when implicitly or explicitly cast to an int, its value is guaranteed to be zero, and in C this is also almost invariably the case). In this case if you want to use zero as the sentinel value you should use a literal zero not NULL. The problem is of course that if in this application zero is a valid data value it is not suitable for use as a sentinel.

So for example the following might suit:

static const int SENTINEL_VALUE = -1 ;
int array[7] = { 1, 12, 41, 45, 58, 68, SENTINEL_VALUE } ;
int* i ;

for( i = array; *i != SENTINEL_VALUE; i++ )
{
    printf( "%d ", *i ) ;
}

If all integer values are are valid data values then you will not be able to use a sentinel value at all, and will have to use either a container class (which knows its length) or iterate for the known length of the array (from sizeof()).

Just to pedanticize and expand a little on a previous answer: in dealing with integer arrays in C, it's vanishingly rare to rely on a sentinel value in the array itself. No(1) sane programmer does that. Why not? Because by definition an integer can hold any value within predefined negative/positive limits, or (for the nowadays-not-unusual 32-bit integer) 0 to 0xffffff. It's not a good thing to redefine the notion of "integer" by stealing one of its possible values for a sentinel.

Instead, one always(1) must(1) rely on a controlling up-to-date count of integers that are in the array. Suppose we are to write a C function that returns an int pointer to the first array member whose value is greater than the function's argument or, if there's no such member, returns NULL (all code is untested):`

int my_int_array[10];  // maximum of 10 integers in my_int_array[], which must be static
int member_count = 0;  // varies from 0 to 10, always holds number of ints in my_int_array[]
int *
first_greater_than ( int val ) {
  int i;
  int *p;
  for ( i = 0, p = my_int_array; i < member_count; ++i, ++p ) {
    if ( *p > val ) {
      return p;
    }
  }
  return NULL;
}

Even better is also to limit the value of i to never count past the last possible member of my_int_array[], i.e., it never gets bigger than 9, and p never points at my_int_array[10] and beyond:

int my_int_array[10];  // maximum of 10 integers in my_int_array[], which must be static
int member_count = 0;  // varies from 0 to 10, always holds number of ints in my_int_array[]
int *
first_greater_than ( int val ) {
#define MAX_COUNT sizeof(my_int_array)/sizeof(int)
  int  i;
  int* p;
  for ( i = 0, p = my_int_array; i < member_count && i < MAX_COUNT; ++i, ++p ) {
    if ( *p > val ) {
      return p;
    }
  }
  return NULL;
}

HTH and I apologize if this is just too, too elementary.

--pete

1. Not strictly true but believe it for now

In ANSI C it's very easy and shorter than solution before:

int array[]={1,12,41,45,58,68}, *i=array;
size_t numelems = sizeof array/sizeof*array;
while( numelems-- )
    printf("%d ",*i++);

Another way is to manage array of pointers to int:

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

#define MAX_ELEMENTS 10

int main() {
 int * array[MAX_ELEMENTS];
 int ** i;
 int k;

 // initialize MAX_ELEMENTS,1 matrix
 for (k=0;k<MAX_ELEMENTS;k++) {
  array[k] = malloc(sizeof(int*));
  // last element of array will be NULL pointer
  if (k==MAX_ELEMENTS-1)
    array[k] = NULL;
  else
    array[k][0] = k;
 }

 // now loop until you get NULL pointer
 for (i=array;*i;i++) {
  printf("value %i\n",**i);
 }

 // free memory
 for (k=0;k<MAX_ELEMENTS;k++) {
  free(array[k]);
 }

 return 0;
}

In this way loop condition is totally independent from the values of integers. But... for this to work you must use 2D array (matrix) instead of ordinary 1D array. Hope that helps.