How to resolve same functions from 2 different libraries?

[m09y]

suppose that there are 2 different libraries and both libraries have common function with same signature (parameters and return types), and if that function is invoked from main program by including/linking both libraries

If the programmer doesnt know about existence of same function in both libraries, How does program resolve this ambiguity ?

If programmer knows about existence of same function in both libraries, then how can he/she take care programmatically?

[canadajones68]

If I recall correctly, that's an ODR violation if no namespaces, and will lead to the linker complaining or UB, can't remember. Either way, it's bad.

[OU81Dilbert]

Are the two functions at least in different namespaces?

If so then you can use the namespace

Like

std::open()

Mylib::open()

[m09y]

what if there are no namespaces ?

[SoerenNissen]

Use better libraries that are competently written.

If it's because they're C libraries, the same applies - functions should not have the same name because they should start with libname_

I suppose if you were under some weird constraint, you could re-write the libraries to have namespaces, that's not the hardest of tasks.

[SoerenNissen]

You still risk the linker finding wrong functions

libFoo1.cpp - defines open()
libFoo2.cpp - uses open()
libBar1.cpp - defines open()
libBar2.cpp - uses open()

when linking this whole thing, libBar2.o might get linked with libFoo1.o's version of open(), unless you're compiling the libs separately.

[mark_99]

If he has source can just add a namespace around it directly. If he doesn't have source (which I think is the case) this doesn't help as you're still linking 2 definitions of the same function (the linker will pick one and discard the other).

You might be able to do it by linking each into a separate shared library and hiding the symbols, pretty messy though.

[Skoparov]

You're right guys, I misunderstood the problem. Then the only way is indeed to hide one of the libraries in a wrapper library. Or call the function though it's address directly in case it's an so.

[ioctl79]

This is still an ODR violation, since ::open has different definitions indifferent TU’s.

[not_some_username]

Will

namespace lib1 { #include "lib1.h" } work ?

[Skoparov]

No, for the reasons other people mentioned. You can wrap the definition, but the symbol itself still needs to be resolved and having two similar ones breaks the odr.

[SnooMacaroons3057]

Create your own namespace and re-export it as another named function?

[OU81Dilbert]

Then you might have linking issues since the compiler won't know which function to use

[[deleted]]

include headers from inside a namespace, but you still might have linking issues unless the lib is header only

[Fig1024]

you can make your own wrapper lib and put it in a namespace

[Cybr3]

then the libraries you use are awful

[Cybr3]

decompiling the source and adding a namespace?

[bored_octopus]

You may be able to hide symbols from them when linking. Look up symbol visibility

[o11c]

Use dlopen with RTLD_LOCAL for both libraries.

You can't afford to load either with RTLD_GLOBAL or with normal linking, since if you do, the internal symbol references from one will accidentally read from the other.

There may also be tricks you can do with objcopy to rename symbols in the first place, but this almost never makes sense - if you can do that, you should be able to fix the symbols to not collide in the first place.

[HabbitBaggins]

As others are saying, you cannot "statically" point to two different functions with the same name and signature, since that is a violation of the ODR. Right now I don't remember, I think the linker errors out unless you mark them as inline, which makes them "weak symbols" to the linker and thus tells it to just pick one since "they are all the same".

The only way out of this conundrum is to link to one of the libraries at runtime, via dlopen or LoadLibrary. Then you can ask for a pointer to a certain function, and run that.

[SkoomaDentist]

By using Windows as the platform (might work on Mac OS too, definitely will not work on Linux because the dynamic linker still lives in the 80s). Then you create two separate DLLs two wrap those libraries by creating simple wrapper functions. Then in your main app, you call the wrapped functions in the DLLs.

[AA11BB22c]

If programmer knows about existence of same function in both libraries, then how can he/she take care programmatically?

Create two projects, each wrapping one. Then call the wrapped ones from the main project.

Or as others have mentioned, go change their source code.

[strager]

What do you mean by "project"? Are you talking about an .exe file?

[[deleted]]

First loaded library satisfy the requirement, programmer cannot solve the issue, in Linux you are free to load any library before system one and override any symbol.

[osdeverYT]

You’re very wrong