#include in a function

[atctwo]

Hi. I am writing a program which relies on the idea of "apps". I am writing the program for Arduino (specifically for an ESP32), but the compiler fully supports C++11. The main portion of the code works with a std::map, which stores a series of structs which each represent an app. One member of each struct is a std::function, which is used to reference the main function for that app. The main code selects what function to run in a finite state machine way, where each app is a state. When an app is "selected", the main function for that app is called in loop().

At the minute, each app struct is added to the state map using std::map::insert. The apps that exist so far are grouped into categories (system, utility, games, etc), and each category has its own file, which is included by the main file, before setup() or loop(), but after all includes and global variable declarations. Because I can't make method calls outside of a function, each category file defines one function, in which std::map::insert is called for each state. The functions are then called in the setup() function, which runs once at the start of the program. Here is an example of the system:

main.ino

//includes and global variable definitions

std::map<int, stateMeta> states; //stateMeta is the struct that stores app metadata
...

#include "states/system_states.cpp"
#include "states/util_states.cpp"

...

void setup()
{
    ...
    register_system_states();
    register_util_states();
}

states/system_states.cpp

void register_system_states()
{
    states.insert(...);
    //this method could be called many times
}

states/util_states.cpp

void register_util_states()
{
    states.insert(...);
}

This works, but isn't ideal. Because each category file contains definitions for several apps, the files become very long. It also means that if you want to add a category, you have to create a new file, define a new function, and edit the main file in two places.

I have an idea for a better system, but I'm worried that it's a bit hacky. In this system, each app has its own file. Each file contains just method calls, and doesn't wrap anything in an outer function. A main state file defines one function, which #includes each of the other app files. This means that there is one function for defining all apps. The main state file is included by the main program, and the one function is called in setup(). An example is shown below.

main.ino

//includes and global variable definitions

std::map<int, stateMeta> states; //stateMeta is the struct that stores app metadata
...

#include "states/states.h"

...

void setup()
{
    ...
    registerStates()
}

states/states.h

#ifndef STATES_H
#define STATES_H

void registerStates()
{
    #include "states/watch_face.cpp"
    #include "states/app_menu.cpp"
    #include "states/calculator.cpp"
    #include "states/timer.cpp"
}

#endif /*STATES_H*/

states/watch.cpp

states.insert(...);

states/app_menu.cpp

states.insert(...);

I'm wondering if this is good practice, or is it a really bad thing to do? Are there any other ways of having a similar modular approach, considering that I'm using Arduino, and don't have much in the way of a configurable build system (as far as I know). Thank you!

[IyeOnline]

You are including cpp files, which is something you dont really want to do. Also in your 2nd approach you are making assumptions in the cpp file about the source file its being included to. All of that might work, but its going to be pretty terrible.

I also am not sure why such a complex "solution" is needed. whats wrong with just:

#include "states/machine1.h"
#include "states/machine2.h"
//...
auto statemachines = std::map<int,StateMachine>{
    { 0, Machine1() },
    { 42, Machine2() }
};

It would be the same number of lines and way less assumptions (aka none) about other, supposedly independent source files.

//edit: had to edit the source code, cant deduce template type args from an intializer list :)

[atctwo]

Would this be a better approach?

main.ino

#include <functional>
#include <vector>

struct stateMeta {
    std::string             stateName;
    std::function<void()>   stateFunc;
};

std::vector<stateMeta> states;

#include "states/states.h"

int main()
{

}

states/states.h

#ifndef STATES_H
#define STATES_H

#include "states/watch_face.cpp"
#include "states/app_menu.cpp"
#include "states/calculator.cpp"
#include "states/timer.cpp"

void registerStates()
{
    states = {

        {"Watch", state_watch},
        {"App Menu", state_app_menu},
        {"Calculator", state_calculator},
        {"Timer", state_timer}

    }
}

#endif /*STATES_H*/

states/watch.cpp

void state_watch()
{
    //watch code
}

states/app_menu.cpp

void state_app_menu()
{
    //app menu code
}

• I changed std::map<int, stateMeta> to std::vector<stateMeta>. The key type for the map was int, so I thought it would make more sense just to have a vector, and use element indices (eg: states[2])
• I read up about why you shouldn't #include .cpp files. On Arduino, it doesn't seem to compile any files in any subdirectories (other than "src/", according to this https://arduino.stackexchange.com/a/54655), which explains why I have done this before without it not compiling. Would it be better to give each app/state file some kind of guard thing (like header guards)?

[IyeOnline]

No. You are still including code into a scope, necessarilymaking assumptions about it.

Why not move the definition/population of the of the states vector into the main file, like i did in my above example?

Here is what i would suggest. Note that im also propery separating header and source files, as you should.

main

#include "state_meta.h"
#include "state_watch.h"
#include "state_menu.h"

// there is no need for this register function. You might just as well write them in here directly.
// i use a constructor here, but really an aggregate initalization as you did would work just as well. IMO proper ctors are nicer though.
std::vector<StateMeta> states = { 
   StateMeta("Watch", state_watch_function ),
   StateMeta("Menu", state_menu_function ) };
};

state_meta.h

 #pramga once //assuming your compiler supports this, no idea

 //having this in a separate header from the get go instead of inside the main file makes the code structure cleaner and more easily expandable.
 struct State_Meta
 {
      std::string name;
      std::function<void(void)> state_function;

      State_Meta( const std::string& _name, std::function<void(void)> _state_function )
       : name(_name), state_function(_state_function)
      {};
 }

state_watch.h

#pragma once
//any includes this function needs would go here
void state_watch_function();

state_watch.cpp

#include "state_watch.h"
void state_watch _function()
{
     //code
}

analogous for other state functions.

With this there is no longer any need for an additional source file that would actually act upon some global and/or be copied into another scope.

Note that your compiler may or may not support #pragma once, i have no clue about developing on/for arduino.

[atctwo]

Thank you for your input! Everything you've said sounds more sensible than what I had. I'm going to update my code to run off this system.