c++ interfaces (class) to hide the real identity (instantiation) - c++

Question

i was wondering if someone could explain me how to use interfaces.
generally, the interface shall be used in every case between layers and architecture objects (allows testability, clear structure/architecture, independently working in teams,....)
What i don't yet understand is, is the include dependency.. i still need to instantiate the object Test itself and therefore need to include it directly in the layer above (arch). But id like rather not to know whats going on down there and only work with the interface.
What is the way to go here?
Does someone have a concrete example (Example: HAL::Timer as Object and HAL:IF_Timer as interface where Middleware/Application whats to create such object and make use of it?
// =============== IF_Test.hpp =======================
#ifndef IF_Test_hpp
#define IF_Test_hpp
#include <stdio.h>
class I_Test
{
public:
I_Test() { };
virtual ~I_Test() { };
virtual std::string& toString() = 0;
};
#endif /* IF_Test_hpp */
// =============== Test.hpp =========================
#ifndef Test_hpp
#define Test_hpp
#include <stdio.h>
#include "IF_Test.hpp"
class Test : public I_Test
{
std::string myName;
public:
Test();
~Test();
std::string& toString();
};
#endif /* Test_hpp */
// =============== Test.cpp =========================
#include <iostream>
#include <cstdio>
#include <string>
#include "Test.hpp"
Test::Test()
: myName("PeterParkerIsBatman")
{
std::cout << "Test\n";
}
Test::~Test()
{
std::cout << "!Test\n";
}
std::string& Test::toString()
{
return myName;
};
// =============== main.cpp =========================
#include <iostream>
#include "IF_Test.hpp"
/** HERE i still need to include the
concrete class object, which id likte NOT to do
(Or do i want this and why?) */
#include "Test.hpp"
int main(int argc, const char * argv[])
{
I_Test * obj = new(Test);
obj->toString();
std::cout << "Hello, World!\n";
return 0;
}

Answer 1

By having a reference to an abstract class member ITimer, you can obtain this abstraction layer you are looking for where the Scheduler doesn't have any knowledge of mTimer implementation.
// =============== ITimer.h =======================
class ITimer {
public:
virtual double time() = 0;
};
// =============== Timer_A.h =======================
//#include ITimer.h
class Timer_A : public ITimer {
public:
double time() override {
/* One way .. */
return {};
}
};
// =============== Timer_B.h =======================
//#include ITimer.h
class Timer_B : public ITimer {
public:
double time() override {
/* Another way .. */
return {};
}
};
// =============== Scheduler.h =======================
//#include ITimer.h <-- No mention of any specific implementation of the ITimer abstract class
class Scheduler{
public:
Scheduler(ITimer& timer)
: mTimer(timer)
{}
void run (){
double time = mTimer.time();
/* etc .. */
}
private:
ITimer& mTimer;
};
// =============== main.cpp =======================
#include Timer_A.h
#include Timer_B.h
#include Manager.h
int main()
{
Timer_A timerA;
Timer_B timerB;
Scheduler schedulerA(timerA);
Scheduler schedulerB(timerB);
}
You can have as many layers like that where the only place where you include the file containing the implementation (Timer_A.h and Timer_B.h) is a the highest level.
Like you said, this lets you change the concrete classes very easily and allows great testing capability using gmock for example.