Array unallocated space in c

Cyhaxor · 12-01-2009, 05:38 PM

Hello there,

I am trying to determine whether a particular element in an array is empty in C without using malloc() standard library function. Here is an example code:

Code:

#include <stdio.h>

int main(void)
{
  int array[5];
  array[0] = 10;
  array[1] = 20;

  /* a code that checks each element of the array and determine if it contains a value or its empty */
}

I've tried if(array[2] == NULL) but it doesn't seem to work.

Notice: that not all the elements are initializes therefore [2-4] must be empty(NULL(?)).

Thanks in advance.

ammorais · 12-01-2009, 05:42 PM

Quote:

Originally Posted by Cyhaxor

Hello there,

I am trying to determine whether a particular element in an array is empty in C without using malloc() standard library function. Here is an example code:

Code:

#include <stdio.h>

int main(void)
{
  int array[5];
  array[0] = 10;
  array[1] = 20;

  /* a code that checks each element of the array and determine if it contains a value or its empty */
}

I've tried if(array[2] == NULL) but it doesn't seem to work.

Notice: that not all the elements are initializes therefore [2-4] must be empty(NULL(?)).

Thanks in advance.

A C array allways points to an address on memory(and it reserves this space). The value of array is undetermined before any value is assigned.
The array space is allocated at the beginning of the program, on the contrary with malloc that dynamically allocates space.

[EDIT]
There's no such thing as NULL values. There are NULL pointers(pointers that point to 0). For example a byte(char) variable has allwas a value between 0-255. There can't be "char var = NULL". A pointer can be NULL: "char* var == NULL)

Cyhaxor · 12-01-2009, 05:58 PM

Ok I can see what you're trying to say but other than that, is there any way to determine that a particular element of an array has not been initialized to any value i.e the programmer has not manually specified the value of an element at a particular index?

[EDIT]
Actually what I am trying to do is to set a pointer pointing on the address of the first "empty" element in an array.

ammorais · 12-01-2009, 06:06 PM

No. Take look at this example

unsigned char var[10];

Each position of the array will always have an undetermined value between 0-255 before any value is assigned.
for example:
var[0] can have any value from 0-255. Even if the value was 0(there is the possibility of some compilers initialize the array to 0, but I don't know any), it's impossible to know if it was a value assigned or not.
An alternative method is a dynamic array of pointers initialized with NULLS.

sundialsvcs · 12-01-2009, 06:06 PM

It contains garbage. It's not initialized to any particular value...

Can you spell, "segfault?"

Cyhaxor · 12-01-2009, 06:17 PM

Ok I understand! Thank you very much

raconteur · 12-01-2009, 06:30 PM

Why not initialize each element of the array to an invalid value ( 0 or -1 or whatever you wish)?

Code:

  int array[5];
  memset(array, -1, 5);

  array[0] = 10;
  array[1] = 20;

Daring to venture into the realm of style, I recommend always initializing variables of any type, arrays in particular.

ammorais · 12-01-2009, 06:36 PM

Quote:

Originally Posted by raconteur

Why not initialize each element of the array to an invalid value ( 0 or -1 or whatever you wish)?

Code:

  int array[5];
  memset(array, -1, 5);

  array[0] = 10;
  array[1] = 20;

Daring to venture into the realm of style, I recommend always initializing variables of any type, arrays in particular.

I was going to also suggest that but OP specified specifically that it wanted to know before the array is actually initialized.

Quote:

i.e the programmer has not manually specified the value of an element at a particular index?

rupertwh · 12-01-2009, 07:25 PM

Quote:

Originally Posted by raconteur

Code:

  int array[5];
  memset(array, -1, 5);

That memset() doesn't do what you meant it to do...

chrism01 · 12-01-2009, 07:29 PM

There's a good discussion of array initialisation here http://stackoverflow.com/questions/1...-default-value

sundialsvcs · 12-02-2009, 09:04 AM

When a standard "C" array is allocated, its contents are unpredictable. It is literally impossible, therefore, to determine if the value is garbage or not.

This is why languages like C++ and Delphi make various promises to you about what newly-allocated memory blocks shall contain. And, it's why they make so much use of dynamic storage allocation, and dynamic data structures.

After all, there are really two reasons for using "an array." One is that you actually want to reserve and refer-to a contiguous block of bytes. The other, more common purpose is that you want to refer to a collection of items by means of a numeric index. For the latter purpose, an array has the disadvantage of being of a fixed size, and also wasteful if the actual distribution of values is sparse.

There's a reason why "C" is used most-often as "a tool to build other tools in." I am not speaking against it as a tool; merely pointing out that it is a comparatively low-level tool.

raconteur · 12-02-2009, 01:34 PM

Quote:

Originally Posted by rupertwh

That memset() doesn't do what you meant it to do...

I know, I was in a hurry.

Code:

  memset(array, -1, sizeof(int) * 5);

Fixed.

johnsfine · 12-02-2009, 01:38 PM

Quote:

Originally Posted by raconteur

I know, I was in a hurry.

Code:

  memset(array, -1, sizeof(int) * 5);

Looks like you were still in a hurry. Your fixed version is correct, but not good. An arbitrary constant (the 5) in one place is semi OK. But in two places that need to match each other is bad code. Even needing int in both places is questionable. Simpler and better:

Code:

  memset(array, -1, sizeof(array));

raconteur · 12-02-2009, 02:05 PM

Quote:

Originally Posted by johnsfine

Looks like you were still in a hurry. Your fixed version is correct, but not good. An arbitrary constant (the 5) in one place is semi OK. But in two places that need to match each other is bad code. Even needing int in both places is questionable. Simpler and better:

Code:

  memset(array, -1, sizeof(array));

Agreed.

wje_lq · 12-02-2009, 02:36 PM

Quote:

Originally Posted by johnsfine

Simpler and better:

Code:

  memset(array, -1, sizeof(array));

In this precise context, yes. But it's not a good overall formula. Consider the following code snippet:

Code:

#define ELEMENT_COUNT 5
int *array;
array=malloc(ELEMENT_COUNT*sizeof(int));
if(array==NULL)
{
  /* error recovery code goes here */
}
else
{
  /* wipes out not the array, but the pointer: */

  memset(array,-1,sizeof(array));
}

I know many people here will know this already, but I want to make it explicit for anyone else.

Edit:

I blew it. This code does wipe out part of the array, but only the first n bytes of the array, where n is the size of a pointer in your system.