Question

我正在玩使用可变参数模板的命名/类型化参数，并具有以下类：

class audio_source_t
{
public:

    virtual ~audio_source_t()
    {
    }

    template<typename T...>
    void receive(const T&... args)
    {
        auto tuple = std::tie(args...);

        receive_impl(std::get<boost::optional<sample_rate_t>>(tuple),
                     std::get<boost::optional<nb_channels_t>>(tuple));                   
    }

private:

    virtual void receive(audio_frame_t& destination,
                         const boost::optional<sample_rate_t>& sample_rate_hint = nullptr,
                         const boost::optional<nb_channels_t>& nb_channels_hint = nullptr) const;
};

参数类型定义为：

template<typename T>
class explicit_class
{
public:
    explicit sample_rate_t(T value)
        : value_(value)
    {
    }

    explicit operator T()
    {
        return value_;
    }

private:
    T value_;
};

class sample_rate_t : public explicit_class<int>{};
class nb_channels_t : public explicit_class<int>{};

到目前为止一直很好，现在我可以按如下方式使用该类：

audio_source.receive(boost::optional<sample_rate_t>(48000),
                     boost::optional<nb_channels_t >(2));

audio_source.receive(boost::optional<nb_channels_t>(2), 
                     boost::optional<sample_rate_t>(48000));

参数顺序无关紧要，它是明确的，很棒。

但是，如果可选参数实际上是可选的并且我不需要为指定的参数提及boost::optional，那就更好了，例如

audio_source.receive(sample_rate_t(48000), 
                     nb_channels_t(2));

audio_source.receive(nb_channels_t(2), 
                     sample_rate_t(48000));

audio_source.receive(sample_rate_t(48000));

audio_source.receive(nb_channels_t(2));

我知道我可以简单地创建所有可能的重载，但是当我达到+3参数时，很快变得不切实际。

关于如何实现这一改进的任何建议？

基本上我需要的是：

get_or_nullptr_t<sample_rate_t>(tuple)

在编译期间可以决定元组是否包含类型，否则返回std::nullptr_t()。

使用可变参数模板命名/输入参数

0 个答案: