How can I calculate a hash/checksum/fingerprint of an object in c++?

Question

Requirements:

The function must be 'injective'(*). In other words, there should be no two different input objects, that return the same hash/checksum/fingerprint.

Background:

I am trying to come up with a simple pattern for checking whether or not an entity object has been changed since it was constructed. (In order to know which objects need to be updated in the database).

Note that I specifically do not want to mark the object as changed in my setters or anywhere else.

I am considering the following pattern: In short, every entity object that should be persisted, has a member function "bool is_changed()". Changed, in this context, means changed since the objects' constructor was called.

Note: My motivation for all this is to avoid the boilerplate code that comes with marking objects as clean/dirty or doing a member by member comparison. In other words, reduce risk of human error.

(Warning: psudo c++ code ahead. I have not tried compiling it).

class Foo {
private:

    std::string my_string;

    // Assume the "fingerprint" is of type long.
    long original_fingerprint;

    long current_fingerprint()
    {
        // *** Suggestions on which algorithm to use here? ***
    }
public:
    Foo(const std::string& my_string) :
        my_string(my_string)
    {
        original_fingerprint = current_fingerprint();
    }

    bool is_changed() const 
    {
        // If new calculation of fingerprint is different from the one
        // calculated in the constructor, then the object has  
        // been changed in some way.

        return current_fingerprint() != original_fingerprint;
    }

    void set_my_string(const std::string& new_string)
    {
        my_string = new_string;
    }
}


void client_code()
{
    auto foo = Foo("Initial string");

    // should now return **false** because 
    // the object has not yet been changed:
    foo.is_changed();

    foo.set_my_string("Changed string");

    // should now return **true** because
    // the object has been changed:
    foo.is_changed();
}

(*) In practice, not necessarily in theory (like uuids are not unique in theory).

How can I calculate a hash/checksum/fingerprint of an object in c++?

2 Answers