Question

tl; dr：有没有办法将当前作用域中的默认参数添加到C ++中的所有隐式构造函数中？

我目前正在为C ++中的嵌入式语言设计一个接口。目标是使语法正确的表达式的创建既安全又方便。现在，我认为学习像boost :: proto这样的重量级实现会在开发过程中产生太大的延迟，所以我试图推出自己的实现。

这是一个小型演示：

#include <iostream>
#include <string>
#include <sstream>

class ExprBuilder
{
public:
    ExprBuilder(const int val) : val(std::to_string(val)) {}
    ExprBuilder(const std::string val) : val(val) {}
    ExprBuilder(const char* val) : val(val) {}

    ExprBuilder(const ExprBuilder& lhs, const ExprBuilder& arg) {
        std::stringstream ss;
        ss << "(" << lhs.val << " " << arg.val << ")";
        val = ss.str();
    }

    const ExprBuilder operator()(const ExprBuilder& l) const {
        return ExprBuilder(*this, l);
    }

    template<typename... Args>
    const ExprBuilder operator()(const ExprBuilder& arg, Args... args) const
        {
            return (*this)(arg)(args...) ;
        }

    std::string val;
};

std::ostream& operator<<(std::ostream& os, const ExprBuilder& e)
{
    os << e.val;
    return os;
}

int main() {
    ExprBuilder f("f");
    std::cout << f(23, "foo", "baz") << std::endl;
}

正如您所看到的，由于C ++重载和隐式转换，嵌入表达式相当简单。

然而，我面临一个实际问题：在上面的示例中，所有数据都以std :: string对象的形式分配。在实践中，我需要一些更复杂的（AST节点），这些东西在堆上分配并由专用所有者管理（遗留代码，不能更改）。所以我必须传递一个唯一的参数（所述所有者）并将其用于分配。我宁愿不在这里使用静态字段。

我正在搜索的是一种使用方法，每次使用构建器时都要求用户提供这样的所有者，但是方便。像动态范围变量之类的东西会很棒。有没有办法在C ++中获得以下内容：

class ExprBuilder
{
    ...
    ExprBuilder(const ExprBuilder& lhs, const ExprBuilder& arg) {
        return ExprBuilder(owner.allocate(lhs, rhs)); // use the owner implicitly
    }
    ...
};

int main() {
    Owner owner; // used in all ExprBuilder instances in the current scope
    ExprBuilder f("f");
    std::cout << f(23, "foo", "baz") << std::endl;
}

这可能吗？

编辑：我想澄清为什么我（直到现在）不考虑全局变量。所有者必须在某些时候由构建器的用户手动释放，因此我不能创建一个ad hoc。因此，用户可能完全“忘记”所有者。为了避免这种情况，我正在寻找一种方法来强制执行typechecker的所有者。

Answer 1

如果没有全局/静态变量，这几乎是不可能的，因为没有全局/静态信息，局部变量Owner owner和ExprBuilder f就无法了解彼此。

我认为最干净的方法是添加

static Owner* current_owner;

到ExprBuilder课程。然后，您可以添加一个新类ScopedCurrentOwnerLock，它在构造函数中设置current_owner并在析构函数中将其设置为nullptr。然后你可以使用它类似于互斥锁：

class ScopedCurrentOwnerLock {
public:
    ScopedCurrentOwnerLock(Owner const& owner) {
        ExprBuilder::current_owner = &owner;
    }
    ~ScopedCurrentOwnerLock() {
        ExprBuilder::current_owner = nullptr;
    }
};

int main() {
    Owner owner;
    ScopedCurrentOwnerLock lock(owner);
    ExprBuilder f("f");
}

如果您有权访问Owner代码，则可以省略ScopedCurrentOwnerLock类，并直接在Owner的构造函数/析构函数中设置/取消设置指针。

请注意此解决方案存在以下两个问题：

如果在锁定超出范围之前所有者超出范围，则指针无效。
如果您同时拥有多个锁，则静态指针具有不可预测的行为，例如： G。由于多线程。

Answer 2

您的所有ExprBuilders都依赖于Owner，而您并不想要全球状态。所以你必须将所有者传递给每个构造函数。

如果您真的不想将owner,添加到块中的所有实例化中，您可以创建一个工厂来为您传递它。

struct ExprBuilderFactory
{
    Owner & owner;
    ExprBuilder operator()(int val) { return ExprBuilder(owner, val); }
    ExprBuilder operator()(char * val) { return ExprBuilder(owner, val); }
    // etc
}

int main() {
    Owner owner;
    ExprBuilderFactory factory{ owner };
    ExprBuilder f = factory("f");
}

转换构造函数的隐含参数

2 个答案: