-2

我发现关于 OOP 最烦人的一件事是，每当您在成员函数中需要一个新变量，并且您需要该变量“附加”调用该函数的对象时，您基本上别无选择，只能创建一个新的私有场地。在我看来这很难看，因为这意味着变量在对象实例化时被初始化（如果你不调用需要它的方法，你可能永远无法使用它），它不会对其他可以隐藏的实体隐藏访问对象的私有成员，除此之外，这意味着可能会使您的类定义变得混乱（想想 C++ 类，它通常带有一个包含整个字段定义的标题）。

用 C++ 术语来说，我想要static修饰符对全局函数中变量的行为，但在成员函数中，并且存储必须在对象中。

我不知道那么多语言，但我觉得在动态编程语言中更容易做到。我可以想到 Lua：我只想在当前表中添加一个新索引。这并没有向世界其他地方隐藏新的“领域”，但除非你篡改元表，否则 Lua 中的所有内容都是公开的，所以这在 Lua 思维方式中并不是真正的问题。但是初始化的问题得到了解决。

所以，我的问题是：是否有任何静态编程语言（即，在编译时知道对象布局的语言）可以实现这一点？

顺便说一句，C++ 中是否有一个巧妙的解决方法来获得类似的结果？

4

2 回答 2

0

You say static and by design in static languages every thing about the design of object should addressed in compile time and class can't change it self in runtime. So I don't think any static language can do such a dynamic job, and it is good since it will decrease performance, when you access a variable, in static languages compiler create code to access that variable at compile time but if such a variable (function-object-static) exist, then compiler should write an extra code to check some dynamic storage to see if a property with that name exist or not and this is only because you feel sad with current design of C++!? But on the other hand, if you do not want to do it without changing fields, you can simply add one extra variable to the class of a type that can used for dynamic lookup(for example std::map) and make that variable private so no one except you in your class can access it:

class foo {
    std::map<std::string, boost::any> functionVariables;

public:
    void test1() {
        int visitNumber;
        auto i = functionVariables.find( "test1" );
        if( i == functionVariables.end() ) {
            // This is first visit of the function, initialize your variable
            functionVariables["test1"] = (visitNumber = 0);
        } else {
            // It is already initialized, use it
            visitNumber = ++ *boost::any_cast<int>(&*i);
        }
    }
};
于 2012-10-18T22:36:09.987 回答
0

由于面向对象编程的一般思想是将行为封装为一组方法（函数），并将数据封装为一组实例变量，因此这种行为在我能想到的任何静态编程语言中都不存在。

然而，一些语言已经考虑过将单个类的关注点分成多个单元（以使其不那么单一）的想法。这个想法是在单个对象类中分离各种关注点。尽管变量不是在运行时创建的（这会使类型成为非静态的），但它可以在与其他单元分开的单元中声明。

这实际上在 C# 中是可用的。尽管实现纯粹是装饰性的，但您可以将单个类声明为多个分部类。好处之一是分离关注点，以避免对类封装的所有内容进行单一大声明（另一种用途是代码生成场景）。

这使您可以执行以下操作：

文件1：

partial class Foo {
   int X;
   void DoSomethingWithX() {
        X++;
   }
}

文件 2：

partial class Foo {
   int Y;
   void DoSomethingWithY() {
        Y++;
   }
}
于 2012-10-18T22:43:46.323 回答