C++ Multiple Libraries Define Same Class Name

Question

I am developing a project in which I have a vendor library, say vendor.h, for the specific Arduino-compatible board I'm using which defines class HTTPClient that conflicts with an Arduino system library, HTTPClient.h, which also defines class HTTPClient.

These two classes are unrelated other than having the same name, and the vendor implementation of an HTTP client is far less capable than the Arduino system library's implementation, so I'd prefer to use the latter. But I can't omit including the former, because I need quite a bit from the vendor.h. Essentially, I have the problem posed here, but with classes rather than functions. I have the full code of both, but given that one is a system library and the other is a vendor library, I'm reluctant to fork and edit either, as that adds lots of merging work down the road if either of them are updated, so my preference would be to find a tidy solution that doesn't edit either header.

I've tried a variety of solutions posted in other SO questions:

• I do not want to leave out either header, as I need vendor.h for quite a few things and need the capabilities of HTTPClient.h's client implementation
• Proper namespaces in the headers would solve the problem, I would prefer to avoid editing either header
• I tried wrapping the #include <HTTPClient.h> in a namespace in my main.cpp, but that caused linking errors, as it's not a header-only library, so the header & cpp weren't in the same namespace
• I tried a simple wrapper as proposed for the function in the above linked SO question in which the header contained just a forward declaration of my wrapper class & the associated cpp contained the actual class definition. This gave a compiler error of error: aggregate 'HTTP::Client client' has incomplete type and cannot be defined (Code sample of this attempt below)

main.cpp:

#include <vendor.h>
#include "httpclientwrapper.h"

HTTP::Client client;

httpclientwrapper.h:

#ifndef INC_HTTPCLIENTWRAPPER_H
#define INC_HTTPCLIENTWRAPPER_H

namespace HTTP {

class Client;

}

#endif

httpclientwrapper.cpp:

#include "httpclientwrapper.h"

#include <HTTPClient.h>

namespace HTTP {

class Client : public ::HTTPClient {};

}

In that example, I can't inherit from HTTPClient in a class definition in my header, as that will reintroduce the duplicate class name to the global namespace in my main program (hence the perhaps misguided attempt to see if a forward declaration would do the trick). I suspect that I can resolve the issue by completely duplicating the class definition of HTTPClient in my wrapper class above rather than trying to use inheritance. I would then add member definitions to my wrapper cpp which pass the call to HTTPClient's members. Before I go through the trouble of rewriting (or more likely, copy/pasting) the entire HTTPClient definition from HTTPClient.h into my own wrapper, I was wondering if there was a better or more proper way to resolve the conflict?

Thanks for you help!

Answer 1

As a solution was never proposed, I'm posting an answer that summarizes my research and my ultimate resolution. Mostly, I encourage the use of namespaces, because proper uses of namespaces would have eliminated the conflict. However, Arduino environments try to keep things simple to lower the barrier of entry, eschewing "complicated" features of C++, so more advanced use cases will likely continue to run into issues like this. From other SO answers and forum posts (cited where I could), here are some methods for avoiding name conflicts like this:

If you can edit the source

Edit the source code to remove the conflict or add a namespace to one of both libraries. If this is an open source library, submit a pull request. This is the cleanest solution. However, if you can't push your changes back upstream (such as when one is a system library for some hardware), you may end up with merge issues down the road when the maintainer/developer updates the libraries.

If you can't edit the source

Credit for part of this: How to avoid variable/function conflicts from two libraries in C++

For libraries that are header only libraries (or all functions are inline)

(ie, they have only a .h file without a .o or .cpp)

Include the library inside a namespace. In most code, this is frowned upon as poor form, but if you're already in a situation where you are trying to cope with a library that doesn't contain itself nicely, it's a clean and simple way to contain the code in a namespace and avoid name conflicts.

main.cpp

namespace foo {
    #include library.h
}

int main() {
    foo::bar(1); 
}

For libraries with functions

The above method will fail to link at compile time, because the declarations in the header will be inside the namespace, but the definitions of those functions are not.

Instead, create a wrapper header and implementation file. In the header, declare your namespace and functions you wish to use, but do not import the original library. In the implementation file, import your library, and use the functions inside your new namespaced functions. That way, the one conflicting library is not imported into the same place as the other.

