如果是第一次则计算，如果是第二次时间则加载

Question

I want to ask if using this pattern is a good practice or not:

I have a class that contains some raw data. I want to conclude some information from this data for example:

class my_class{
public:
    int get_integers_sum();
private:
    std::vector<int> all_integers;
};

assuming that the all_integers is not going to be changed. Is it a good to do this :

 class my_class{
    public:
        int get_integers_sum(){
            if(sum==-1){
                sum=sum=std::acculmate(all_integeres);// the proper code ofcourse
            }

            return sum; 
        }
    private:
        std::vector<int> all_integers;
        int sum=-1;
 };

Answer 1

This is a useful pattern when you know that the input will not change. The general name for this approach is memoization . Your implementation is a bit flawed since the sum of all_integers might actually be -1.

Answer 2

Measure it and find out; never try to optimise without measuring. Bear in mind that on modern CPUs computation is fast and memory access is slow, so the answers may not be what you expect.

And that's before you worry about multiple threads safely calling this code.

Answer 3

As far as I know, this type of caching method is fine. It basically makes sense when you know that get_integers_sum() gets called quite often, but all_integers changes very rarely. But you should keep const correctness and this is one of the cases it's ok to use mutable.

class my_class{
public:
    int get_integers_sum() const { // <- adding const
        if(sum==-1){
            sum=std::acculmate(all_integeres);
        }

        return sum; 
    }
private:
    std::vector<int> all_integers;
    mutable int sum=-1; // <- adding mutable so it can be changed in const function
};