C ++ size_t and ptrdiff_t for indexing a negative array

Question

I find it difficult to choose between size_t and ptrdiff_t for the index type, which should be able to store a negative value.

To be precise, in my code I need to implement an array. I get its length (in the constructor) as type size_t , and when I overload the [] operator , I need the index to be of type ptrdiff_t (not size_t ), since I want to allow negative indexes, as this example shows:

 std::size_t length = 50; MyVector<int> vec(length); vec[0] = 10; MyVector<int> vec2 = vec+1; std::cout << vec2[-1] << std::endl; //should print 10 

The problem that arises from this construction is that the range of available indexes is limited by the maximum ptrdiff_t value, and on some machines this upper limit is less than the maximum size_t value .

i.e. std::numeric_limits<std::ptrdiff_t>::max() < std::numeric_limits<std::size_t>::max()

So the problem is that the user can create an array with a size larger than the maximum ptrdiff_t value (but still in the size_t range, of course) , but he won’t have access to the elements of the array that prevail over the maximum value ptrdiff_t because their indexes overflow to a negative number. On my machine, this reduces the available indexes in half! (since both size_t and ptrdiff_t are 64 bits, but one is unsigned and the other is signed )

Here are the solutions I came up with, but, unfortunately, none of them are perfect:

• In the constructor, let's say a length of type ptrdiff_t instead of size_t and add a check that checks that the given length is not negative.

  Pros: Solves the problem, since now I could access all the elements in the array and still allow negative indexes.

  Cons: It limits the maximum possible length of the array. (for example, as I said earlier, on my machine it is cut in half)

• Leave things as they are, but in the [] operator enter an index to enter size_t , and use the fact that a negative value will overflow.

  i.e. to this index add the difference between the element we are currently pointing at, and

  for example, in my example before, since vec2 points to the second element in arary, the [] operator will look something like

   template<class T> T& MyVector<T>::operator[] (std::ptrdiff_t index) { //Since vec2 points to the second element, we add 1. //For vec, we would add 0 since it points at the //first element in the array. std::size_t actual_index = static_cast<std::size_t>(index + 1); //Do boundary checking return this->ptr[actual_index]; } 

  Pros: Now we can access all the elements in the array.

  Cons: Use becomes clumsy and ugly. For example, if we create a vector of size std::numeric_limits<std::size_t>::max() , then to access the last element we need to access the element '-1':

   MyVector<int> big_vector(std::numeric_limits<std::size_t>::max()); big_vector[-1] = 5; // big_vector[-1] is the last element in the array. MyVector<int> big_vector2 = big_vector + 1; std::cout << big_vector2[-2] << std::endl; // would print 5, since big_vector2 points at the second element in the array 

Answer 1

I find it difficult to choose between size_t and ptrdiff_t for the index type, which should be able to store a negative value.

Why did you limit yourself to size_t and ptrdiff_t? What about other integer types?

Do you have a real plan for implementing a container with elements of 4.294.967.296? (this is 2 ^ 32 ).

I don’t think that today there is a platform that will allocate so much memory - at least not on consumer-level computers. Do you work on specialized equipment?

For universal C ++, you can safely write the constructor std::size_t -accepting to the indexed class std::ptrdiff_t .

You may have to adjust the accepted index range so that if you accept negative indexes, the effective index range should be (-max32bit, max32bit).

This means that if you try to use a class with an index in the range (max32bit, max64bit), your class should throw an exception.

The std::size_t constructor in the constructor will make my decision (with clear documentation that the index ranges from -max ( ptrdiff_t ) to max ( ptrdiff_t ), and not from 0 to max ( std::size_t )). Then the class will be indexed using std::ptrdiff_t .