C++ 我可以从有符号字符*或无符号字符*中获取字符*？

我必须处理可能未签名的

char

数组（因为它们来自SCSI数据块）。我想用这个函数来处理它们：

template <typename CharT, size_t Len>
std::string strFromArray(CharT (&src) [Len])
{     
    return std::string((typename boost::make_signed<CharT>::type *) src, Len);
}

模板
std:：string strFromArray（图表（&src）[Len]）
{     
返回std:：string（（typename boost:：make_signed:：type*）src，Len）；
}

错误出现在

std:：string

构造函数调用中，它不能接受

signed char

/

unsigned char

，但只接受

char

当然，我可以用

（char*）src

替换强制转换，但是如果传入非char类型，我将丢失所有编译器错误

---

我如何编写它以使其从所有“charry”类型构造字符串？

假设转换为

字符串

表示字节数组携带以null结尾的C字符串（例如字符串文字）：

#包括
#包括
名称空间我的{
使用std:：string；
使用大小=ptrdiff\u t；
名称空间详细信息{
自动是字符类型（字符常量*）->bool；
自动是字符类型（符号字符常量*）->bool；
自动是字符类型（无符号字符常量*）->bool；
}//名称空间详细信息
模板<类字符，大小n>
自动字符串\u来自（Char（&src）[n]）
->串
{     
（void）sizeof（detail:：is_char_type（src））；
返回字符串（src，src+n-1）；
}
}//名称空间我的
auto main（）->int
{
无符号字符常量数据[]=“Blah”；
auto const s=my:：string_from（数据）；
#ifdef测试
wchar_t const wdata[]=L“Blah”；
auto const ungood_s=my:：string_from（wdata）；//未编译。
#恩迪夫
}

如果不是字符串，而是关于任意二进制数据，那么只使用

src+n

而不是

src+n-1

---

但是，对于二进制数据，可能需要单独的长度，即不使用原始数组本身的长度。

假设转换为

字符串

表示字节数组带有以null结尾的C字符串（例如字符串文字）：

#包括
#包括
名称空间我的{
使用std:：string；
使用大小=ptrdiff\u t；
名称空间详细信息{
自动是字符类型（字符常量*）->bool；
自动是字符类型（符号字符常量*）->bool；
自动是字符类型（无符号字符常量*）->bool；
}//名称空间详细信息
模板<类字符，大小n>
自动字符串\u来自（Char（&src）[n]）
->串
{     
（void）sizeof（detail:：is_char_type（src））；
返回字符串（src，src+n-1）；
}
}//名称空间我的
auto main（）->int
{
无符号字符常量数据[]=“Blah”；
auto const s=my:：string_from（数据）；
#ifdef测试
wchar_t const wdata[]=L“Blah”；
auto const ungood_s=my:：string_from（wdata）；//未编译。
#恩迪夫
}

如果不是字符串，而是关于任意二进制数据，那么只使用

src+n

而不是

src+n-1

---

但是，在二进制数据的情况下，可能需要单独的长度，即不使用原始数组本身的长度。

我会尽可能简单，并使用：

#include <iostream>
#include <string>

namespace conv {
    template <size_t len>
    std::string strFromArray(const char(&arr)[len])
    {
        static_assert(len > 0, "don't use zero-sized arrays");
        return std::string(arr, len - 1);
    }

    template <size_t len>
    std::string strFromArray(const unsigned char(&arr)[len])
    {
        static_assert(len > 0, "don't use zero-sized arrays");
        return std::string((const char *)arr, len - 1);
    }
}

int main()
{
    const char charstr[] = "abcd";
    std::string str = conv::strFromArray(charstr);
    std::cout << str << std::endl;

    const unsigned char ucharstr[] = "efg";
    str = conv::strFromArray(ucharstr);
    std::cout << str << std::endl;

/*not possible:
    const wchar_t wcharstr[] = L"hijk";
    str = conv::strFromArray(wcharstr);
*/

}

