C++ 跟踪c+中的变化+；班

我们将用一个简单的例子来解释这一点

class Vector
{
    float X;
    float Y;
    float _length;
    float Length();
}

---

如果X或Y发生变化，我只知道如何计算长度并将其指定给_Length。如果它们都没有改变，我只需返回长度。

使你的

浮动X，Y私有，并添加
bool更改也发送到您的类。
更改X，Y将通过setters函数完成，该函数还将
bool changed
设置为false

无论何时调用函数
Length（）它检查
bool changed
变量，如果为false，则重新计算

class Vector
    {
        float X;
        float Y;
        bool changed;
        float _length;

        void setX (float val) { // the same for Y
        X = val;
        changed = true;
        }
        float Length(){
           if (changed)
          //compute Length 
            changed = false;
            return ComputedValue;

       } 

}

使你的
浮动X，Y私有，并添加
bool更改也发送到您的类。
更改X，Y将通过setters函数完成，该函数还将
bool changed
设置为false

无论何时调用函数
Length（）它检查
bool changed
变量，如果为false，则重新计算

class Vector
    {
        float X;
        float Y;
        bool changed;
        float _length;

        void setX (float val) { // the same for Y
        X = val;
        changed = true;
        }
        float Length(){
           if (changed)
          //compute Length 
            changed = false;
            return ComputedValue;

       } 

}

通过setter和getter使
X
和
Y
仅可访问。有一个布尔值，告诉您
\u length
是否是最新的。在
X
和
Y
上，设置器使
长度无效（通过该布尔变量）。获取长度时，检查长度是否有效。如果是，就把它退回。如果不计算，则使其有效并返回。
通过setter和getter使
X
和
Y
仅可访问。有一个布尔值，告诉您
\u length
是否是最新的。在
X
和
Y
上，设置器使
长度无效（通过该布尔变量）。获取长度时，检查长度是否有效。如果是，就把它退回。如果不计算它，请使其有效并返回它。
首先想到的是：

class Vector
{
public:
    void setX(float x)   {changed = true; X = x;}
    void setY(float y)   {changed = true; Y = y;}

    float length()
    {
        if (changed)
            // calculate

        changed = false;
        return _Length;
    }
private:
    floate X, Y, _Length;
    bool changed;
};

编辑：我希望现在的格式化工作…
首先想到的是：

class Vector
{
public:
    void setX(float x)   {changed = true; X = x;}
    void setY(float y)   {changed = true; Y = y;}

    float length()
    {
        if (changed)
            // calculate

        changed = false;
        return _Length;
    }
private:
    floate X, Y, _Length;
    bool changed;
};

编辑：我希望现在格式化工作…
您需要包括一个保护标志（或“无效”值），您可以通过以下修改将其标记为
X
/
Y
：

class Vector {
 public:
  Vector(float x = 0.0, float y = 0.0)
  : X{x}, Y{y}, Length{-1.0f}
  { }

  float x() const { return X; }
  float y() const { return Y; }

  float length() const {
    if (Length < 0.0f) {
      Length = sqrt(X*X + Y*Y);
    }
    return Length;
  }

  void setX(float x) { if (X != x) { Length = -1.0f; } X = x; }
  void setY(float y) { if (Y != y) { Length = -1.0f; } Y = y; }

 private:
  float X;
  float Y;
  mutable float Length;
};

类向量{
公众：
矢量（浮点x=0.0，浮点y=0.0）
：X{X}，Y{Y}，长度{-1.0f}
{ }
float x（）常量{return x；}
float y（）常量{return y；}
浮点长度（）常量{
如果（长度<0.0f）{
长度=sqrt（X*X+Y*Y）；
}
返回长度；
}
void setX（float x）{if（x！=x）{Length=-1.0f；}x=x；}
void setY（float y）{if（y！=y）{Length=-1.0f；}y=y；}
私人：
浮动X；
浮动Y；
可变浮动长度；
};

mutable
限定符意味着这些值不是对象“逻辑”状态的一部分，即使在
Vector
的
const
实例上也可以修改（自然通过
const
成员函数）。
您需要包含一个保护标志（或“无效”值）您通过以下方式标记
X
/
Y
修改：

class Vector {
 public:
  Vector(float x = 0.0, float y = 0.0)
  : X{x}, Y{y}, Length{-1.0f}
  { }

  float x() const { return X; }
  float y() const { return Y; }

  float length() const {
    if (Length < 0.0f) {
      Length = sqrt(X*X + Y*Y);
    }
    return Length;
  }

