Changing undefined values of an array - c

Question

lets think of a two dimensional array; which looks like this:
[1][2][3][4][undefined][undefined][undefined]
[5][6][7][8][undefined][undefined][undefined]
[9][0][1][2][undefined][undefined][undefined]
Can I change the undefined values with a for loop like this?
for (i=0;i<7;i++)
{ for (j=0;j<3;j++)
{
if (Arr[i][j]=="the value of undefined, which I wonder")
Arr[i][j]=0;
}
}
I remember using NULL keyword on C#, but that obviously doesnt work for C.
Thank you for your help!
Note: I dont need any other methods than that to solve the problem, just wondering if there is a keyword or phrase to help me solve it that way.

Answer 1

If the elements of the array are a floating-point type, you can use a NaN to indicate that they are not set to a number (in most C implementations; this is not in all C implementations but is common). You would have to initialize the array to contain NaNs; they will (generally) not be placed there by default.
If the elements of the array have another type, you would have to select a value to designate that the element has not been otherwise assigned yet, and that could create problems using the array normally.
After you #include <math.h>, you can test whether a C implementation supports NaNs with:
#if defined NAN
// NaNs are supported.
#else
#error "This program requires support for NaNs."
#endif
You can test whether an object x is a NaN with:
if (isnan(x)) …
You can set an object to a NaN with:
x = NAN;

Answer 2

In addition to Eric's answer, there are several other ways to handle this sort of situation in C, with varying amounts of extra baggage and mental grief. That is: these are ways to to express a value which represents undefined or unset values in your domain. We are not talking about the actual indeterminate values you will generally get back from your C implementation if you allocate an array without initializing it and then access it.
Method 1: NaN (not-a-number) values, as indicated in Eric's solution. Works in the specific case where you are manipulating floats, and there is no possibility that NaN is going to be used as a legitimate defined value in your domain. If you were storing characters, the null character '\0' might also be a reasonable choice for undefined.
Method 2: Pointers. C does have NULL, just like C#. However, it only applies if you're manipulating values of pointer types. So, instead of:
int a[3];
a[0] = 1;
a[1] = 2;
a[2] = 0; /* blech -- I really want this to mean 'undefined',
but what if I really needed 0 as a numeric value
in my array? In that case, this doesn't work! */
I could do this:
#include <stdlib.h>
int* integer_new(int i) {
int* result = (int*) malloc(sizeof(int));
*result = i;
return result;
}
int* a[3];
a[0] = integer_new(1);
a[1] = integer_new(2);
a[2] = NULL;
and now you have a value which can easily be tested and distinguished from your normal integer values. This is in theory what's going on behind the scenes in the C# code, I believe. But you can see the disadvantages pretty quickly: you have a bunch of heap-allocated objects now where you didn't before, and you now have to manage them, freeing them as appropriate when you're done with them.
There's a refinement of this if you're dealing with something like the flyweight pattern where these values are stack-allocated or pre-allocated elsewhere. In that case, you could just take the addresses of those values, stick them in the array, and not have to heap-allocate them yourself. But you still have to contend with an extra layer of indirection.
Method 3: The maybe pattern (which I'm stealing from Haskell). Something like this:
typedef struct maybe_int_ {
int has_value; /* 1 if yes, 0 if no */
int value;
} maybe_int;
maybe_int maybe_nothing(void) {
maybe_int result;
result.has_value = 0;
return result;
}
maybe_int maybe_just(int i) {
maybe_int result;
result.has_value = 1;
result.value = i;
return result;
}
maybe_int a[3];
a[0] = maybe_just(1);
a[1] = maybe_just(2);
a[2] = maybe_nothing();
This works better with the stack, so it's generally an improvement over pointers in that way, but you still have a lot more to deal with for bookkeeping.
Method 4: Unions. Similar to Method 3, but you might do something like this if you can have multiple kinds of values in your array:
typedef enum {
BOXED_TYPE_UNDEFINED,
BOXED_TYPE_INT,
BOXED_TYPE_FLOAT
} boxed_type;
typedef struct boxed_ {
boxed_type type;
union {
int int_value;
float float_value;
} u;
} boxed;
boxed boxed_undefined(void) {
boxed result;
result.type = BOXED_TYPE_UNDEFINED;
return result;
}
boxed boxed_int(int i) {
boxed result;
result.type = BOXED_TYPE_INT;
result.u.int_value = i;
return result;
}
boxed boxed_float(float f) {
boxed result;
result.type = BOXED_TYPE_FLOAT;
result.u.float_value = f;
return result;
}
boxed a[3];
a[0] = boxed_int(1);
a[1] = boxed_float(2.0f);
a[2] = boxed_undefined();
If you're already using a union plus a type discriminator, then this solution might be particularly easy to implement.
What do all these solutions have in common? The idea of a sentinel value: some value you're storing in your array which is guaranteed to not be used for anything else in your domain, so you're free to interpret it to mean an undefined value. As you can see, there are a lot of ways to inject sentinel values into your domain.
Here's one solution that doesn't involve sentinel values. Method 5: go outside the box.
int a[3];
unsigned char adef[3];
a[0] = 1; adef[0] = 1;
a[1] = 2; adef[1] = 1;
adef[2] = 0; /* I would set a[2] = 0 here as well
because I dislike uninitialized
array values! */
If you really can't muck with the values in your domain in any way that would allow you to define a sentinel value, then just store the extra "definedness" of values somewhere else. I've never had to resort to this myself, but I have found that the general technique of a separate table of related data does come in handy from time to time.

Answer 3

Let me say , there is no value means:"the value of undefined, which I wonder" , if you didn't initialized it , it is unkown value.

Answer 4

Arrays in C have undefined value if you do not initialize them to a value; That means it can be 0 0 0 0 0 900000 0 0 0 0 0 etc.
Yes there is a undefined value but as per the name it's well ...undefined - as in there is no set value.
You can just overwrite them like you are doing. . Even better though would be to use memset
The reason it's undefined is you're just getting a chunk of memory - anything could be sitting (value wise) in that memory.
edit: ok unless you static init the array of course.