How to use a member function with std::bsearch

Question

I have a C++ class but I'm also using some low level C and need to use the bsearch function. The last argument of bsearch is a comparison function, and I want to implement said function in a way that will allow it to access const private variables of the class.

The problem is that if I make the comparison function a member function it will not work, because it won't be a convertible to a regular function pointer. If I make a non member function I can pass that to bsearch, but would not able to access private variables of the class.

What to do?

example:

3 means there are 3 elements.16,32,56 are offset bytes.I need bsearch to search for actors.I'm searching in the offset array.I need a comparison function which would compare actors but i laso need const void * actorFile pointer to compute the locations in the comparison function.actorFIle is class private variable.

Answer 1

The solution is to forgo the C library function, and use C++ as it's meant to be used. The C++ standard library also has a utility search function, it's called std::lower_bound. And it accepts general function-like objects, not just regular function pointers.

This allows you to call it with a lambda expression that captures your class:

std::lower_bound(start, finish, value, [this] (auto const& lhs, auto const& rhs) {
                 /* Compare and utilize anything this can point to*/ });

Answer 2

If you are really tied to bsearch just use your member function inside the non member function. Hence you don't need to access private members.

/* Create global variable to use in compare proc*/
actors_data_base* cmp_data_base = NULL;

/* Write compare routine like */
int cmp_proc(const void * a, const void * b)
{
    size_t a_offset = static_cast<size_t>(a);
    size_t b_offset = static_cast<size_t>(b);
    return cmp_data_base->compare_actors(a_offset, b_offset);
}


/* Set global pointer and use bsearch */
actors_data_base = &my_data_base;
bsearch(&my_value, array, size, sizeof(size_t), cmp_proc);

Definitely, this is ugly, due to use of global variable. But this is the only way to pass a context to compare proc. You may think of using thread local storage to avoid threading issues (cmp_proc must not be used concurrently due to global var)

Hence, you would much and much better to use std::lower_bound.