我应该使用静态数据成员吗？ (C++)

发布于 2024-07-10 22:31:42 字数 139 浏览 6 评论 0原文

让我们考虑一个 C++ 类。在执行开始时，我想从 XML 文件中读取一组值并将它们分配给此类的 7 个数据成员。这些值在整个执行过程中不会改变，并且必须由相关类的所有对象/实例共享。静态数据成员是实现此行为的最优雅的方法吗？（当然我不考虑全局变量）

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

╰沐子 2024-07-17 22:31:42

正如其他人提到的，在这种情况下使用静态成员似乎是合适的。请记住，这并不是万无一失的；全局数据的一些问题适用于静态成员：

您无法控制静态成员的初始化顺序，因此您需要确保没有全局变量或其他静态变量引用这些对象。有关更多详细信息，请参阅此 C++ 常见问题解答了解一些避免此问题的提示。
如果您在多线程环境中访问这些成员，您需要确保在生成任何线程之前成员已完全初始化。

回复收藏 0 原文

冷情妓 2024-07-17 22:31:42

对我来说，听起来静态变量很好用。您将这些更多地用作固定参数而不是变量，并且这些值需要合法地共享。

回复收藏 0 原文

太阳男子 2024-07-17 22:31:42

静态成员可以在这里工作并且完全可以接受。另一种选择是对保存这些成员的类使用单例模式，以确保它们是仅构造/设置一次。

回复收藏 0 原文

蘸点软妹酱 2024-07-17 22:31:42

这不是一个干净的设计。静态类成员是全局状态，全局状态不好。

如果这是一个中小型项目并且您对自动测试没有很高的目标，这可能不会给您带来麻烦，但既然您问：有更好的方法。

更简洁的设计是为该类创建一个工厂，并让该工厂在构造该类时将七个变量传递给该类。那么工厂就有责任确保所有实例共享相同的值。

这样你的类就变得可测试，并且你已经正确地分离了你的关注点。

附言。不要使用单例要么。

回复收藏 0 原文

眼藏柔 2024-07-17 22:31:42

听起来像是静态类成员的适当使用。只是不要忘记它们实际上是具有命名空间和（也许）一些保护的全局变量。因此，如果您的应用程序有一天可能会发展出单独的“环境”，或者每个环境都需要一组这样的全局变量，那么您就会把自己逼入绝境。

正如 Rob 建议的那样，考虑使用单例，这样以后更容易转换为某种托管环境变量。

回复收藏 0 原文

情归归情 2024-07-17 22:31:42

在执行开始时，我想从
XML 文件并将它们分配给其中的 7 个
该类的数据成员。那些
整个过程中值不会改变
执行并且必须共享
由所有对象/实例
有问题的类。

粗体字的句子是这里的关键。只要该声明成立，就可以使用静态变量。这将如何执行？

很难。因此，如果您现在可以使用该陈述，那么就继续吧。如果您希望未来的开发人员（或您）使用错误的类（例如在程序中途读取另一个 XML 文件），那么请执行 Rasmus Farber 所说的操作。

回复收藏 0 原文

一指流沙 2024-07-17 22:31:42

是的，静态数据成员就是您所寻找的。但是您必须注意静态变量的初始化/销毁顺序。 C++ 中没有机制可以确保静态变量在跨翻译单元使用之前已初始化。为了安全起见，请使用看起来像单例模式的模式，众所周知，它可以解决该问题。它之所以有效，是因为：

所有静态对象都是在任何 xml_stuff 实例完全构造之后才完全构造的。
C++ 中静态对象的销毁顺序与其构造完成的顺序（当其构造函数完成执行时）完全相反。

代码：

class xml_stuff {
public:
    xml_stuff() {
        // 1. touch all members once
        // => 2. they are created before used
        // => 3. they are created before the first xml_stuff instance
        // => 4. they will be destructed after the last xml_stuff instance is 
        //       destructed at program exit.
        get_member1();
        get_member2();
        get_member3();
        // ...
    }  

    // the first time their respective function is called, these
    // objects will be created and references to them are returned.
    static type1 & get_member1() { static type1 t; return t; }
    static type2 & get_member2() { static type2 t; return t; }
    static type1 & get_member3() { static type1 t; return t; }
    // ... all other 7 members
};

现在，由 xml_stuff::get_memberN() 返回的对象在任何 xml_stuff 实例的整个生命周期内都有效，因为这些成员中的任何一个都是在任何 xml_stuff 实例之前构造的。使用普通静态数据成员，您无法确保这一点，因为跨翻译单元的创建顺序在 C++ 中未定义。

Yes, static datamembers are what you look for. But you have to take care for the initialization/destruction order of your static variables. There is no mechanism in C++ to ensure that your static variables are initialized before you use them across translation units. To be safe, use what looks like the singleton pattern and is well known to fix that issue. It works because:

All static objects are completely constructed after the complete construction of any xml_stuff instance.
The order of destruction of static objects in C++ is the exact opposite of the completion of their construction (when their constructor finishes execution).

Code:

class xml_stuff {
public:
    xml_stuff() {
        // 1. touch all members once
        // => 2. they are created before used
        // => 3. they are created before the first xml_stuff instance
        // => 4. they will be destructed after the last xml_stuff instance is 
        //       destructed at program exit.
        get_member1();
        get_member2();
        get_member3();
        // ...
    }  

    // the first time their respective function is called, these
    // objects will be created and references to them are returned.
    static type1 & get_member1() { static type1 t; return t; }
    static type2 & get_member2() { static type2 t; return t; }
    static type1 & get_member3() { static type1 t; return t; }
    // ... all other 7 members
};

Now, the objects returned by xml_stuff::get_memberN() are valid the whole lifetime of any xml_stuff instance, because any of those members were constructed before any xml_stuff instance. Using plain static data members, you cannot ensure that, because order of creation across translation units is left undefined in C++.

回复收藏 0 原文