My goal is to create nullable value which takes both a default value function and a key to retrieve a potential customization of the value from the flash storage.
But trying to instantiate it as a property member I get "expected type specifier" compile error for the two arguments.
How to fix this?
Here how I use my constructor in my class:
class BatteryConfig {
static float _defaultPackL1Undervoltage();
FloatStorageNullableWithDefault packL1Undervoltage("PackL1UndervoltageKey", _defaultPackL1Undervoltage); // <<<== the errors here
};
Here is my base classes:
template <typename T>
class Nullable {
public:
Nullable() : hasValue_(false) {}
Nullable(const T& value) : hasValue_(true), value_(value) {}
bool hasValue() const { return hasValue_; }
virtual T get() const {
if (!hasValue_) {
throw std::runtime_error("Nullable value is not set");
}
return value_;
}
virtual void set(const T& value) {
hasValue_ = true;
value_ = value;
}
protected:
bool hasValue_;
T value_;
};
template <typename T>
class NullableWithDefault : public Nullable<T> {
public:
NullableWithDefault(const std::function<T()>& defaultValue) : Nullable<T>(), defaultValue_(defaultValue) {}
T get() const override {
if (!Nullable<T>::hasValue_) {
return defaultValue_();
}
return Nullable<T>::get();
}
protected:
std::function<T()> defaultValue_;
};
class FloatStorageNullableWithDefault : public NullableWithDefault<float> {
public:
FloatStorageNullableWithDefault(
const std::string& key,
const std::function<float()>& defaultValue
) : NullableWithDefault<float>(defaultValue), key_(key) {}
/// returns the key
std::string getKey() const { return key_; }
private:
const std::string key_;
};
I see you're trying to create a nullable value with a default value function and a key to retrieve a potential customization of the value from the flash storage. However, you're getting a compile error when trying to instantiate it as a property member.
The issue is that you're trying to initialize a non-static member variable with a non-constant expression. In C++, you can't initialize a non-static member variable with a function call or a non-constant expression.
To fix this, you can use an initializer list in the constructor of your BatteryConfig class. Here's the corrected code:
class BatteryConfig {
public:
BatteryConfig() : packL1Undervoltage("PackL1UndervoltageKey", _defaultPackL1Undervoltage) {}
FloatStorageNullableWithDefault packL1Undervoltage;
static float _defaultPackL1Undervoltage() { /* implementation */ }
};
By using an initializer list, you're ensuring that the packL1Undervoltage member is initialized with the correct arguments when the BatteryConfig object is constructed.
Alternatively, you can also use a default member initializer, which is a new feature in C++11:
class BatteryConfig {
public:
FloatStorageNullableWithDefault packL1Undervoltage = FloatStorageNullableWithDefault("PackL1UndervoltageKey", _defaultPackL1Undervoltage);
static float _defaultPackL1Undervoltage() { /* implementation */ }
};
This way, you can initialize the packL1Undervoltage member with the default value without needing an initializer list in the constructor.