  void setX(float x) { if (X != x) { Length = -1.0f; } X = x; }
  void setY(float y) { if (Y != y) { Length = -1.0f; } Y = y; }

 private:
  float X;
  float Y;
  mutable float Length;
};

类向量{
公众：
矢量（浮点x=0.0，浮点y=0.0）
：X{X}，Y{Y}，长度{-1.0f}
{ }
float x（）常量{return x；}
float y（）常量{return y；}
浮点长度（）常量{
如果（长度<0.0f）{
长度=sqrt（X*X+Y*Y）；
}
返回长度；
}
void setX（float x）{if（x！=x）{Length=-1.0f；}x=x；}
void setY（float y）{if（y！=y）{Length=-1.0f；}y=y；}
私人：
浮动X；
浮动Y；
可变浮动长度；
};

mutable
限定符意味着这些值不是对象“逻辑”状态的一部分，即使在
Vector
的
const
实例上也可以修改（当然是通过
const
成员函数）。
简单，从变量
X
和
Y
动态计算长度。这样，无论
X
或
Y
是否已更改，您都将始终获得正确的长度

float Vector::Length()const
{
  return sqrt(X * X + Y * Y);
}

简单，通过变量
X
和
Y
动态计算长度。这样，无论
X
或
Y
是否已更改，您都将始终获得正确的长度

float Vector::Length()const
{
  return sqrt(X * X + Y * Y);
}

将
x
和
y
设为私有，并添加两个函数，如

void setX(float x) {
    this -> x = x;
    handleLengthChange();
}

及

函数
handleLengthChange
计算新的长度。
使用
Vector
的每个类现在都将使用上面的方法来更改x或y。
由于x和y是私有的，只需添加两个函数即可获得x和y的值。
使
x
和
y
私有并添加两个函数，如

void setX(float x) {
    this -> x = x;
    handleLengthChange();
}

及

函数
handleLengthChange
计算新的长度。
使用
Vector
的每个类现在都将使用上面的方法来更改x或y。
由于x和y是私有的，只需添加两个函数即可获得x和y的值。
维护保护标志或“无效”值的替代方法是使用指针之类的可空对象，最好是智能指针。当缓存是大于浮动的对象时，这可能更合适

class Vector {
  float X;
  float Y;
  mutable std::unique_ptr<float> length_;

 public:
  Vector() : X(0.0f), Y(0.0f) { }
  Vector(float x, float y) : X(x), Y(y) { }

  float x() const { return X; }
  float y() const { return Y; }

  float length() const {
    if (!length_)
      length_ = std::unique_ptr<float>(new float(sqrt(X*X + Y*Y)));
    return *length_;
  }

  void setX(float x) { if (X != x) { length_.reset(); X = x; } }
  void setY(float y) { if (Y != y) { length_.reset(); Y = y; } }
};

类向量{
浮动X；
浮动Y；
可变标准：：唯一长度；
公众：
向量（）：X（0.0f），Y（0.0f）{}
向量（float x，float y）：x（x），y（y）{
float x（）常量{return x；}
float y（）常量{return y；}
浮点长度（）常量{
if（！length_u2;）
长度=标准：：唯一性（新浮点（sqrt（X*X+Y*Y））；
返回*长度；
}
void setX（float x）{if（x！=x）{length.reset（）；x=x；}
void setY（float y）{if（y！=y）{length.reset（）；y=y；}
};
维护保护标志或“无效”值的替代方法是使用指针之类的可空对象，最好是智能指针。当缓存是大于浮动的对象时，这可能更合适

class Vector {
  float X;
  float Y;
  mutable std::unique_ptr<float> length_;

 public:
  Vector() : X(0.0f), Y(0.0f) { }
  Vector(float x, float y) : X(x), Y(y) { }

  float x() const { return X; }
  float y() const { return Y; }

  float length() const {
    if (!length_)
      length_ = std::unique_ptr<float>(new float(sqrt(X*X + Y*Y)));
    return *length_;
  }

  void setX(float x) { if (X != x) { length_.reset(); X = x; } }
  void setY(float y) { if (Y != y) { length_.reset(); Y = y; } }
};

类向量{
浮动X；
浮动Y；
可变标准：：唯一长度；
公众：
向量（）：X（0.0f），Y（0.0f）{}
向量（float x，float y）：x（x），y（y）{
float x（）常量{return x；}
float y（）常量{return y；}
浮点长度（）常量{