键入的参数

Question

我正在为示波器编写序列，并希望根据使用的范围使用不同对象的构造函数。

所以我想根据范围创建下面提到的对象的构造函数，而不是创建不同的构造函数。因此，例如，对于一个示波器，我只需要极性范围和宽度，因此我从列表中获取对象并动态创建构造函数。

这可能吗？

ScopeTriggerWidth::ScopeTriggerWidth(AnsiString polarity, AnsiString range, double width, double delta, AnsiString source, double upper_value, double lower_value)

很抱歉，如果我的解释不明确，这是我第一次来这里。

Answer 1

如果参数列表可能形成相同的前缀序列，如（A，B），（A，B，C），（A，B，C，D，E）那么您可能有一个默认值的构造函数需要时，比如

MyClass(A a, B b, C c=default_c, D d=default_d, E e=default_e);

但是如果你想说（A，E），那么你将要创建另一个构造函数。

Answer 2

当默认参数不符合您的需求时，例如因为你需要能够设置一个后面的参数而不设置之前的参数，尝试类似于命名参数idiom的东西（注意：未经测试的代码，甚至可能不会编译）：

class ScopeTriggerWithParams {
    private:
         const AnsiString& polarity_;
         const AnsiString& range_;
         double width_ = 4711;
         double delta_ = 42;
         AnsiString source_ = "asdfasdf"s;
         double upper_value_ = 815;
         double lower_value_ = 23;
    public:
         ScopeTriggerWithParams(const AnsiString& polarity,
                                const AnsiString& range):
         polarity_{polarity}, range_{range} {};

         ScopeTriggerWithParams& width(double w) {
             width_ = w;
             return *this;
         };
         ScopeTriggerWithParams& delta(double d) {
             delta_ = d;
             return *this;
         };
         ScopeTriggerWithParams& source(const AnsiString& s) {
             source_ = s;
             return *this;
         };
         // ... 
};

class ScopeTriggerWith {
    // ...
    public:
         ScopeTriggerWith(const ScopeTriggerWithParams& params);
    // ...
};

// ...
auto myScopeTriggerWith =
    ScopeTriggerWith{ScopeTriggerWithParams{"asdf"s, "qwer"s}
                         .delta(42.7)
                         .source("blabla"s)};

另一方面，为什么多个构造函数不是一个选项？使用C ++ 11，他们可以遵循一个实际的构造函数实现。

键入的参数

从下面的讨论中可以得到另一种解决方案：输入参数。这是一个（未经测试的）代码示例：

class Width {
    private:
        double w_;
    public:
        Width() = delete;
        Width(const double w): w_{w} {};
        Width(const Width& w): w_{w.w_} {};

        operator double () const { return w_; };
        Width& operator = (const double w) {
            w_ = w;
            return *this;
        };
        Width& operator = (const Width& w) {
            w_ = w.w_;
            return *this;
        };
};

class Delta {
    private:
        double d_;
    public:
        Delta() = delete;
        Delta(const double d): d_{d} {};
        Delta(const Delta& d): d_{d.d_} {};

        operator double () const { return d_; };
        Delta& operator = (const double d) {
            d_ = d;
            return *this;
        };
        Delta& operator = (const Delta& d) {
            d_ = d.d_;
            return *this;
        };
};

class Source {
    private:
        AnsiString s_;
    public:
        Source() = delete;
        Source(const AnsiString& s): s_{s} {};
        Source(const Source& s): s_{s.s_} {};

        operator double () const { return s_; };
        Source& operator = (const AnsiString& s) {
            s_ = s;
            return *this;
        };
        Source& operator = (const Source& s) {
            s_ = s.s_;
            return *this;
        };
};

class UpperValue {
    private:
        double u_;
    public:
        UpperValue() = delete;
        UpperValue(const double u): u_{u} {};
        UpperValue(const UpperValue& u): u_{u.u_} {};

        operator double () const { return u_; };
        UpperValue& operator = (const double u) {
            u_ = u;
            return *this;
        };
        UpperValue& operator = (const UpperValue& u) {
            u_ = u.u_;
            return *this;
        };
};

class LowerValue {
    private:
        double l_;
    public:
        LowerValue() = delete;
        LowerValue(const double l): l_{l} {};
        LowerValue(const LowerValue& l): l_{l.l_} {};

        operator double () const { return l_; };
        LowerValue& operator = (const double l) {
            l_ = l;
            return *this;
        };
        LowerValue& operator = (const LowerValue& l) {
            l_ = l.l_;
            return *this;
        };
};

class ScopeTriggerWith {
    // ...
    public:
         ScopeTriggerWith(AnsiString polarity, AnsiString range, Width width, Delta delta);
         ScopeTriggerWith(AnsiString polarity, AnsiString range, UpperValue upper_value, LowerValue lower_value);
    // ...
};

// ...
auto myScopeTriggerWith =
    ScopeTriggerWith{"asdf"s, "qwer"s, Width{47.11}, Delta{42.0}};

C ++创建不同的构造函数

2 个答案:

键入的参数