4

我正在研究循环潜在的多维数组的东西，并且遇到了一些模板问题。这是我正在尝试做的事情的想法：

template<std::size_t D = 3>
class Deriv {
public:
    typedef typename boost::array<double, D> results_t;

    template<typename Iterator>
    results_t operator()(Iterator& objIterator)
    {
        double u;
        double um1;

        results_t derivs;

        for(results_t::index i = 0; i < D; ++i) {
           u = *objIterator;
           um1 = *(objIterator.left<i>(1));
           derivs[i] = u-um1;
        }
     }
   };
};

因此，它看起来有点令人困惑，但它使用了一个自定义迭代器，该迭代器具有一个left和right模板方法，其中模板参数是要向左或向右移动的维度，参数是偏移量。例如，如果objIterator指向array[i][j][k]，则objIterator.left<0>(1)返回指向 的迭代器array[i-1][j][k]。

显然我发布的内容不起作用，因为i不是编译时间，不能用作left. 我觉得递归可以在这里以某种方式通过替换 for 循环来实现这一点，但我不知道如何。

有什么建议么？

4

3 回答 3

2

这是另一种方法：

template<std::size_t D = 3>
struct Deriv
{
    typedef typename boost::array<double, D> results_t;

private:
    template<std::size_t I>
    struct apply
    {
        template<typename Iterator>
        static void impl(results_t& derivs, Iterator& iter)
        {
            derivs[I] = *iter - *iter.template left<I>(1);
            apply<I + 1>::impl(derivs, iter);
        }
    };

    template<>
    struct apply<D>
    {
        template<typename Iterator>
        static void impl(results_t&, Iterator&) { }
    };

public:
    template<typename Iterator>
    results_t operator ()(Iterator& iter) const
    {
        results_t derivs;
        apply<0>::impl(derivs, iter);
        return derivs;
    }
};

我已经使用 VC++ 2010 进行了测试，但我怀疑它可能无法在更符合标准的编译器上编译。D-1如果您可以从through倒计时0而不是从0through倒计时D-1，那么以下应该没问题：

namespace detail
{
    template<std::size_t I>
    struct apply
    {
        template<typename ResultsT, typename Iterator>
        static void impl(ResultsT& derivs, Iterator& iter)
        {
            derivs[I] = *iter - *iter.template left<I>(1);
            apply<I - 1>::impl(derivs, iter);
        }
    };

    template<>
    struct apply<0>
    {
        template<typename ResultsT, typename Iterator>
        static void impl(ResultsT& derivs, Iterator& iter)
        {
            derivs[0] = *iter - *iter.template left<0>(1);
        }
    };
}

template<std::size_t D = 3>
struct Deriv
{
    typedef typename boost::array<double, D> results_t;

public:
    template<typename Iterator>
    results_t operator ()(Iterator& iter) const
    {
        results_t derivs;
        detail::apply<D - 1>::impl(derivs, iter);
        return derivs;
    }
};
于 2012-04-27T19:21:37.590 回答
0

我没有方便的 C++ 编译器，但这应该可以解决您的问题：

template<typename Iterator, int dimNo>
void processDim(results_t & derivs, Iterator& objIterator) {
    if(dimNo==-1) return;
    double u;
    double um1;
    u = *objIterator;
    um1 = *(objIterator.left<dimNo>(1));
    derivs[dimNo] = u-um1;

    processDim<Iterator,dimNo!=D?dimNo+1:-1>(derivs, objIterator);
}

template<typename Iterator>
results_t operator()(Iterator& objIterator)
{

    results_t derivs;
    processDim<Iterator, 0> (derivs,objIterator);
    return derivs;
}

您的代码中也有一个隐藏的笑脸！

顺便说一句，如果您能够修改Iterator即将到来的类型，那么如果它是模板参数的唯一原因首先是为了性能，您可以让它接收维度作为常规参数（而不是模板参数）。我相信编译器会发现它可以简单地展开循环。这样，您就不需要任何丑陋的递归模板。

于 2012-04-27T19:16:12.067 回答
0

总体思路，按照您认为合适的方式对其进行修改。

// recursive
template<typename Iterator, int I>
void apply(Iterator& objIterator, results_t &derivs, mpl::int_<I>) {
       u = *objIterator;
       um1 = *(objIterator.left<I>(1));
       derivs[I] = u-um1;
       apply(objIterator, derivs, mpl::int_<I-1>());
 }
// terminate
template<typename Iterator>
void apply(Iterator& objIterator, results_t &derivs, mpl::int_<-1>) {}

也看看http://www.boost.org/doc/libs/1_45_0/libs/mpl/doc/refmanual/for-each.html

于 2012-04-27T19:22:33.653 回答