Is std::unordered_map a good candidate for recording if I have already "dealt with" an object?

I have a structure called Col:

struct Col
{
   Object* o1;
   Object* o2;
   Object* o3;

   bool operator==(const Col &other) const
   { 
	   return o1 == o1 && o2 == o2 && o3 == o3;
   }
};

I define a hash on this:

template <>
struct std::hash<Col>
{
  std::size_t operator()(const Col& k) const
  {
    using std::size_t;

	std::hash<void> void_hash;

    std::size_t res = void_hash(k.o1) + void_hash(k.o2) + void_hash(k.o3;

	return res;
  }
};

I then have a long std::vector of Col objects which contains duplicates (per my definition of equality), and I wish to "process" each unique element only once.

This is what I do:

std::unordered_map<Col, bool> done_list;

for (Col c : col_list)
{
	if (done_list.find(c) == done_list.end())
	{
        process(c);

		done_list[c] = true;
	}
	else
	{
		continue;
	}
}

Is this a reasonable way to check for whether the same collection of objects has been processed already? Would a sparse matrix be better?

You approach is OK, but you can simplify it a bit by using std::unordered_set instead of std::unordered_map.

The set will contain the values you already processed.

#include <unordered_set>

std::unordered_set<Col> done_list;

for (Col const & c : col_list)
{
    if (done_list.find(c) == done_list.end())
    {
        process(c);
        done_list.insert(c);
    }
    else
    {
        continue;
    }
}

Note that I used const & in the ranged for-loop to avoid copy and mutation of c. You can drop the const if need to mutate it.

If you are using c++20 you can use std::unordered_set::contains to make the check even simpler:

    if (done_list.contains(c) == false)
    // ...

Another variation takes advantage of the overload of std::unordered_set::insert that returns a pair where the bool second indicates whether the item was inserted (it will not be inserted if it already exists in the set):

    auto[it, inserted] = done_list.insert(c);
    if (inserted)
    {
        process(c);
    }
    else
    {
        continue;
    }

• What you need is rather some kind of set which stores only one of each element.
• You also do not need to store the Cols in the set. It's enough with pointers to the elements.

I suggest using an unordered_set so first we need a hasher and a comparator for the pointers:

struct colptr_hash {
    const bool operator()(const Col* col) const {
        return std::hash<Col>{}(*col);
    }
};

struct colptr_equal {
    const bool operator()(const Col* lhs, const Col* rhs) const {
        return *lhs == *rhs;
    }
};

Then the actual usage:

std::unordered_set<Col*, colptr_hash, colptr_equal> done_list;

for (Col& c : col_list) {           // take by reference
    // try to insert this Col*
    auto [it, inserted] = done_list.emplace(&c);

    if (!inserted) continue;        // already processed, try next

    // never processed, go ahead:
    process(c);
}