What should be used to check identity in C++?

Question

I have two pointers to objects and I want to test if they are the exact same object in the most robust manner. I explicitly do not want to invoke any operator == overloads and I want it to work no matter what base classes, virtual base classes and multiple inheritance is used.

My current code is this:

((void*)a) == ((void*)b)

And for my case this works. However, that doesn’t work for this case:

class B1 {};
class B2 {};
class C : public B1, public B2 {}

C c;
B1 *a = &c;
B2 *b = &c;

Subbing in reinterpert_cast, static_cast or dynamic_cast doesn't work either.

---

Particularly I'm hoping for something that ends up really simple and efficient. Ideally it wouldn't require any branch instructions to implement and would do something like, adjust the pointer to the start of the object and compare.

Answer 1

Except for smart pointers (which aren't really pointers, but class objects), overloading operator== isn't possible for pointers, so a cast shouldn't be necessary.

Of course, comparing pointers of different types might not work. Why do you think you need to do that?

Answer 2

You could check to point if the objects pointed to overlap in memory (stealing from Mark Ransom's answer). This invokes undefined behavior, but should do what you want on any reasonable compiler:

template <typename T1, typename T2>
bool is(const T1 *left, const T2 * right)
{
    const char *left_begin=reinterpret_cast<const char*>(left);
    const char *left_end=left_begin+sizeof(*left);

    const char *right_begin=reinterpret_cast<const char*>(right);
    const char *right_end=right_begin+sizeof(*right);

    return ( left_begin  <= right_begin && right_begin < left_end) ||
           ( right_begin <= left_begin  && left_begin < right_end);
}

Answer 3

Your approach worked for me even in your cited case:

class B1 {};
class B2 {};
class C : public B1, public B2 {};

int main() {
  C c;
  B1 *a = &c;
  B2 *b = &c;

 if ((void*)a == (void*)b) {
  printf("equal");
 }
 else {
  printf("not equal!");
 }

}

prints "equal" here..

Answer 4

There's no general way to do it. Base class subobjects, in general, have no knowledge that they are that, so if you only have a pointer to a base class subobject, you do not have any means to obtain a pointer to the most derived object to which it belongs, if you do not know the type of the latter in advance.

Let's start with this:

 struct B1 { char b1; };
 struct B2 { char b2; };
 struct D : B1, B2 { char d; };

 // and some other type...
 struct Z : B2, B1 { };

Consider a typical implementation of in-memory layout of D. In the absence of vtable, the only thing we have is the raw data (and possibly padding):

       Offset    Field
       ------    -----
    /       0    b1     >- B1
 D-<        1    b2     >- B2
    \       2    d

You have two pointers:

B1* p1;
B2* p2;

Each pointer effectively points at a single char within an instance of D. However, if you do not know that in advance, how could you tell? There's also a possibility that pointers could rather point to subobjects within an instance of Z, and looking at pointer values themselves, there's clearly no way to tell; nor is there anything you (or the compiler) can deduce from data referenced by the pointer, since it's just a single byte of data in the struct.

Answer 5

So, you're looking for a compile time solution. I don't believe this is possible as stated in C++. Here's a thought experiment:

File Bases.hpp:

class B1 {int val1;};
class B2 {int val2;};

File Derived.hpp:

#include <Bases.hpp>
class D : public B1, public B2 {};

File Composite.hpp:

#include <Bases.hpp>
class C
{
   B1 b1;
   B2 b2;
};

File RandomReturn.cpp:

#include <Composite.hpp>
#include <Derived.hpp>
#include <cstdlib>

static D derived;
static C composite;

void random_return(B1*& left, B2*& right)
{
    if (std::rand() % 2 == 0)
    {
        left=static_cast<B1*>(&derived);
        right=static_cast<B2*>(&derived);
    }
    else
    {
        left=&composite.b1;
        right=&composite.b2;
    }
}

Now, suppose you have:

#include <Bases.hpp>
#include <iostream>

extern void random_return(B1*& , B2*& );

// some conception of "is_same_object"    
template <...> bool is_same_object(...) ...

int main()
{
    B1 *left;
    B2 *right;

    random_return(left,right);
    std::cout<<is_the_same_object(left,right)<<std::endl;
}

How could we possibly implement is_same_object here, at compile time, without knowing anything about class C and class D?

On the other hand, if you're willing to change the hypotheses, it should be workable:

class base_of_everything {};
class B1 : public virtual base_of_everything {};
class B2 : public virtual base_of_everything {};

class D : public B1, public B2, public virtual base_of_everything {};

...
// check for same object
D d;
B1 *b1=static_cast<B1*>(&d);
B2 *b2=static_cast<B2*>(&d);

if (static_cast<base_of_everything*>(b1)==static_cast<base_of_everything*>(b2))
{
    ...
}

Answer 6

If your classes are genuinely exactly as given then it's impossible as there's not enough information available at runtime to reconstruct the required information.

If they're actually polymorphic classes, with virtual functions, it sounds like dynamic_cast<void *> is the answer. It returns a pointer to the most derived object. Your check would then be dynamic_cast<void *>(a)==dynamic_cast<void *>(b).

See paragraph 7 here:

http://www.csci.csusb.edu/dick/c++std/cd2/expr.html#expr.dynamic.cast

I suspect the usual dynamic_cast issues apply -- i.e., no guarantee it will be quick, and your classes will have to be polymorphic.

This is not a feature I have used myself, I'm afraid -- but I have seen it suggested often enough by people who have that I infer it is widely-supported and works as advertised.

Answer 7

There's an easy way and a hard way.

The easy way is to introduce an empty virtual base class. Every object inheriting from such a class gets a pointer to the common point in the "real" object, which is what you want. The pointer has a little overhead but there are no branches or anything.

class V {};
class B1 : public virtual V {}; // sizeof(B1) = sizeof(void*)
class B2 : public virtual V {}; // sizeof(B2) = sizeof(void*)
class D : public B1, public B2 {}; // sizeof(D) = 2*sizeof(void*)

bool same( V const *l, V const *r ) { return l == r; }

The hard way is to try to use templates. There are a few hacks here already… when hacking with templates remember that you are essentially reinventing part of the language, just with hopefully lower overhead by managing compile time information. Can we lower the overhead of the virtual base class and eliminate that pointer? It depends on how much generality you need. If your base classes can be arranged in several different ways within a derived object, then there is certainly information that you can't get at compile time.

But if your inheritance hierarchy is an upside-down tree (ie, you are building large objects by lots of multiple inheritance), or several such trees, you can just go ahead and cast the pointers to the most derived type like this:

class C; // forward declare most derived type
class T { public: typedef C base_t; }; // base class "knows" most derived type
class B1: public T { int a; };
class B2: public T { int b; };
class D: public B1, public B2 { int c; };

 // smart comparison function retrieves most-derived type
 // and performs simple addition to make base pointers comparable
 // (if that is not possible, it fails to compile)
template< class ta, class tb >
bool same( ta const *l, tb const *r ) {
        return static_cast< typename ta::base_t const * >( l )
         == static_cast< typename tb::base_t const * >( r );
}

Of course, you don't want to pass NULL pointers to this "optimized" version.

Answer 8

Use boost::addressof. I'm thinking this is the best way. boost::addressof is provided to get the address anyway, regardless of potential uses and misuses of operator overloading. By using some clever internal machinery, the template function addressof ensures that it gets to the actual object and its address. Look at this

#include "boost/utility.hpp"

class some_class {};

int main() {
  some_class s;
  some_class* p=boost::addressof(s);
}

Answer 9

If you need to compare the identity of your objects, why wouldn't you give them one? After all, it's you who decides what makes the identity of the object. Let the compiler do it, and you're bound to the compiler's limitations.

Something in the way of...

class identifiable {
    public:
    long long const /*or whatever type*/ identity;
    static long long sf_lFreeId() { 
       static long long lFreeId = 0;
       return lFreeId++; // not typesafe, yet
    }
    identifiable(): identity( sf_lFreeId() ) {}
    bool identical( const identifiable& other ) const { 
      return identity == other. identity;
    }
};

class A : public identifiable {
};

....

A a1, a2;
A& a3 = a1;

assert( !a1.identical(a2) );
assert( a1.identical( a3 ) );