小编pri*_*tor的帖子

好吧,我读了很多"无法推断模板论证"的问题,但似乎没有一个与我的案例相符 - 或者我不明白答案......

有一个我觉得正确的方向,但我没有为我的问题提取解决方案.

我标题中的精简代码如下所示:

template<typename T>
class TemplateProblem
{
public:
    // Do I really need this or did I miss something from the STL?
    template<typename Tin, typename Tout>
    struct UnaryFunction : public std::unary_function<Tin, Tout>
    {
        virtual Tout operator()(Tin input) = 0;
    };

    template<typename Tin, typename Tout>
    struct StaticCast : public UnaryFunction<Tin, Tout>
    {
        virtual Tout operator()(Tin input)
        {
            return static_cast<Tout>(input);
        }
    };

private:
    T * const _data;
    T const _bias;

    template<typename Tin>
    void Init(Tin * data, int …

我想用我的类替换一些原始指针,std::shared_ptr以便在创建该类的副本时我不必担心.但原始指针指向动态数组.当您为其提供自定义删除器时,可以使用带动态数组的shared_ptr,例如:G.default_delete<T[]>.

但是,当我尝试为该字段分配新值时,即使在构造时,我也会得到一个大错误列表.

这是一个最小的代码示例:

#include <memory>
#include <cstddef>

using namespace std;

template<typename T> shared_ptr<T[]> make_shared_array(size_t size)
{
  return shared_ptr<T[]>(new T[size], default_delete<T[]>());
}

struct Foo
{
  shared_ptr<char[]> field;
};

int main()
{
  Foo a;
  // This line produces the error.
  a.field = make_shared_array<char>(256);

  return 0;
}

NB:是的,我知道我可以/应该vector而不是动态数组.但他们的表现并不相同.我做了一些繁重的图像处理,数组保持像素.在低于VGA分辨率的情况下,处理时间从8秒增加到11秒.那是非常多的.

更新:当然我可以在这里提供错误.我只是不知道我是否应该用它弄乱问题描述.但这里是:

C:\ Program Files(x86)\ Microsoft Visual Studio 11.0\VC\INCLUDE\memory(754):错误C2664:'std :: _ Ptr_base <_Ty> :: _ Reset0':无法将参数1从'char '转换为'char ()[]'
与
[
_Ty = char []
] …

我有一个coins = [200; 100; 50; 20; 10; 5; 2; 1] 列表和这个递归函数来计算有多少种方法可以提供一定量的变化（Project Euler 问题 31 的剧透警报）：

let rec f acc coins amount =
    if amount < 0 then 0L
    elif amount = 0 then acc
    else
        match coins with
        | [] -> 0L
        | c::cs ->
            f (acc + 1L) coins (amount - c) + f acc cs amount

除了 aStackOverflowException对于大值之外，该函数需要很长时间。所以我想起了Y 组合器，并很好奇如何将它应用于这个问题。在一点帮助和对函数签名的两个小改动后，我得到了这个：

let f f acc coins amount =
    if amount < …

在Martin等人的论文中.我读到了有关nestet数据类型的高效广义折叠.本文讨论了Haskell,我想在F#中尝试一下.

到目前为止,我设法遵循Nest包括实施的例子gfold.

type Pair<'a> = 'a * 'a
type Nest<'a> = Nil | Cons of 'a * Nest<Pair<'a>>

let example =
    Cons(1,
        Cons((2, 3),
            Cons(((4, 5), (6, 7)),
                Nil
            )
        )
    )

let pair (f:'a -> 'b) ((a, b):Pair<'a>) : Pair<'b> = f a, f b

let rec nest<'a, 'r> (f:'a -> 'r) : Nest<'a> -> Nest<'r> = function
    | Nil -> Nil
    | Cons(x, xs) -> Cons(f x, nest (pair f) …