C++级联operator[]到operator()参数列表？

Question

我有一个带有 operator() 的类，如下所示：

struct S
{
    int operator()(int a, int b, int c, int d);
};

示例用法：

S s;
int i = s(1, 2, 3, 4);

我需要我的用户能够使用备用语法：

int i = s[1][2][3][4]; // equivalent to calling s(1, 2, 3, 4)

我知道我需要添加 S::operator[]( int a) 并且它需要返回一个辅助对象。但除此之外，一切都变得有点复杂，我有一种感觉，我正在重新发明轮子，因为其他库（例如多维数组）可能已经提供了类似的接口。

理想情况下，我只需使用现有的库来实现此目标。如果做不到这一点，我怎样才能用最通用的代码来实现我的目标呢？

编辑：理想情况下，我希望在现代优化编译器上实现这一目标，而不会造成任何运行时损失。

Answer 1

开始了！

首先，代码有点混乱——我必须在执行过程中累积参数值，而我能想到的唯一方法（至少在 C++03 中）是将立即索引设置为数组。

我已经在 G++ 4.5.1 (Windows / MinGW) 上检查过这一点，并确认在 -O3 上调用：

s[1][2][3][4];

产生相同的汇编代码as:

s(1,2,3,4);

因此，如果您的编译器能够智能优化，则不会产生运行时开销。 干得好，GCC 团队！

代码如下：

#include <iostream>

template<typename T, unsigned N, unsigned Count>
struct PartialResult
{
    static const int IndicesRemembered = Count-1-N;
    T& t;
    int args[IndicesRemembered];
    PartialResult(T& t, int arg, const int* rest) : t(t) {
        for (int i=0; i<IndicesRemembered-1; ++i) {
            args[i] = rest[i];
        }
        if (IndicesRemembered>0) args[IndicesRemembered-1] = arg;
    }
    PartialResult<T, N-1, Count> operator[](int k) {
        return PartialResult<T, N-1, Count>(t, k, args);
    }
};

template<typename T, unsigned Count>
struct PartialResult<T, 0, Count>
{
    static const int IndicesRemembered = Count-1;
    T& t;
    int args[IndicesRemembered];
    PartialResult(T& t, int arg, const int* rest) : t(t) {
        for (int i=0; i<IndicesRemembered-1; ++i) {
            args[i] = rest[i];
        }
        if (IndicesRemembered>0) args[IndicesRemembered-1] = arg;
    }
    void operator[](int k) {
        int args2[Count];
        for (int i=0; i<Count-1; ++i) {
            args2[i] = args[i];
        }
        args2[Count-1] = k;
        t(args2);
    }
};

template<typename T, unsigned Count>
struct InitialPartialResult : public PartialResult<T, Count-2, Count> {
    InitialPartialResult(T& t, int arg)
        : PartialResult<T, Count-2, Count>(t, arg, 0) {}
};

struct C {

    void operator()(const int (&args)[4]) {
        return operator()(args[0], args[1], args[2], args[3]);
    }
    void operator()(int a, int b, int c, int d) {
       std::cout << a << " " << b << " " << c << " " << d << std::endl;
    }
    InitialPartialResult<C, 4> operator[](int m) {
        return InitialPartialResult<C, 4>(*this, m);
    }

};

说真的，请不要使用这个，只坚持使用 operator()。 :) 干杯！

Answer 2

这是对bind 方法的尝试。我怀疑它是否特别有效，并且其中有一些令人讨厌的部分，但我将其发布以防有人知道如何修复它。请编辑：

template <int N>
struct Helper {
    function_type<N>::type f;
    explicit Helper(function_type<N>::type f) : f(f) {}
    Helper<N-1> operator[](int p) {
        return Helper<N-1>(bound<N-1>(f,p));
    }
};

template<>
struct Helper<0> {
    function_type<0>::type f;
    explicit Helper(function_type<0>::type f) : f(f) {}
    operator int() {
        return f();
    }
};

Helper<3> S::operator[](int p) {
    return Helper<3>(std::bind(s, _1, _2, _3));
}

其中 s 是一个返回绑定到 this 的 operator() 的表达式。类似于 std::bind(std::mem_fun(S::operator(), this, _1, _2, _3, _4)) 的内容。虽然我不记得 std::bind 是否已经可以处理成员函数，但可能不需要 mem_fun 。

function_type::type 是 std::function，并且 bound< /code> 是 function_type::typebound(function_type::type f, int p) { return std::bind(f, p, _1、_2、..._N)； }。我不确定如何递归地定义它们，但您可以将它们列出到一定限度。

Answer 3

我会完全避免这种情况，只提供 operator()，但如果您真的想尝试一下，想法是您的类型的 operator[] 将返回一个对象一个帮助器类型，它保存对对象的引用和传入的值。该帮助器类将通过再次存储对原始对象的引用和两个调用的参数来实现operator[]到[]。除了最后一个级别（即相当数量的助手）之外，所有级别都必须执行此操作。在最后一个级别，operator[] 将获取其参数以及所有先前存储的值，并使用所有先前存储的值加上当前值调用 operator()。

一种常见的表述方式是，每个中间类型绑定对operator()调用的参数之一，最后一个使用所有绑定参数执行调用。

根据您是否想要支持更多或更少的数组维度，您可能希望/需要使其变得更加复杂以使其通用。一般来说，这是不值得付出努力的，仅仅提供 operator() 通常就是解决方案。请记住，最好让事情尽可能简单：更少的编写工作和更少的维护工作。

Answer 4

这是一个支持任意参数和返回类型的 Fusion 实现。感谢任何能够实现此功能的人（如果您这样做，请告诉我）！

template <class Derived, class ReturnValue, class Sequence>
struct Bracketeer
{
    typedef ReturnValue result_type;
    typedef boost::fusion::result_of::size<Sequence> Size;

    struct RvBase
    {
        Sequence sequence;
        Derived *derived;
    };

    template <int n>
    struct Rv : RvBase
    {
        Rv(Derived *d) { this->derived = d; }
        Rv(RvBase *p) : RvBase(*p) { }
        Rv<n-1> operator[](typename boost::fusion::result_of::at_c<Sequence const, n-1>::type v)
        {
            boost::fusion::at_c<Size::value - 1 - n>(sequence) = v;
            return Rv<n-1>(this);
        }
    };

    template <>
    struct Rv<0> : RvBase
    {
        Rv(Derived *d) { this->derived = d; }
        Rv(RvBase *p) : RvBase(*p) { }
        ReturnValue operator[](typename boost::fusion::result_of::at_c<Sequence, Size::value - 1>::type v)
        {
            boost::fusion::at_c<Size::value - 1>(sequence) = v;
            return invoke(*derived, sequence);
        }
    };

    Rv<Size::value - 1> operator[](typename boost::fusion::result_of::at_c<Sequence, 0>::type v)
    {
        Rv<Size::value> rv(static_cast<Derived*>(this));
        return rv[v];
    }
};

struct S
    :
    Bracketeer<S, int, boost::fusion::vector<int, int, int, int> >
{
    int operator()(int a, int b, int c, int d);
};