Using a config file to allocate array at compile time in c++ - c++

Question

I am a bit new to c++ and want to learn more by trying a specific project. This project is somewhat bigger project where I want to test the dependence of some numerical method "function" with respect to parameters like array size and what not. I figured the best way to organize my code would be to create
A file implementing the functions I want to use
// implement.h
#include <cmath>
struct input_params{
int input_array_size;
// other parameters
}
void function(float* , float* , input_params);
// implement.cpp
#include <cmath>
#include "implement.h"
void function(float *input, float *output, input_params args){
// do stuff
}
A config file specifying what my input_params will contain (with a corresponding header file)
#include "config.h"
input_params args;
#include "implement.h"
#include "config.h"
input_params args;
args.input_array_size = 100; // something I would change before compile time
A script that will actually run the code
#include <cmath>
#include "implement.h"
#include "config.h"
// float *input = new [arg.input_array_size];
float input[arg.input_array_size]; // I want to make this stack-allocated for performance reasons
// float *output = new [arg.output_array_size];
float output[arg.output_array_size];
function(input, output, args);
My questions are as follows:
How should I compile the code using g++?
How do compile my "config" file so that my parameters are known at compile time?
Is there a better, alternative way of actually doing this?

Answer 1

The simplest approach would be to make your configuration file create macros:
// config.h
#define ARG_INPUT_SIZE 100
#define ARG_OUTPUT_SIZE 300
// some_other_file.c
#include "config.h"
float input[ARG_INPUT_SIZE];
float output[ARG_OUTPUT_SIZE];
It's pretty unlikely that allocating this in the bss vs the heap is actually going to be meaningfully important to any performance metrics.

Answer 2

"Is there a better, alternative way of actually doing this?"
Of course there is. Just use a std::vector<float> for the input / output parameters. You can adapt the necessary size of them dynamically as needed.
If you still want fixed sizes, and do that at compile time you can use std::array<float,MY_SIZE> and define the size you want using the -D command line option of g++:
g++ -D MY_SIZE=100 ...
std::vector and std::array are a lot easier to deal with than raw c-style arrays or pointers.
Example code:
#include <array>
using inarray_t = std::array<float,MY_INPUT_SIZE>;
using outarray_t = std::array<float,MY_OUTPUT_SIZE>;
// Change the signature of your function
void function(inarray_t&, outarray_t& , input_params);
// ...
int main() {
// ...
inarray_t input; // this is stack-allocated for performance reasons
outarray_t output; // this is stack-allocated for performance reasons
// ...
}
Take care that the stack allocations don't exceed the stack size limitations, these aren't that big usually, and you can end up with stack overflow (no pun intended) very quickly.