C++ 编译器选择专门用于数组的模板，但随后尝试将数组参数强制转换为指针

以下代码未能编译，基本上出现以下错误：

variadic_function2.cpp:68:17: note:   template argument deduction/substitution failed:
variadic_function2.cpp:86:53: note:   cannot convert ‘params#0’ (type ‘const char [64]’) to type ‘char*’

第68行是

Helper:：CopyFrom

专门化，因此编译器（g++4.8.1）选择了正确的模板。然而，（对我来说）不可思议的是，它随后试图将

char[64]

转换为

char*

如果第68行从

static bool CopyFrom (F f, T arr[N])

到

然后它编译得很好

有人能帮我理解发生了什么事吗

---

#包括
#包括
#包括
模板
结构辅助程序
{
静态大小\u t Sizeof（）
{
返回sizeof（T）+Helper:：sizeof（）；
}
模板
静态bool CopyFrom（F、T、Params…Params）
{
如果（！f（重新解释铸件（&t），尺寸f（t）））
返回false；
返回帮助程序：：CopyFrom（f，params…）；
}
};
模板
结构辅助程序
{
静态大小\u t Sizeof（）
{
返回大小f（T）；
}
模板
静态bool CopyFrom（F，T）
{
返回f（重新解释铸件（&t），尺寸f（t））；
}
};
模板
结构辅助程序
{
静态大小\u t Sizeof（）
{
返回N*sizeof（T）+Helper:：sizeof（）；
}
模板
静态bool CopyFrom（F，T arr[N]，Params…Params）
{
//如果（！f（重新解释铸件（arr），尺寸（arr）））
//返回false；
返回帮助程序：：CopyFrom（f，params…）；
}
};
模板
结构辅助程序
{
静态大小\u t Sizeof（）
{
返回N*sizeof（T）；
}
模板
静态bool CopyFrom（F，T arr[N]）
{
返回f（重新解释铸件（arr），尺寸（arr））；
}
};
模板
大小\u t GetSizeof（常量参数和…参数）
{
返回Helper:：Sizeof（）；
}
模板
bool CopyFrom（F、常量参数和…参数）
{
返回帮助程序：：CopyFrom（f，params…）；
}
结构单元测试夹具
{
bool Read（常量字符*buf，大小\u t bufLen）
{
m_calltrace.push_back（bufLen）；
返回true；
}
无效重置（）
{
m_calltrace.clear（）；
}
std：：向量m_调用跟踪；
};
int main（）
{
联合测试夹具utf；
char-buf[64]；
CopyFrom（std:：bind（&UnitTestFixture:：Read，&utf，std:：占位符：：_1，std:：占位符：：_2），buf）；
}

模板
bool CopyFrom（F、常量参数和…参数）
{
返回帮助程序：：CopyFrom（f，params…）；
}

当您传递一个

char[64]

时，

params…

将是一个

const char（&）[64]

，它将衰减为

const char*

，不能传递给需要

char*

的函数。删除

const

并编译（至少使用gcc）

此外，

sizeof（arr）

不会执行您期望它执行的操作（它将返回

sizeof char*

，而不是

sizeof char[64]

）。使用

sizeof T[N]

可以很容易地解决这个问题

static bool CopyFrom (F f, const T arr[N])

#include <vector>
#include <functional>
#include <cstddef>

template <typename T, typename...  Params>
struct Helper
{
    static size_t Sizeof()
    {
        return sizeof (T) + Helper<Params...>::Sizeof();
    }

    template <typename F>
    static bool CopyFrom (F f, T t, Params... params)
    {
        if (!f (reinterpret_cast<const char*>(&t), sizeof(t)))
            return false;

        return Helper<Params...>::CopyFrom (f, params...);
    }
};


template <typename T>
struct Helper<T>
{
    static size_t Sizeof()
    {
        return sizeof (T);
    }

    template <typename F>
    static bool CopyFrom (F f, T t)
    {
        return f (reinterpret_cast<const char*>(&t), sizeof(T));
    }
};


template <typename T, size_t N, typename...  Params>
struct Helper<T[N], Params...>
{
    static size_t Sizeof()
    {
        return N * sizeof (T) + Helper<Params...>::Sizeof();
    }

    template <typename F>
    static bool CopyFrom (F f, T arr[N], Params... params)
    {
        // if (!f (reinterpret_cast<const char*>(arr), sizeof(arr)))
        //     return false;

        return Helper<Params...>::CopyFrom (f, params...);
    }
};


template <typename T, size_t N>
struct Helper<T[N]>
{
    static size_t Sizeof()
    {
        return N * sizeof (T);
    }

    template <typename F>
    static bool CopyFrom (F f, T arr[N])
    {
        return f (reinterpret_cast<const char*>(arr), sizeof(arr));
    }
};


template <typename... Params>
size_t GetSizeof (const Params&... params)
{
    return Helper<Params...>::Sizeof();
}


template <typename F, typename... Params>
bool CopyFrom (F f, const Params&... params)
{
    return Helper<Params...>::CopyFrom (f, params...);
}


struct UnitTestFixture
{
    bool Read (const char* buf, size_t bufLen)
    {
        m_calltrace.push_back (bufLen);
        return true;
    }

    void Reset()
    {
        m_calltrace.clear();
    }

    std::vector<size_t> m_calltrace;
};


int main()
{
    UnitTestFixture utf;
    char buf[64];
    CopyFrom (std::bind(&UnitTestFixture::Read, &utf, std::placeholders::_1, std::placeholders::_2), buf);
}

template <typename F, typename... Params>
bool CopyFrom (F f, const Params&... params)
{
    return Helper<Params...>::CopyFrom (f, params...);
}