标签: invariants

我想抛出一个运行时异常，以防我的类不变式无效。由于这是编程错误（类似于NullPointerException），因此客户端不应捕获该异常。

应该将异常类声明为私有还是公共（或其他）？

class Foo
{
    // ...

    private static class InvariantsViolated
    {
        // ...
    }
}

是否有关于自定义运行时异常和可见性的准则？

我是Objective-C的新手,并试图弄清楚维护类的rep不变量的最佳方法是什么,因为异常并不是实现它们的适当方式.一个很好的例子就是在这个Fraction类中,作为Kochan 在Objective-C中编程的一个例子,它有这个setter方法:

-(void) setDenominator: (int) d {
    self.denominator = d;
}

所以说你的代表不变的要求的一部分self.denominator != 0.例如,在Java中,强制执行该不变量的最直接的方法是抛出IllegalArgumentExceptionif 0,但在Objective-C中没有意义.另一种方法是添加一个NSError**指针参数来报告问题,但这看起来既像是过度杀戮又喜欢它不适合抽象的本质 - 不像数据库连接,我们不期望零在正常使用中发生的分母分数.那么这里最干净的解决方案是什么？返回整数错误代码？还有别的我想念的？

据我所知,在DbC方法中,前置条件和后置条件附加到函数中.

我想知道的是,这是否也适用于成员函数.

例如,假设我在每个公共函数末尾的开头使用不变量,成员函数将如下所示:

编辑:(清理我的例子)

void Charcoal::LightOnFire() {
  invariant();
  in_LightOnFire();

  StartBurning();    
  m_Status = STATUS_BURNING;
  m_Color = 0xCCCCCC;

  return; // last return in body

  out_LightOnFire();
  invariant();
}

inline void Charcoal::in_LightOnFire() {
  #ifndef _RELEASE_
  assert (m_Status == STATUS_UNLIT);
  assert (m_OnTheGrill == true);
  assert (m_DousedInLighterFluid == true);
  #endif
}

inline void Charcoal::out_LightOnFire() {
  #ifndef _RELEASE_
  assert(m_Status == STATUS_BURNING);
  assert(m_Color == 0xCCCCCC);
  #endif
}

// class invariant
inline void Charcoal::invariant() {
  assert(m_Status == STATUS_UNLIT || m_Status == STATUS_BURNING || m_Status == STATUS_ASHY);
  assert(m_Color == 0x000000 …

拥有以下代码:

#include <iostream>
#include <set>
#include <string>
#include <functional>

using namespace std;

class Employee {
  // ...
  int _id;
  string _name;
  string _title;
public:
  Employee(int id): _id(id) {}

  string const &name() const { return _name; }
  void setName(string const &newName) { _name = newName; }

  string const &title() const { return _title; }
  void setTitle(string const &newTitle) { _title = newTitle; }

  int id() const { return _id; }
};

struct compEmployeesByID: public binary_function<Employee, Employee, bool> {
  bool operator()(Employee const …

我试图理解这两个概念.我正在阅读的手册非常简短,像多通道算法这样的东西对我来说是新的.我想有一些例子(不是代码)我需要在哪里使用不变量或精确变量,只是为了得到一个大致的想法,所以我可以继续而不留下任何东西.

当他们说

GLSL不保证不同着色器中的两个相同计算将产生完全相同的值

我不知道在不同的着色器中我将如何以及何时需要2个相同的计算.

这是 Leslie Lamport 的《教学并发》一文中的一个简单并发程序。

考虑N编号从 0 到N-1每个进程i执行的进程

x[i] := 1
y[i] := x[(i - 1) % N]

并停止，其中每个x[i]初始值都等于 0。（假设每个的读取和写入x[i]都是原子的。）

该算法满足以下性质：每个进程停止后，y[i]至少有一个进程等于1 i。很容易验证：最后i写入的进程y[i]必须将其设置为1。

然后，兰波特评论说

但该进程并未设置y[i]为 1，因为它是最后一个写入的进程y。

该算法满足此属性，因为它保持归纳不变量。你知道那个不变量是什么吗？如果不是，那么你就没有完全理解为什么算法满足这个属性。

所以，

并发程序的归纳不变量是什么？

对于OOP,是不可变的和不变的同义词吗？

我有一种模糊的感觉,存在差异,但我不确定.

我相信不可变通常应用于对象,而不变通常应用于属性/值.

在这两种情况下,对象或变量都将保持不变并且为"真",因此它们看起来非常相似.

感谢任何反馈,因为我正在努力提高我对这些术语理解的准确性,我认为我忽略了微妙的差异.

我开始使用领域驱动设计，并对ValueObject有疑问：

它们可以包含不变量或其他规范吗？

考虑一个不可变的ValueObject：

ValueObject (

  prop integer: Int
  prop string: String

  // Value and copy constructor

  // Observers for integer and string

  // Equality methods on integer and string value

)

我可以添加一些不变量，例如integer > 0 & < 42。或者它们必须是没有任何逻辑的简单传输？

我希望他们可以，但需要确认。

我正在开发一个Android应用程序.

我想将大小设置为这样的char数组:

public char[5] language;

但它不起作用.我必须删除第五个才能使它工作.

我想限制为语言变量的五个字符.我怎样才能做到这一点？

谢谢.

我很难正确识别以下函数的循环不变量:

F(y)
    X <-- 1
    while (y > 1)
        do x <-- x * y
           y <-- y - 1
    return (x)

我已经确定了循环不变量,x = 1 OR x = y!因为该语句作为前置条件保持为真,并且作为后置条件保持为真.

它似乎并不适用于每次迭代,例如,如果y = 3,那么在循环的第一次迭代中,x = 1*3,相当于3和NOT 3!相当于6.

这就是我猜想我的困惑.一些书籍文章声明循环不变量是一个必须在开头或循环(因此是前置条件)等于true的语句,并且必须在循环结束时保持为真(因此在条件后)但不一定需要在循环中保持正常.

上述函数的正确循环不变量是多少？