How to initialize object without default constructor and heap usage? - c++

Question

During programming an embedded system without MMU, I should not use heap (because of memory fragmentation problem).
Part of the software is written in C (drivers) and the logic is written in C++ subset without dynamic allocation of memory.
Because of unit testing the default constructor is deleted. Instead - there is single parameter constructor with reference to structure of driver function pointers.
driver.h: (the pure C module)
#pragma once
bool Init();
uint32_t ReadMeasurement();
module.hpp: (the C++ part)
class Module {
public:
struct DriverApi {
void (*Init)();
uint32_t (*ReadData)();
};
Module() = delete;
explicit Module(DriverApi &aDriverApi);
private:
DriverApi& mDriverApi;
};
The module manager:
module_manager.hpp:
class ModuleManager {
// (...)
private:
Module::DriverApi module_1; // I can't declare this in this way
Module::DriverApi module_2; // because of lack of default constructor.
Module::DriverApi module_3;
etc.
};
How to initialize module_1, module_2 and module_3 without using heap? And n parameters constructor?
Options I'm aware:
It look's easy to use std::shared_ptr, but then std::make_shared use heap.
I can leave default constructor and then call sth. like Init(Module::DriverApi *aDriverApi) but this "violates" RAII.
Is there any other way to create "elegant" and embedded safe initialization?

Answer 1

Either use a default constructor or write one with named parameters. If you need to initialize members to non-zero values but don't have access to such values because the constructor has too few parameters, the constructor is incorrectly designed.
Because of unit testing the default constructor is deleted
Tests are supposed to make the product better - get rid of them if they do the opposite.
Normally any embedded system has a fixed set of drivers. So normally it would make little sense to have those as non-static members. Making a driver class per hardware peripheral present makes sense. Then a static instance for each instance of that hardware present on the target. You don't need to cover hardware which is never going to be present, nor will the hardware change dynamically in run-time. In fact a large part of it ought to be const and be stored in flash.
RAII has limited use on single core, single process embedded systems since your program needs to be deterministic and it owns all resources on the MCU. You usually never need to free up anything, all you need is to allocate as much memory as the product needs.
Keep it simple. Don't invent abstraction layers that fill no purpose.

Answer 2

I just put your code in IDE, and it compiles.
What I can identify in your program:
if you try to assign bool Init(); to the void (*Init)(), please change the return type.
When a user-defined constructor is defined, the default constructor is already deleted implicitly. What is missing is that you have to initialize the member.
Try explicit Module(DriverApi &aDriverApi):mDriverApi{aDriverApi}{}
class Module {
public:
struct DriverApi {
void (*Init)();
uint32_t (*ReadData)();
};
Module() = delete;
explicit Module(DriverApi &aDriverApi):mDriverApi{aDriverApi}{}
private:
DriverApi& mDriverApi;
};
void fun(){
std::cout<<"This is fun\n";
}
int main(){
Module::DriverApi module_1; // I can't declare this in this way because of lack of default constructor.
module_1.Init = fun;
module_1.Init();
Module m{module_1};
return 0;
}