C++ C++；：包含十六进制值的格式字符串

在Visual Studio 2010上使用C++ 尝试提出一个健壮的函数，将十六进制值作为字符串，大小作为整数，然后输出格式化的十六进制值

例如

如果输入字符串为“A2”，大小为1，则输出为“0xA2”

如果输入字符串为“800”，大小为2，则输出为“0x0800”

如果输入字符串为“DEF”且大小为4，则输出为“0x00000DEF”

如果输入字符串为“00775”，大小为4，则输出为“0x00000775”

如果输入字符串为“FB600”，大小为3，则输出为“0x0FB600”

基本思想是，将size乘以2，如果字符串长度小于2，则将前导零添加到十六进制值，然后将其追加“0x”

无论是否添加前导零，都会追加“0x”

正如您在第一个示例中看到的，由于字符串已经包含2个字符，所以没有要添加的零

我提出了下面的函数，但它有内存损坏。另外，当我试图通过调用此函数数百次来处理大量数据时，它会崩溃。看来我的逻辑有记忆漏洞

所以我希望有人能为这个函数提供一个健壮的智能代码

我的尝试：

void formatHexString(char* inputHex, int size, char* outputFormattedHex)
{
    int len = size * 2;
    int diff = len - strlen(inputHex);
    char * tempHex = new char [diff + 2]; //"2" is for holding "0x"
    tempHex[0] = '0';
    tempHex[1] = 'x';

    if (len > strlen(inputHex))
    {

        for (int i = 2; i < ((len - strlen(inputHex)) + 2); i++)
        {
            tempHex[i] = '0';

        }

    }

    strcat(tempHex, inputHex);
    sprintf(outputFormattedHex, "%s", tempHex);

    delete [] tempHex;

    cout <<outputFormattedHex <<endl;
}


int main 
{
    char bbb1[24];
    formatHexString("23", 1, bbb1);
    char bbb2[24];
    formatHexString("A3", 2, bbb2);
    char bbb3[24];
    formatHexString("0AA23", 4, bbb3);
    char bbb4[24];
    formatHexString("7723", 4, bbb4);
    char bbb5[24];
    formatHexString("AA023", 4, bbb5);
    return 0;
}

