Question

I’m converting a type from a C-style struct to a C++-style struct; I’m adding a member which will force the type to need a constructor, and I must therefore switch from malloc and free to new and delete. I can find everywhere the type is allocated (due to the conventions of this codebase) by looking for sizeof(TYPE).

Is there any way I can locate all the instances where pointers of that type are passed to free? I realise that, since the argument to free is void* that’s not a guarantee I’ve found everywhere the type is freed.

For instance, can I overload free somehow so that I’ll get a compilation error wherever free(TYPE*) is called, but not anywhere else?

Answer 1

can I overload free somehow

You can certainly give it a go. For example:

#include <cstdlib>
#include <iterator>

namespace my {
    class TYPE { };
    template <typename T>
    void free(T *ptr) { std::iterator_traits<T>::attempt_to_free_TYPE; }
}

using std::malloc;
using std::free;
using my::TYPE;

int main() {
    TYPE *ptr = (TYPE *) malloc(sizeof(TYPE));
    free(ptr);
}

Thanks to ADL, that call to free is to my::free, so the code fails to compile. Obviously this wouldn’t catch free((void*)ptr);, since calls to free with arguments other than my::TYPE* are unaffected.

As I’ve written it, there need to not be any calls to free inside namespace my, or in code that has using namespace my;. So you might want to use a newly-invented namespace for the purpose. Or write a less catch-all template, I improvised that one.

It also doesn’t catch fully-qualified calls to std::free. It’s undefined behavior to overload std::free (or anything in namespace std), but if necessary you’d probably get away with it just for the purpose of finding call sites. Something like this:

template <typename T>
struct allowed_to_free {
    enum { value };
};
template <>
struct allowed_to_free<TYPE> {};

namespace std {
    template <typename T>
    void free(T *ptr) {
        allowed_to_free<T>::value; 
        free((void*)ptr); 
    };
}