wrapper.h

namespace foo {
    int bar(int a);
}

wrapper.cpp

#include "wrapper.h"
#include "library.h"

namespace foo {
    int bar(int a) {
        return ::bar(a);
    } 
}

main.cpp

#include "wrapper.h"

int main() {
    foo::bar(1); 
}

You could also, for the sake of consistency, wrap both libraries so they're each in their own namespace. This method does mean that you will have to put in the effort to write a wrapper for every function you plan to use. This gets more complicated, however, when you need to use classes from the library (see below).

For libraries with classes

This is an extension of the wrapper function model from above, but you will need to put in more work, and there are a few more drawbacks. You can't write a class that inherits from the library's class, as that would require importing the original library in your wrapper header prior to defining your class, so you must write a complete wrapper class. You also cannot have a private member of your class of the type from the original class that you can delegate calls to for the same reason. The attempt at using a forward declaration I described in my question also did not work, as the header file needs a complete declaration of the class to compile. This left me the below implementation, which only works in the cases of a singleton (which was my use case anyway).

The wrapper header file should almost completely duplicate the public interface of the class you want to use.

wrapper.h

namespace foo {
    Class Bar() {
    public:
        void f(int a);
        bool g(char* b, int c, bool d);
        char* h();
    };
}

The wrapper implementation file then creates an instance and passes the calls along.

wrapper.cpp

#include "wrapper.h"
#include "library.h"

namespace foo {

    ::Bar obj;

    void Bar::f(int a) {
        return obj.f(a);
    } 

    bool Bar::g(char* b, int c, bool d) {
        return obj.g(b, c, d);
    } 

    char* Bar::h() {
        return obj.h();
    } 
}

The main file will interact with only a single instance of the original class, no matter how many times your wrapper class in instantiated.

main.cpp

#include "wrapper.h"

int main() {
    foo::Bar obj;
    obj.f(1);
    obj.g("hello",5,true);
    obj.h();  
}

Overall, this strikes me as a flawed solution. To fully wrap this class, I think the this could be modified to add a factory class that would be fully contained inside the wrapper implementation file. This class would instantiate the original library class every time your wrapper class is instantiated, and then track these instances. In this way, your wrapper class could keep an index to its associated instance in the factory and bypass the need to have that instance as its own private member. This seemed like a significant amount of work, and I did not attempt to do so, but would look something like the code below. (This probably needs some polish and a real look at its memory usage!)

The wrapper header file adds a constructor & private member to store an instance id

wrapper.h

namespace foo {
    Class Bar() {
    public:
        Bar();
        void f(int a);
        bool g(char* b, int c, bool d);
        char* h();
    private:
        unsigned int instance;
    };
}

The wrapper implementation file then adds a factory class to manage instances of the original library's class

wrapper.cpp

#include "wrapper.h"
#include "library.h"

namespace foo {

    class BarFactory {
    public:
        static unsigned int new() {
            instances[count] = new ::Bar();
            return count++;
        }
        static ::Bar* get(unsigned int i) {
            return instances[i];
        }
    private:
        BarFactory();
        ::Bar* instances[MAX_COUNT]
        int count;
    };

    void Bar::Bar() {
        instance = BarFactory.new();
    }

    void Bar::f(int a) {
        return BarFactory.get(i)->f(a);
    } 

    bool Bar::g(char* b, int c, bool d) {
        return BarFactory.get(i)->g(b, c, d);
    } 

    char* Bar::h() {
        return BarFactory.get(i)->h();
    } 
}

The main file remains unchanged

main.cpp

#include "wrapper.h"

int main() {
    foo::bar obj;
    obj.f(1);
    obj.g("hello",5,true);
    obj.h();  
}

If all of this seems like a lot of work, then you're thinking the same thing I did. I implemented the basic class wrapper, and realized it wasn't going to work for my use case. And given the hardware limitations of the Arduino, I ultimately decided that rather than add more code to be able to use the HTTPClient implementation in either library, I wrote my own HTTP implementation library in the end, and so used none of the above and saved several hundred kilobytes of memory. But I wanted to share here in case somebody else was looking to answer the same question!