Is operator< (less than) on pointers consistent?

Question

Note: This question is not about total order. A total order on pointers of the same type can be obtained using std::less.

According to this, comparing two pointers with operator< isn't allowed if they point for example into different allocations.

In which sense isn't it allowed? Is it implementation defined, unspecified or undefined behaviour?

I think I read somewhere that it's unspecified. An implementation isn't required to document what the behaviour is, but there must be some behaviour. So that would mean, comparing any two pointers is still legal, but doesn't neccessarily yield a total order. Does that mean, that we still have to get a consistent result, when comparing the same two pointers twice? The general case would be: Does invoking the same unspecified behaviour twice within an application always yield the same result?

int i1, i2;
int* a = &i1;
int* b = &i2;
bool b1 = a < b; // unspecified, right?
bool b2 = a < b;
assert(b1 == b2); // Is this guaranteed to be true?

Answer 1

Comparing two unrelated pointers (i.e. pointers not pointing to the same memory, or not pointing to different parts of the same "array") can only be done using equality == and inequality !=. All other comparison is unspecified.

If you have two pointers pointing to the same place, or inside the same array, then you can compare them using the relative operators.

So if you have e.g.

int* p1 = new int[10];
int* p2 = new int[5];

you can only use == and != to compare the pointers p1 and p2.

But if you have

int a = new int[10];
int* p1 = &a[0];
int* p2 = &a[3];

then you can use also < and > (and of course <= and >=) to compare p1 and p2

Answer 2

1. It is not possible to compare two unrelated pointers(except using == and !=), that is comparing two unrelated pointer is undefined.
2. However, it is still possible to create a vector of pointers and then sort that vector in terms of the address of those pointers! See example 2 below.

Example 1:

int a = 5,b = 6;
int *a_ptr = &a, *b_ptr = &b;
bool ans = a_ptr < b_ptr;//undefined behavior

Example 2:

#include <iostream>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;

int main()
{
    std::string firstName = "Anoop",middleName = "Singh", lastName = "Rana";
    std::vector<string *> storage_ptr = {&firstName,&middleName,&lastName};
    std::vector<string *>::iterator begin = storage_ptr.begin();
    while(begin!=storage_ptr.end()){
       std::cout<<(**begin)<<std::endl;
       begin++;
    }
    std::sort(storage_ptr.begin(),storage_ptr.end(),greater<string *>());
    std::vector<string *>::iterator begin2 = storage_ptr.begin();
    while(begin2!=storage_ptr.end()){
       std::cout<<(**begin2)<<std::endl;
       begin2++;
    }
    return 0;
}

As you can see that the first while loop prints the vector in descending order while the second while loop prints the vector in ascending order showing that using the new standard we can use the function object greater<string *> to sort the vector of pointers.

Answer 3

Comparing pointers as shown in your example makes little sense because "a" and "b" value depends on how is the data stored in memory, not on the content stored in that location.

Pointers are addresses in memory (usually stored as 32 bit integer). Unless you change any of them, their comparison will return the same result. You might not know what that result is, but you'll know that it'll be the same every time.

Therefore, in your case, you will get the same result for both b1 and b2, so the assertion will pass.

Here is an example where comparing pointers does make sense:

int data[1000];
int *end = data + 50;
for (int *c = data; c < end; c++)
     ... use *c