Override function but retain reference to the original - c++

Question

I am inexperienced with C++, so I might be missing the correct search terms.
I want to replace a few library functions with my own wrappers at runtime. Basically, I would like to provide an instrumented version of the library. In an ideal world, users of the library would not have to alter their code to use this version (or, at most, change only the linking within CMakeLists.txt).
User-defined executables are often declared as follows in a CMake file.
add_library(my_code ${SOURCES})
add_dependencies(my_code ${catkin_EXPORTED_TARGETS})
target_link_libraries(my_code ${catkin_LIBRARIES})
I suppose that, to achieve this, changing target_link_libraries() would be required, so as to link to a different version.
However, even if I redefine all functions in the original header, under the same namespace, how can I refer to the original implementation?
namespace thelib {
void theFunction() {
// how do I call the original thelib::theFunction() here?
}
}

Answer 1

Basically it is to good practice to isolate third party dependency using come abstraction. Aim is to hide library API behind some interface, which implementation an be freely altered.
I do it more or less that:
// some header
class IDependency {
public:
virtual ~IDependency() = default;
virtual void theFunction() = 0;
};
std::unique_ptr<IDependency> depFactory(int someArg);
// some cpp
std::unique_ptr<IDependency> depFactory(int someArg)
{
if (someArg = 0) {
return std::make_unique<LibraryWrapper>();
}
if (someArg = 0) {
auto origLib = std::make_unique<LibraryWrapper>();
return std::make_unique<DepCutomization>(origLib);
}
throw std::invalid_argument("");
}
// LibraryWrapper
class LibraryWrapper : public IDependency {
public:
void theFunction() override {
::thelib::theFunction();
}
}
// DepCutomization
class DepCutomization : public IDependency {
public:
explicit DepCutomization(std::unique_ptr<IDependency> orig)
: m_orig(std::move(orig))
{}
void theFunction() override {
customAction();
m_orig->theFunction();
}
void customAction()
{}
private:
std::unique_ptr<IDependency> m_orig;
};
For cases where performance is important, I'm using static polymorphism (template programing).