如何根据用户输入声明 C++ 构造函数？

Question

I'm learning C++ and stumbled upon an issue I don't know how to solve. I have a class hierarchy of probability distributions. I'm asking the user to input the name of a probability distribution (eg "uniform" ) and its associated parameters, which I'm storing as a tuple of the form

std::tuple<std::string, double, double>

I would then like to call the constructor of the corresponding probability distribution class, for example

continuous_distribution *random_uniform = new uniform{0.0,1.0};

However, I'm not sure how to map the name of the distribution given as a C++ string (1st element of the tuple) to the appropriate constructor. I don't think it's possible to directly convert a string to a constructor or member function. I tried using if statements to check the given name and call the corresponding constructor, but this runs into identifier "x" is undefined problems, apparently because this limits the scope of the constructor to the if statement only. Is there a solution to this problem?

Answer 1

If you really wanted to use dynamic class hierarchies here, a simple factory function would do the trick.

#include <string_view>
#include <memory>

struct distribution {
    virtual float generate() = 0;
    virtual ~distribution() = default;
};

struct uniform : distribution {
    uniform(float, float);
    float generate() final;
};

struct normal : distribution {
    normal(float, float);
    float generate() final;
};

std::unique_ptr<distribution> make_distribution(std::string_view name, 
                                                float x,
                                                float y)
{
    // for a large amount of different names, using a
    // std::unordered_map<std::string, distribution*(*)(float,float)>
    // may be more efficient than an if/else chain
    
    if (name == "uniform") {
        return std::make_unique<uniform>(x, y);
    }
    else if (name == "normal") {
        return std::make_unique<normal>(x, y);
    }
    else {
        return nullptr;
    }
}

However, I would also consider different approaches, such as using a std::variant of different distributions, or simply a std::function or function pointer, assuming that the distributions only have a single virtual function.

Answer 2

I would probably use an unordered_map to do the mapping between the literal name of the distribution and an object capable of generating random numbers using that distribution.

I would avoid runtime polymorphism in this particular case - because people dealing with random number generation are often obsessed with speed and dynamic dispatch comes with some overhead.

Here are the building blocks I'd consider:

• Create a function to return a reference to a seeded PRNG.
• Create simple functions to return references to the distributions you want to support.
• The instances in the above functions should be static - or thread_local if this is ever going to be multithreaded.
• Create a map that returns a lambda capable of reading user supplied parameters, set those parameters in the appropriate distribution and then return another lambda that can be used to call the PRNG using the distribution.

First the prng() function and some examples of distributions:

#include <algorithm>
#include <functional>
#include <iostream>
#include <random>
#include <type_traits>
#include <unordered_map>

auto& prng() {
    thread_local std::mt19937 instance(std::random_device{}());
    return instance;
}
auto& uniform() {
    thread_local std::uniform_real_distribution<double> instance;
    return instance;
}
auto& normal() {
    thread_local std::normal_distribution<double> instance;
    return instance;
}
auto& exponential() {
    thread_local std::exponential_distribution<double> instance;
    return instance;
}

Then the map. It's a little cluttered but follows a pattern:

• Print the wanted parameters to the user. In this example, one distribution only requires 1 parameter and the other requires 2.
• Read the parameter(s) from the user.
• Call the selected distribution function to get a reference to the distribution and set the parameters in that distribution.
• Finally, return a lambda that will act as a generator.

using gen_sig = double (*)(); // the signature of the returned generators

// A map from clear text name to a lambda that reads distribution parameters,
// sets them in the selected distribution and returns another lambda, wrapping
// a call to distribution(prng)
std::unordered_map<std::string, gen_sig (*)(std::ostream&, std::istream&)>
    gen_factories{
        {"uniform", [](std::ostream& os, std::istream& init) -> gen_sig {
             using ptype = std::remove_reference_t<decltype(uniform())>::param_type;
             os << "min max> ";
             double min, max;
             init >> min >> max;
             uniform().param(ptype(min, max)); // set params
             return [] { return uniform()(prng()); };
         }},
        {"normal", [](std::ostream& os, std::istream& init) -> gen_sig {
             using ptype = std::remove_reference_t<decltype(normal())>::param_type;
             os << "mean stddev> ";
             double mean, stddev;
             init >> mean >> stddev;
             normal().param(ptype(mean, stddev)); // set params
             return [] { return normal()(prng()); };
         }},
        {"exponential", [](std::ostream& os, std::istream& init) -> gen_sig {
             using ptype = std::remove_reference_t<decltype(exponential())>::param_type;
             os << "lambda> ";
             double lambda;
             init >> lambda;
             exponential().param(ptype(lambda)); // set params
             return [] { return exponential()(prng()); };
         }},
    };

The interaction with the user could then look like this:

int main() {
    std::string dist;

    while(std::cout << "Select distribution> " && std::cin >> dist) {
        if(auto it = gen_factories.find(dist); it != gen_factories.end()) {

            // get a generator
            auto gen = it->second(std::cout, std::cin);

            // print 10 numbers using the selected distribution
            for(int i = 0; i < 10; ++i) std::cout << gen() << '\n';

        } else {
            std::cout << "ERROR: Distribution \"" << dist << "\" not implemented.\n";
        }
    }
}

Example session:

Select distribution> exponential
lambda> 0.5
0.261241
0.0869284
1.73573
5.00439
1.68901
2.96613
0.583754
0.223562
0.2828
0.146842
Select distribution> uniform
min max> 10 20
17.177
19.587
18.9658
14.5269
11.6994
13.7626
13.8706
19.0378
17.0001
17.4791