Accessing an array with a negative number!

Question

I am converting an extremely large and very old (25 years!) program from C to C++.

In it there are many (very very many) places where I access a global one dimensional UBYTE array using a variety of integer indexes. Occasionally this index may be negative.

I sometimes, but not always, trapped this case and made sure nothing went wrong, but as a belt and braces measure I actually went to the trouble of making sure that there was another chunk of memory immediately preceding the array and filled it with the right values such that if I accidentally omitted to trap the negative number condition then a correct answer would still be fetched in the array access. This actually worked fine for many many years.

But now under C++ it seems that accessing an array with a negative number behaves differently and now I have a program behaving badly. I fixed one case of an unhandled negative number and the program appears to be working fine, but I am nervous that I have not trapped all the negative numbers and there may be problems ahead.

So my question now is, is there a way, at runtime, for me to detect any instances of accessing arrays with negative indexes? I'll be impressed if anyone can come up with an answer. If you're pretty certain it can not be done in any automated way then telling me that is valuable information too.

I should just add that I'm not really a C++ programmer (yet). So far all I've done is the absolute bare minimum (almost nothing) to get the program to compile under a C++ compiler. So if your answer involves fancy "experts only, C++ solutions", then please try and explain in words of one syllable or give me a link so I can look it up.

Answer 1

the only way i can think of would be to wrap the array in a method that checks the index is positive.

Answer 2

Some kind of memory usage checker might work, particularly if you can force the array to its own page. I'd use valgrind on Linux, not sure what you'd use on Windows - purify?

Answer 3

Can you replace the global one-dimensional ubyte array with an object with overloaded operator[]? Using the absolute value of the int input might solve some of your issues.

Edit: Depending on the usage pattern of your array (no pointer shenanigans), using an object with overloaded operator[] could actually be entirely transparent to the users of the array, hence my suggestion.

Answer 4

Wrap it. In alternative, check if your compiler supports boundary checking. Worst case scenario, I would not put valid values in your array at negative numbers. I would put blatantly wrong values, so that you get a clearly wrong value when this occurs. You will not pinpoint the issue without a debugger, but at least you have a clear warning that somewhere, some code is doing it.

Answer 5

Personally I'd try to sort out why any of your indices could ever be negative; it's obvious that they will return an incorrect value so surely you shouldn't let the index to go negative?

Fix the code that allows them to go negative rather than trying to make a square plug fit into a circular hole (so to speak) ;)

Answer 6

Is there a way, at runtime, for me to detect any instances of accessing arrays with negative indexes?

Replace your global array by std::vector. Replace use of the array[index] syntax by

vector.at(index)

This does exactly what you ask for: it adds runtime array bound checks.

Answer 7

One thing you can do is you can check till what minimum value your indexes are going, and start filling your array from that index.

a[-i] = *(a - i)

so start with (a-i) as your base address instead of (a) so you will just shift your array and get desired values.

Answer 8

Do you know the bounds of the indices?

Reading the comment under Siyfion's answer, it seems like negative indices are allowed in your problem domain, and so there's no point in trying to force all indices to be positive. A better solution is to allow negative indices without breaking any language rules (which your C version also did btw. You were just lucky it didn't explode ;))

So if you know that the indices you're going to use are in the range -x to y, simply create an array of size x+y, and use a pointer to the xth element when accessing the array.

For example, assuming you need an array with indices -4 to 5:

int arr[10];
int* ptr = arr+4;
// use ptr when you need to index into the array:

ptr[-4]; // is valid, reads arr[0]
ptr[5]; // is valid, reads arr[9]

Of course the same could (and should) have been done in C.

Another piece of advice would be to not access the raw array directly. Define simple accessor functions instead. (for example, but not necessarily, by putting the array in a class. If you do put it in a class, you can overload operator[] so it'll even look like an array still)

The overhead of this is precisely zero (not "nearly zero, or "so close to zero you won't notice the difference", but zero. The generated code will be exactly the same as if you'd accessed the array directly), as the compiler will inline short functions, but it also allows you to insert extra checks so that you can verify in debug builds that you never go past the bounds of the array.