是否有可能每个类只传递一次变量但不能使它变为静态变量？

Question

This question is (loosely) related to something I asked yesterday here .

I have just refactored a container class ( Ecosystem ), which contains pointers to Individual s:

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...
}

I am now in the situation where I have to pass config with practically every function call to Individual objects. Initially I thought, well, I'll just make a static Config config; inside Individual , but soon I realised that I need to be able to create multiple coexisting ecosystems with different configurations.

If I understand the implications of static correctly, if I have static Config config; inside Individual which is assigned the value of config from Ecosystem , it will get overwritten each time I create a new ecosystem.

My question is: is there a way to pass config once to the Individual class without making it static in order to avoid passing it as an argument with each function?

I have considered having Config* config in both Ecosystem and Individual , but this means that every individual will have a pointer to the config object, which seems clunky. What I need is the equivalent of a static member whose scope is aware of the container hierarchy, if that makes any sense.

Once created, a Config object will not be altered, so it's possible to have a const Config config; .

Thank you in advance for any suggestions!

---

EDIT 1

Thank you everyone for your responses. Matthew Kraus had a point that I didn't provide the right constructor of my Ecosystem class in the original question, which is, of course, an oversight on my side. I see now that it might have been relevant, but I was focusing more on illustrating what kind of variable access I'm after rather than what my classes look like, so I presented a simple example. Apologies if I brought in confusion to the discussion with my extra comments!

The solutions proposed here are all very good, but I can see from the answers that C++ doesn't have any means of defining such class-level variables without defining them as static . What I need is a class-level variable whose scope is limited to its container. This is just an illustration of my idea, it will not compile (and I am certain by now that this cannot be done in 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;
}

I will go with the suggestion to pass a pointer to the config to each individual at construction time. This will waste space but should be the most easily maintainable solution.

Again, thank you all for your input, and apologies if the question was confusing.

Answer 1

If I understand you correctly, passing a config to a constructor of an Individual should do:

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

You still have to pass Config to every individual constructor, but this is a single point, rather than however many functions Individual will have. Moreover, you could encapsulate the creation of an Individual into a factory method if you felt like the creation was too cumbersome.

Answer 2

If Individual objects shouldn't contain a configuration, then there is always

class ConfiguredIndividualReference
{
private:
    std::shared_ptr<Individal> ptr; // or just Individual* depending on how you use this
    const Config &config;
public:
    // ...
    void func1()
    {
        ptr->func1(config);
    }
    // ...
};

Furthermore, you can make a member function to automatically generate this:

ConfiguredIndividualReference fetch(int id) const {
    return ConfiguredIndividualReference(individuals[id], config);
}

and always use this to fetch the individuals rather than directly accessing the map.

Answer 3

A few answers trickled in while I was working on a solution, but I thought I'd post my answer anyway. Here is a complete solution to see everything in context:

#include <iostream>
#include <string>
#include <map>

class Config
{
public:
    explicit Config(std::string name) : name(name) {}

    std::string getName() const { return name; }

private:
    std::string name;
};

class Individual
{
public:
    // using 'explicit' ensures that an Individual is created with a Config
    explicit Individual(const Config& config) :
        config(config) {}

    std::string getConfigName() const { return config.getName(); }

    void func1() {}
    void func2() {}

private:
    // a "const reference" is read-only
    const Config& config;
};

// notice that the dependency on Config is removed from Ecosystem
class Ecosystem
{
    private:
        // std::map<int, std::shared_ptr<Individual> > individuals;
        // I compiled using Individual*, so be aware
        // of the implications of using a naked ptr vs shared_ptr
        std::map<int, Individual*> individuals

    public:
        Ecosystem() {};

        void sort_individuals();
        void func1(int _individual_id)
        {
            // no dependency on Config
            individuals[_individual_id]->func1();
        }

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

int main()
{
    using namespace std;

    Config globalConfig("global configuration");
    Config localConfig("local configuration");

    // the Config object passed to an Individual must
    // last the lifetime of the Individual
    Individual individualA(globalConfig);
    Individual individualB(localConfig);

    // the following prints "global configuration"
    cout << "individualA config is: " << individualA.getConfigName() << endl;

    // the following prints "local configuration"
    cout << "individualB config is: " << individualB.getConfigName() << endl;

    return 0;
}

As noted in the code, be sure that the Config object out-lives any object that depends on it. Sharing object like this--even if you are making a const reference--removes the physical dependency, but it doesn't remove the logical dependency. In other words, the C++ compiler can compile the Ecosystem class without knowledge of a Config . However, the Ecosystem depends on Individual s, which in turn depend on Config s, so be forewarned. My point here is that a const reference is the vanilla C++ way to do this, but it might be worth considering std::shared_ptr if managing the lifetime of Config objects is anything but trivial.

Edit

I didn't actually use shared_ptr when I compiled this; I used Individual* in the map. Just be aware of the implications of using one vs. the other.

Answer 4

I'm posting a second answer to meet the new requirement of only having one Config per Ecosystem instead of one per Individual :

#include <iostream>
#include <string>
#include <map>

class Config
{
public:
    explicit Config(std::string name) : name(name) {}

    std::string getName() const { return name; }

private:
    std::string name;
};

class Individual
{
public:
    Individual() {}

    void func1(const Config& config) const
    {
        std::cout << config.getName() << std::endl;
    }

    // you might remove the dependency of Config and
    // just pass only the config parameters needed.
    void func2(Type1 configParam1, Type2 configParam2) {}
};

// notice that the dependency on Config is removed from Ecosystem
class Ecosystem
{
public:
    explicit Ecosystem(Config& config) : config(config) {}

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

private:
    // std::map<int, std::shared_ptr<Individual> > individuals;

    // I compiled using Individual*, so be aware
    // of the implications of using a naked ptr vs shared_ptr
    std::map<int, Individual*> individuals;

    const Config& config;    
};

int main()
{
    using namespace std;

    Config globalConfig("global configuration");

    // Config objects don't need to be created in main();
    // you could create them on the heap, too:
    Config* localConfig = new Config("local configuration");

    Ecosystem ecosystemA(globalConfig);
    Ecosystem ecosystemB(*localConfig);

    // TODO: add Individuals to each Ecosystem

    // clean up objects on heap
    delete localConfig;

    return 0;
}

I feel like we already answered the OP's original question of "is there a way to pass config once to the Individual class without making it static in order to avoid passing it as an argument with each function" . This example gives a few more options.

The addition here is creating the Config object on the heap. This makes the caller of Ecosystem(Config& config) responsible for managing the Config object. Again, this doesn't have to happen in main() , but you might modify my example to use smart pointers to automatically manage the lifetime of Config objects.