如何在 c++ 模板 class 中保存用于计算的值？

Question

Hello I have doubt about keeping values used to calculation in c++ template class.

The scenario is following, we have a plenty of functions which are using some nested calculations in their calculations for setting some states/values etc. Those nested calculations are repetitive for all of those functions.

The problem is in which approach is correct, in case of templates? Keeping those values as member value? Or just calling inline function which will perform calculation inplace? Lets say value of that member function/value is calculated based on template argument and its size and there are some mathematical operations like multiplication, subtraction and divivision, generally say difficult mathematics formula which we don't want to repeat.

Approach with member value:

template <typename T>
class ApproachWithMemberValue {
public:
    void firstOperation()
    {
        member_ = (member_ / importantValueUsedMultipleTime_) + something;
    }

    void secondOperation()
    {
        member_ = (1 / (member_ / importantValueUsedMultipleTime_)) * something;
    }

    //And other plenty of functions which uses importantValueUsedMultipleTime_

private:
    T val_;
    size_t member_;
    constexpr size_t importantValueUsedMultipleTime_ = resultOfOperations;
    //Some mathematical computations based on type of val_ and its value but calculated directly in importantValueUsedMultipleTime_
};

Approach with member function:

template <typename T>
class ApproachWithMemberFunction {
public:
    void firstOperation()
    {
        member_ = (member_ / getImportantValueUsedMultipleTime()) + something;
    }

    void secondOperation()
    {
        member_ = (1 / (member_ / getImportantValueUsedMultipleTime())) * something;
    }

    //And other plenty of functions which uses getImportantValueUsedMultipleTime()

private:
    T val_;
    size_t member_;

    constexpr inline size_t getImportantValueUsedMultipleTime()
    {
        //Some mathematical computations based on type of val_ and its value
        return resultOfOperation;
    }
};

Which approach is better in computation efficiency and code quality? Will calling function getImportantValueUsedMultipleTime() return computed value or put calculation in place where it is used?

Answer 1

To answer the question you asked, it seems that, without optimizations, the version that calls the constexpr function directly, without storing it in a static constexpr member, can generate more code. This difference would probably go away with optimizations, but if you want to be extra sure you can declare the function consteval . See the generated code for each version: https://godbolt.org/z/46xeebbcn

Now, to hopefully answer the question you meant to ask. You need to initialize a static constexpr member with something, in your case presumably a constexpr function that can be evaluated at compile-time, call it getImporantValueUsedMultipleTimes() . If this functions depends on the "type of val_ and its value", then it cannot be evaluated at compile-time, since val_ is a run-time variable.

The solution you are probably looking for is some type of memoization . If you really want the computation to be done at compile-time then maybe something like this: https://godbolt.org/z/o7cqzjjbW

template<typename T>
consteval T computeValue(T arg) {
    return arg * 2;
};

template<typename T>
struct MemoizedValues {
    static inline const std::unordered_map<T, T> k_Values{
        {0, computeValue(0)},
        {1, computeValue(1)}};
};

template<typename T>
T getPrecomputedValue(T arg) {
    return MemoizedValues<T>::k_Values.at(arg);
};

template<typename T>
struct UsingMemoizedValues
{
    T foo() {
        return getPrecomputedValue(m_val);
    }

    T m_val;
};

int main() {
    UsingMemoizedValues<int>{}.foo();
}

But this requires that you know at compile-time all the possible argument values that you might get at run-time (in the example only 0 and 1 are supported), which is a tall ask. More likely you'd need a system that caches the results of a constexpr (note, not consteval ) computeValue() at run-time, and returns that if asked a second time. If you know that there are some values that are commonly used you could initialize the cache with results for those values, as long as you use literals or constexpr arguments then computeValue() should be evaluated at compile-time.

Of course, there are open-source libraries that do this for you, for example https://github.com/jimporter/memo .