这个问题(松散地)与我昨天问的问题有关 here .

我刚刚重构了一个容器类 ( Ecosystem )，其中包含指向 Individual 的指针小号:

class Ecosystem
{
    // This is an interface class providing access
    // to functions in Individual without exposing
    // the Individual class.
    // It performs global operations on the entire ecosystem
    // (like sorting individuals based on certain criteria)
    // but is also capable of invoking functions from the
    // Individual class.
    // It also holds the global configuration for this ecosystem.
    private:
        Config config;
        std::map<int, std::shared_ptr<Individual> > individuals;
    public:
        Ecosystem() {};
        void sort_individuals();
        void func1(int _individual_id)
        {
            individuals[_individual_id]->func1(config);
        }

        void func2(int _individual_id)
        {
            individuals[_individual_id]->func2(config);
        }
        // etc...
};

class Individual
{
    private:

    public:
        Individual() {};
        void func1(const Config& _config)
        {
            // Operations using _config.param_1, _config.param_2, ... 
        }

        void func2(const Config& _config)
        {
            // Operations using _config.param_n, _config.param_m, ... 
        }
        // etc...
}

我现在处于必须通过config的情况几乎所有对 Individual 的函数调用对象。最初我想，好吧，我就做一个 static Config config;里面Individual ，但很快我意识到我需要能够创建多个具有不同配置的共存生态系统。

如果我理解 static 的含义正确，如果我有 static Config config;里面Individual其赋值为 config来自 Ecosystem ，每次我创建一个新的生态系统时，它都会被覆盖。

我的问题是:有没有办法通过 config 一次到 Individual 类而不使其成为静态以避免将其作为每个函数的参数传递？

我考虑过 Config* config在两个Ecosystem和 Individual ，但这意味着每个人都会有一个指向配置对象的指针，这看起来很笨重。我需要的是一个静态成员的等价物，如果它有意义的话，其范围是容器层次结构。

一旦创建，Config 对象将不会被更改，因此可能有一个 const Config config; .

提前感谢您的任何建议!

编辑 1

谢谢大家的回复。 Matthew Kraus 指出我在最初的问题中没有提供我的生态系统类的正确构造函数，这当然是我的疏忽。我现在明白它可能是相关的，但我更多地关注于说明我所追求的变量访问类型而不是我的类是什么样的，所以我提供了一个简单的例子。如果我的额外评论给讨论带来了困惑，我深表歉意!

这里提出的解决方案都很好，但是我从答案中可以看出，C++没有任何方法可以定义此类类级变量而不将它们定义为static。 .我需要的是一个类级变量，其范围仅限于其容器。这只是我的想法的一个例子，它不会编译(我现在可以肯定这不能在 C++ 中完成):

class Ecosystem
{
    // This is an interface class providing access
    // to functions in Individual without exposing
    // the Individual class.
    // It performs global operations on the entire ecosystem
    // (like sorting individuals based on certain criteria)
    // but is also capable of invoking functions from the
    // Individual class.
    // It also holds the global configuration for this ecosystem.

    private:

        Config config;
        std::map<int, std::shared_ptr<Individual> > individuals;

    public:
        Ecosystem(const std::string& _file_name)
        {
            Config cfg(_file_name);

            config = cfg;

            // This is done before any Individual objects are created.
            Individual::set_config(cfg);

            for (int i = 1; i <= 10; ++i)
            {
                individuals[i] = std::make_shared<Individual>();
            }
        };

        void sort_individuals();

        void func1(int _individual_id)
        {
            individuals[_individual_id]->func1();
        }

        void func2(int _individual_id)
        {
            individuals[_individual_id]->func2();
        }
        // etc...
};

class Individual
{
    private:
        // v--- No such thing!
        scoped static Config config;

    public:
        Individual() {};

        void func1()
        {
            // Operations using config.param_1, config.param_2, ... 
        }

        void func2()
        {
            // Operations using config.param_n, config.param_m, ...
        }

        // v--- No such thing!
        scoped static void set_config(const Config& _config)
        {
            config = _config;
        }
        // etc...
}

int main(int argc, char* argv[])
{
    Ecosystem ecosystem1("config_file1.txt");

    Ecosystem ecosystem2("config_file2.txt");

    // Conduct experiments with the two ecosytems.
    // Note that when ecosystem2 is created, the line
    //
    // Individual::set_config(cfg);
    //
    // should *not* overwrite the class-level variable
    // config set when ecosystem1 was created. 
    // Instead, it should create a
    // class-level variable but limited to the scope of ecosystem 2.

    // This operates on Individual 1 in ecosystem 1
    // with the parameters set in config_file1.txt
    ecosystem1->func1(1);

    // This operates on Individual 1 in ecosystem 2
    // with the parameters set in config_file2.txt
    ecosystem2->func1(1);

    return 0;
}

我会同意在构建时将指向配置的指针传递给每个人的建议。这会浪费空间，但应该是最容易维护的解决方案。

再次感谢大家的意见，如果问题令人困惑，我们深表歉意。

最佳答案

如果我没理解错的话，将配置传递给 Individual 的构造函数应该这样做:

class Individual {
    const Config& config_;
public:
    Individual(const Config& c) : config_(c) {}
    void func1() {
        // use config_
    }
};

您仍然必须将 Config 传递给每个单独的构造函数，但这是一个点，而不是 Individual 将具有的许多函数。另外，如果觉得创建一个Individual太麻烦，可以将其封装成一个工厂方法。

关于c++ - 是否可以在每个类中只传递一次变量而不是将其设为静态？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/32002421/