我正在尝试为项目的某些类创建类似命名参数的构造函数。

我这样做的方法是定义一个类代理，它将保存参数并将该代理的一个实例传递给我的类的构造函数。

一切正常，直到我不得不派生我的一个类。

基本上我想:我要从基类代理派生新的派生类代理。这也有效，但前提是我只使用派生的代理类参数。

这里举个例子比较容易理解:

class Person
{
public:
    class PersonArgs
    {
    public:
        const std::string& Name() const { return _name; }
        PersonArgs& Name(const std::string& name)
        {
            _name = name;
            return *this;
        }

        const std::string& Surname() const { return _surname; }
        PersonArgs& Surname(const std::string& surname)
        {
            _surname = surname;
            return *this;
        }

    protected:
        std::string _name;
        std::string _surname;
    }

public:
    Person()
        : _name("")
        , _surname("")
    { }

    Person(const PersonArgs& args)
        : _name(args.Name())
        , _surname(args.Surname())
    { }

protected:
    std::string _name;
    std::string _surname;
}

class PersonEx : public Person
{
public:
    class PersonExArgs : public Person::PersonArgs
    {
    public:
        const std::string& Address() const { return _address; }
        PersonExArgs& Address(const std::string& address)
        {
            _address = address;
            return *this;
        }

    protected:
        std::string _address;
    }

public:
    PersonEx()
        : _address("")
    { }

    PersonEx(const PersonExArgs& args)
        : Person(args)
        , _address(args.Address())
    { }

protected:
    std::string _address;
}

int main(int argc, char** argv)
{
    // This is ok since PersonExArgs::Address returns a PersonExArgs&
    PersonEx* p1 = new PersonEx(PersonEx::PersonExArgs().Address("example"));

    // This won't work since PersonExArgs::Name returns a PersonArgs&
    PersonEx* p2 = new PersonEx(PersonEx::PersonExArgs().Address("example").Name("Mark"));
}

基本上，由于我在设置参数时将返回对代理类实例的引用的参数链接在一起，因此当从派生代理类中使用它时它会中断，因为它将返回对基代理类而不是派生代理类的引用，不允许我访问派生的代理参数，也不允许我将其传递给派生类的构造函数。

有人知道如何解决这个问题吗？

最佳答案

也许协变返回类型就是您要找的。
参见 here了解更多详情。

您可以将 PersonArgs 定义为(注意周围放置的 virtual 关键字):

class PersonArgs
{
public:
    const std::string& Name() const { return _name; }
    virtual PersonArgs& Name(const std::string& name)
    {
        _name = name;
        return *this;
    }

    const std::string& Surname() const { return _surname; }
    virtual PersonArgs& Surname(const std::string& surname)
    {
        _surname = surname;
        return *this;
    }

protected:
    std::string _name;
    std::string _surname;
};

然后将 PersonExArgs 定义为(注意 override 和协变返回类型):

class PersonExArgs : public Person::PersonArgs
{
public:
    const std::string& Address() const { return _address; }
    PersonExArgs& Address(const std::string& address)
    {
        _address = address;
        return *this;
    }

    PersonExArgs& Name(const std::string& name) override
    {
       PersonArgs::Name(name);
        return *this;
    }

    PersonExArgs& Surname(const std::string& surname) override
    {
        PersonArgs::Surname(surname);
        return *this;
    }

protected:
    std::string _address;
};

可能这很烦人，因为您必须重写基类中的每个函数，但它做得很好。
在 wandbox 上查看并运行.

关于使用派生类的 C++ 命名参数实现，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/46288075/