#包括
#包括
名称空间转换{
模板
std:：string strFromArray（常量字符（&arr）[len]）
{
静态_断言（len>0，“不要使用零大小的数组”）；
返回标准：：字符串（arr，len-1）；
}
模板
std:：string strFromArray（const unsigned char（&arr）[len]）
{
静态_断言（len>0，“不要使用零大小的数组”）；
返回std:：string（（const char*）arr，len-1）；
}
}
int main（）
{
const char charstr[]=“abcd”；
std:：string str=conv:：strFromArray（charstr）；
std：：cout我会尽可能简单，并使用：

#include <iostream>
#include <string>

namespace conv {
    template <size_t len>
    std::string strFromArray(const char(&arr)[len])
    {
        static_assert(len > 0, "don't use zero-sized arrays");
        return std::string(arr, len - 1);
    }

    template <size_t len>
    std::string strFromArray(const unsigned char(&arr)[len])
    {
        static_assert(len > 0, "don't use zero-sized arrays");
        return std::string((const char *)arr, len - 1);
    }
}

int main()
{
    const char charstr[] = "abcd";
    std::string str = conv::strFromArray(charstr);
    std::cout << str << std::endl;

    const unsigned char ucharstr[] = "efg";
    str = conv::strFromArray(ucharstr);
    std::cout << str << std::endl;

/*not possible:
    const wchar_t wcharstr[] = L"hijk";
    str = conv::strFromArray(wcharstr);
*/

}

#包括
#包括
名称空间转换{
模板
std:：string strFromArray（常量字符（&arr）[len]）
{
静态_断言（len>0，“不要使用零大小的数组”）；
返回标准：：字符串（arr，len-1）；
}
模板
std:：string strFromArray（const unsigned char（&arr）[len]）
{
静态_断言（len>0，“不要使用零大小的数组”）；
返回std:：string（（const char*）arr，len-1）；
}
}
int main（）
{
const char charstr[]=“abcd”；
std:：string str=conv:：strFromArray（charstr）；
std:：cout只需在函数中放置一个静态断言，并稍微修改它：

#include <string>

template <typename CharT, std::size_t Len>
std::string strFromArray(CharT (&src) [Len])
{
    // Anythig which looks like a char is considered a char.
    static_assert(sizeof(CharT) == sizeof(char), "Invalid Character Type");
    std::size_t n = Len;
    // Do not use a terminating zero (might be wrong if the source is no char 
    // literal, but an array of binary data.
    if( ! src[n-1])
        --n;
    return std::string(src, src + n);
}

int main()
{
    char c[3] = {};
    signed char sc[3] = {};
    unsigned char uc[3] = {};
    wchar_t wc[3] = {};
    strFromArray(c);
    strFromArray(sc);
    strFromArray(uc);
    // error: static assertion failed: Invalid Character Type
    // strFromArray(wc);
}

#包括
模板
std:：string strFromArray（图表（&src）[Len]）
{
//任何看起来像字符的东西都被认为是字符。
静态断言（sizeof（CharT）=sizeof（char），“无效字符类型”）；
标准：尺寸=长度；
//不要使用终止零（如果源不是字符，则可能是错误的
//文本，但为二进制数据数组。
如果（！src[n-1]）
--n；
返回std:：string（src，src+n）；
}
int main（）
{
char c[3]={}；
有符号字符sc[3]={}；
无符号字符uc[3]={}；
wchar_t wc[3]={}；
strFromArray（c）；
strFromArray（sc）；
strFromArray（加州大学）；
//错误：静态断言失败：无效的字符类型
//strFromArray（wc）；
}
只需在函数中放置一个静态断言，并稍微修改它：

#include <string>

template <typename CharT, std::size_t Len>
std::string strFromArray(CharT (&src) [Len])
{
    // Anythig which looks like a char is considered a char.
    static_assert(sizeof(CharT) == sizeof(char), "Invalid Character Type");
    std::size_t n = Len;
    // Do not use a terminating zero (might be wrong if the source is no char 
    // literal, but an array of binary data.
    if( ! src[n-1])
        --n;
    return std::string(src, src + n);
}

int main()
{
    char c[3] = {};
    signed char sc[3] = {};
    unsigned char uc[3] = {};
    wchar_t wc[3] = {};
    strFromArray(c);
    strFromArray(sc);
    strFromArray(uc);
    // error: static assertion failed: Invalid Character Type
    // strFromArray(wc);
}

#包括
模板
std:：string strFromArray（图表（&src）[Len]）
{
//任何看起来像字符的东西都被认为是字符。
静态断言（sizeof（CharT）=sizeof（char），“无效字符类型”）；
标准：尺寸=长度；
//不要使用终止零（如果源不是字符，则可能是错误的
//文本，但为二进制数据数组。
如果（！src[n-1]）
--n；
返回std:：string（src，src+n）；
}
int main（）
{
char c[3]={}；
有符号字符sc[3]={}；
无符号字符uc[3]={}；
wchar_t wc[3]={}；
strFromArray（c）；
strFromArray（sc）；
strFromArray（加州大学）；
//错误：静态断言失败：无效的字符类型
//strFromArray（wc）；
}