#include class geometry { public: // Imagine this is a super resource-intensive function static double calculateArea( const double w, const double h, const double d) { std::cout << "I'm called!!!" << std::endl; return w * h * d; } }; class Cube { private: double m_w, m_h, m_d; // double cachedArea{-1}; // 3. mutable variables can be changed from constant functions mutable double cachedArea{-1}; public: Cube(double w=0.0, double h=0.0, double d=0.0) : m_w(w), m_h(h), m_d(d) { } double area() const { // 1. So, as it is a resource-consuming function, you do not want to call it every time you call the "area" function // return geometry::calculateArea(m_w, m_h, m_d); // NOTE: bad // 2. This function is constant, so you cannot change the values of member variables of a class. Removing the word const from a function declaration is a bad idea: most clients will not understand you, because area() is, in theory, a regular getter, and it should not change anything. The mutable keyword comes to the rescue! if (cachedArea == -1) cachedArea = geometry::calculateArea(m_w, m_h, m_d); return cachedArea; } void addToMe(Cube const& c) { m_w = c.getW(); m_h = c.getH(); m_d = c.getD(); cachedArea = -1; } double getW() const { return m_w; } double getH() const { return m_h; } double getD() const { return m_d; } friend Cube operator+ (Cube const& c1, Cube const& c2); }; Cube operator+ (Cube const& c1, Cube const& c2) { return Cube{c1.m_w+c2.m_w, c1.m_h+c2.m_h, c1.m_d+c2.m_d}; } int main() { Cube a(2.0, 3.0, 4.0); Cube b(0.1, 0.2, 0.3); Cube c = a + b; std::cout << c.area() << std::endl; std::cout << c.area() << std::endl; c.addToMe(a); std::cout << c.area() << std::endl; std::cout << c.area() << std::endl; return 0; }

[C++] mutable keyword