How to define C++ struct for configuration?

I have been trying to solve following problem in C++. I would like to define a struct containing a configuration parameters for some software module. The configuration parameters are basically a floating point values and they are of two types:

• parameters which are independent i.e. their values are given directly by some floating point numbers
• parameters which are dependent i.e. their values are given by some expressions where the operands are the independent parameters

Here is an example

struct Configuration {
	float param_independent_01;
    float param_independent_02;
	float param_dependent_01; // param_independent_01 + param_independent_02
	float param_dependent_02; // 1.5f*param_independent_01/(param_independent_01 + param_independent_02)
};

I have been looking for a solution which enables the client code to only set values for the independent parameters and the dependent parameters values will be calculated automatically behind the scene.

Configuration config = {
	param_independent_01 = 0.236f,
    param_independent_02 = 0.728f
    // param_dependent_01 = 0.236f + 0.728f
    // param_dependent_02 = 1.5f*0.236f/(0.236f + 0.728f)
};

I suppose that the Configuration structure will be instantiated only once and the values of the parameters are known at compile time. Can anybody give me an advice how to do that in the C++?

One approach to achieve this behavior is to make use of C++'s constructor initialization list.

struct Configuration {
    float param_independent_01;
    float param_independent_02;
    float param_dependent_01;
    float param_dependent_02;

    Configuration(float p1, float p2) :
        param_independent_01(p1),
        param_independent_02(p2),
        param_dependent_01(p1 + p2),
        param_dependent_02(1.5f * p1 / (p1 + p2)
        )
    {}
};

int main() {
    Configuration config(0.236f, 0.728f);
    return 0;
}

Or just inline constexpr variables in a namespace (can be put in a header).
This allows you to write some constexpr (consteval) functions to calculate the values too. (Not everything needs to be a class or a struct)

// header file
#pragma once

namespace configuration
{
    inline constexpr float get_param_dependent_02(const float p1, const float p2)
    {
        return (1.5f * p1) / (p1+p2);
    }

    inline constexpr float param_independent_01{ 0.236f };
    inline constexpr float param_independent_02{ 0.728f };
    inline constexpr float param_dependent_01 = param_independent_01 + param_independent_02; // direct
    inline constexpr float param_dependent_02 = get_param_dependent_02(param_independent_01, param_independent_02); // or through constexpr/consteval function
};

int main()
{
    float f = configuration::param_dependent_02;
}

If you know the configuration is not going to change at runtime, you can implement a constexpr constructor for Configuration, and then define a constexpr Configuration variable. The construction will be done at compile time (see the generated assembler code for the godbolt link below).

If you wanted to make sure the configuration is not going to change at runtime, I would change Configuration into a class with private members, and just provide accessors for those members.

Notice also that the constructor may throw (due to a division by zero). If you want to take control of that situation, you may want to try-catch the setting of the dependent parameter 2 in the constructor's body.

[Demo]

#include <fmt/format.h>
#include <iostream>

class Configuration {
    float param_independent_01;
    float param_independent_02;
    float param_dependent_01;
    float param_dependent_02;
public:
    constexpr Configuration(float p1, float p2)
    : param_independent_01{p1}
    , param_independent_02{p2}
    , param_dependent_01{p1 + p2}
    , param_dependent_02{(p1 * 1.5f)/param_dependent_01}
    {}

    auto get_pi1() { return param_independent_01; }
    auto get_pi2() { return param_independent_02; }
    auto get_pd1() { return param_dependent_01; }
    auto get_pd2() { return param_dependent_02; }

    friend std::ostream& operator<<(std::ostream& os, const Configuration& c) {
        return os << fmt::format("pi1: {}\npi2: {}\npd1: {}\npd2: {}\n",
            c.param_independent_01, c.param_independent_02,
            c.param_dependent_01, c.param_dependent_02);
    }
};

int main() {
    constexpr Configuration c{3.14, 9.8};
    std::cout << c;
}

No need for a class with a custom constructor, just do this:

struct Configuration
{
    float param_independent_01 = 0; // Always initialize all class members.
    float param_independent_02 = 0;
    
    float param_dependent_01() const {return param_independent_01 + param_independent_02;}
    float param_dependent_02() const {return 1.5f*param_independent_01/(param_independent_01 + param_independent_02);}
};