void formatHexString（char*inputex，int size，char*outputFormattedHex）
{
int len=大小*2；
int diff=len-strlen（inputHex）；
char*tempHex=新字符[diff+2]；/“2”用于保存“0x”
tempHex[0]=“0”；
tempHex[1]=“x'；
if（len>strlen（inputHex））
{
对于（int i=2；i<（（len-strlen（inputHex））+2）；i++）
{
tempHex[i]=“0”；
}
}
strcat（tempHex，inputHex）；
sprintf（outputFormattedHex，“%s”，tempHex）；
删除[]tempHex；
库特
更新：
\define\u CRT\u SECURE\u NO\u警告
#包括
#包括
#包括
#包括
#包括
#包括
void formatHexString（char const*inputex，int size，char*outputFormattedHex）
{
int const input_len（std:：strlen（inputHex））；
如果（！size | |（size*2<输入长度））
大小=输入长度/2+输入长度%2；
std：：stringstream-ss；
ss从您的问题来看，不清楚输入上的前导零会发生什么情况：即输入“00000000 ea”大小2变为“00EA”，或者保留所有前导零

此简单解决方案适用于两种情况（对于第一种情况，bTrim=true）：

如您所知，
strcat（）
附加到现有的以
\0
-结尾的字符串。请指出代码中的特定行，以确保正在以
-strcat
-ed结尾的字符串是以
\0
l-结尾的。此外，最好用纸和铅笔计算出当
大小为2和
时会发生什么情况putHex
是“死牛肉”（这是一个有效的十六进制数）为什么你用C++风格的C字符串来折磨自己？你可以用<代码> STD::String < /代码>使你的生活轻松10倍。如果你使用<代码> STD::String 而不是C风格字符串，那么你的问题就一定会解决。如果你有数字而不是字符串，如果你对C有把握，<代码> Prtff < /C>或<代码>>sprintf
会做你想做的事。使用格式说明符
%#0*x
并将你的长度和要打印的数字传递给它，如下所示：
printf（“%#0*x\n”，len+2，num）
（或者如果
num
是
long int
，请使用
%#0*lx
）我可以使用std:：string。如果有人可以帮忙的话！@DonK“在Visual Studio 2010上使用C++。"您手头确实有日历，是吗？这段代码有以下错误。错误C2734:“input_len”：如果不是外部错误，则必须初始化const对象。错误C2601:“input_len”：本地函数定义是非法的，而且还有更多。@Don K我编辑了我的答案，以避免VS2010无法接受的所有内容。如果仍然存在错误请更具体一些，而不是“太多了”。这段代码很有效！现在的问题是，我无法更改原始函数的参数，因为该函数是从其他应用程序调用的。请参阅我原始问题的更新部分。@DonK我已更新了答案，以适应您更新的问题。
void formatHexString(char* inputHex, int size, char* outputFormattedHex)
{
    string input(inputHex);
    std::size_t const input_len(input.length());

    if (!size || (size * 2 < input_len))
        size = input_len / 2 + input_len % 2;

    std::stringstream ss;
    ss << "0x" << std::setw(2 * size) << std::setfill('0') << input;
    sprintf(outputFormattedHex, "%s", ss.str());
}

#include <iostream>
#include <sstream>
#include <iomanip>
#include <string>
#include <cstddef>

std::string formatHexString(std::string const & input, std::size_t size = 0)
{
    std::size_t const input_len(input.length());

    // always round up to an even count of digits if no size is specified
    // or size would cause the output to be truncated
    if (!size || (size * 2 < input_len))
        size = input_len / 2 + input_len % 2;

    std::stringstream ss;
    ss << "0x" << std::setw(2 * size) << std::setfill('0') << input;
    return ss.str();
}

int main()
{
    std::cout << formatHexString(   "23") << '\n'
              << formatHexString(   "A3", 2) << '\n'
              << formatHexString( "AA23", 4) << '\n'
              << formatHexString( "7723", 4) << '\n'
              << formatHexString("AA023", 4) << '\n';
}

#include <string>
#include <cstddef>

std::string formatHexString(std::string const & input, std::size_t size = 0)
{
    std::size_t const input_len(input.length());

    // always round up to an even count of digits if no size is specified
    // or size would cause the output to be truncated
    if (!size || (size * 2 < input_len))
        size = input_len / 2 + input_len % 2;

    std::string result("0x");

    for (std::size_t i = 0, leading_zeros = size * 2 - input_len; i < leading_zeros; ++i)
        result += '0';

    result += input;
    return result;
}

#define  _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <string>
#include <iomanip>
#include <sstream>
#include <cstddef>
#include <cstdio>

void formatHexString(char const * inputHex, int size, char * outputFormattedHex)
{
    int const input_len(std::strlen(inputHex));

    if (!size || (size * 2 < input_len))
        size = input_len / 2 + input_len % 2;

    std::stringstream ss;
    ss << "0x" << std::setw(2 * size) << std::setfill('0') << inputHex;
    std::strcpy(outputFormattedHex, ss.str().c_str());
}

int main()
{
    char output[24];
    formatHexString("23", 1, output);
    std::cout << output << '\n';

    formatHexString("A3", 2, output);
    std::cout << output << '\n';

    formatHexString("0AA23", 4, output);
    std::cout << output << '\n';

    formatHexString("7723", 4, output);
    std::cout << output << '\n';

    formatHexString("AA023", 4, output);
    std::cout << output << '\n';
}

#include <string>

void formatHexString(std::string & strHex, unsigned int nSize, bool bTrim = true) 
{
    if (bTrim) // Trim leading-zeros:
        strHex = strHex.substr(strHex.find_first_not_of('0'));

    if (nSize > strHex.length()) // Pad with leading-zeros to fit nSize:
        strHex.insert(0, std::string(nSize - strHex.length(), '0').c_str());

    strHex.insert(0, "0x"); // Insert prefix
}

void formatHexString(char* inputHex, int size, char* outputFormattedHex)
{
    std::string strHex(inputHex);
    formatHexString(strHex, size * 2);
    strcpy_s(outputFormattedHex, strHex.length()+1, strHex.c_str()); // Visual Studio
}