字符串相关总结

str系列函数

• 字符串的搜索，返回的都是第一次出现的位置，找不到则返回NULL

// 搜索单个字符
char *strchr(const char *s, int c);  // 从前往后
char *strrchr(const char *s, int c); // 从后往前
// 在s1中搜索s2中任一字符，不包括"\0"
char *strpbrk(const char *s1,const char *s2); 
// 搜索子串，不包括"\0"
char *strstr(const char *haystack, const char *needle);

• 字符串的连接

// 把src连接到dest后面，返回连接后的dest
char *strcat(char *dest, const char *src); 
char *strncat(char *dest, const char *src, size_t count);

wchar_t *wcscat(wchar_t *dest, const wchar_t *src); 
wchar_t *wncat(wchar_t *dest, const wchar_t *src, size_t count);

• 字符串的分割

//将String中保存的字符串，按照Delimiter中的字符作为分隔符进行分割。
//Context用于记录分割一次后String中下一个字符串的位置。
//如果String为NULL，则SAVE_PTR在下一次调用中将作为起始位置
char *strtok_s(char *String, const char *Delimiter, char **Context);

• 字符串的反转

char *strrev(char *str); // 注意这个函数的参数不能是常量字符串
wchar_t *_wcsrev(wchar_t *str);

• 字符串的比较，相等则返回0

int strcmp(const char *str1, const char *str2);
int strncmp(const char *str1, const char *str2, size_t count); 
int _stricmp(const char *str1, const char *str2); // 不区分大小写
int _strnicmp(const char *str1, const char *str2, size_t count);


int wcscmp(const wchar_t *str1, const wchar_t *str2);
int wcsncmp(const wchar_t *str1, const wchar_t *str2, size_t count); 
int _wcsicmp(const wchar_t *str1, const wchar_t *str2); // 不区分大小写
int _wcsnicmp(const wchar_t *str1, const wchar_t *str2, size_t count);

• 字符串的拷贝

// 把src拷贝到dest，包括空值和结束符
char *strcpy(char *dest, const char *src); 
char *strncpy(char *dest, const char *src, size_t count);
// 拷贝字符串到新的内存，注意，用于接收返回值的指针，要用free手动释放内存
char *strdup(const char *str); 

wchar_t *wcscpy_s(wchar_t *dest, const wchar_t *src);
wchar_t *wcsncpy(wchar_t *dest, const wchar_t *src, size_t count);
wchar_t *wcsdup(const wchar_t *str); 

• 字符串的大小，注意不包括"\0"

size_t strlen(const char *str); // strlen("abcd") = 4;
size_t wcslen(const wchar_t *str); // wcslen(L"abcd") = 4;

mem系列函数

// 设置内存，将buffer的前count个字符设为count
void *memset(void *buffer, int ch, size_t count); 

// 内存拷贝，将src的前count个字符拷贝到dest，区别在与当dest和from重叠时
void *memcpy(void *dest, const void *src, size_t count);  //行为不确定
void *memmove(void *dest, const void *src, size_t count); //正常

// 内存查找，在buffer中找ch字符，返回首次出现的位置，没找到则返回NULL
void *memchr(const void *buffer, int ch ,size_t count);

// 内存匹配，比较buffer1和buffer2的前count个字符
int memcmp(const void *buffer1, const void *buffer2, size_t count);

Rtl系列函数

SIZE_T RtlCompareMemory (const VOID *Source1, const VOID *Source2, SIZE_T Length);
PVOID RtlSecureZeroMemory(PVOID ptr. SIZE_T cnt);

#define RtlEqualMemory(Destination,Source,Length)         (!memcmp((Destination),(Source),(Length)))
#define RtlMoveMemory(Destination,Source,Length)           memmove((Destination),(Source),(Length))
#define RtlCopyMemory(Destination,Source,Length)           memcpy((Destination),(Source),(Length))
#define RtlFillMemory(Destination,Length,Fill)             memset((Destination),(Fill),(Length))
#define RtlZeroMemory(Destination,Length)                 memset((Destination),0,(Length))

字符串大小相关

#ifndef ARRAYSIZEOF
#define ARRAYSIZEOF(x)  sizeof (x) / sizeof (x[0])
#endif

sizeof("abcd") = 5;
sizeof(L"abcd") = 10;
wcslen(L"abcd") = 4;
strlen("abcd") = 4;
ARRAYSIZE("abcd") = 5;
ARRAYSIZE(L"abcd") = 5;
ARRAYSIZEOF("abcd") = 5;
ARRAYSIZEOF(L"abcd") = 5;
string v1 = "abcd";
v1.size() = 4;
wstring v2 = L"abcd";
v2.size() = 4;

PCHAR和PWCHAR的相互转换

PCHAR转PWCHAR

WCHAR DestPath[MAX_PATH] = {
    
     0 };
PCHAR TempPath = "C:\\test\\test.txt";
mbstowcs_s(NULL, DestPath, MAX_PATH, TempPath, MAX_PATH);

PWCHAR转PCHAR

CHAR Temp[MAX_PATH] = {
    
     0 };
PWCHAR FilePath = L"C:\\test\\test.txt";
wcstombs_s(NULL, Temp, MAX_PATH, FilePath, MAX_PATH);

std::string和std::wstring的相互转换

std::string
wstr2str(std::wstring wstr, UINT CodePage)
{
    
    
    std::string str;
    PCHAR temp = NULL;
    INT Len = 0;

    Len = WideCharToMultiByte(CodePage, 0, wstr.c_str(), -1, NULL, NULL, NULL, NULL);
    if (Len == 0)
    {
    
    
        return str;
    }
    temp = new char[Len + 1];
    if (temp == NULL)
    {
    
    
        return str;
    }
    WideCharToMultiByte(CodePage, 0, wstr.c_str(), -1, temp, Len, NULL, NULL);
    temp[Len] = '\0';
    str.append(temp);
    delete[] temp;
    return str;
}

std::wstring
str2wstr(std::string str, UINT CodePage)
{
    
    
    INT          nLen = 0;
    PWCHAR       temp = NULL;
    std::wstring wstr;

    nLen = MultiByteToWideChar(CodePage, 0, str.c_str(), -1, NULL, NULL);
    if (nLen == 0)
    {
    
    
        return wstr;
    }
    temp = new WCHAR[nLen + 1];
    if (temp == NULL)
    {
    
    
        return wstr;
    }
    temp[nLen] = L'\0';
    nLen = MultiByteToWideChar(CodePage, 0, str.c_str(), -1, temp, nLen);
    wstr = temp;
    delete []temp;
    return wstr;
}

十六进制转成string

std::string 
HexArrayToString(PCHAR data, INT len)
{
    
    
    const std::string hexme = "0123456789ABCDEF";
    std::string ret = "";
    for (int i = 0; i < len; i++)
    {
    
    
        ret.push_back(hexme[(data[i] & 0xF0) >> 4]);
        ret.push_back(hexme[data[i] & 0x0F]);
    }
    return ret;
}

获得系统环境变量

_dupenv_s 和 _wdupenv_s，用完记得free

// 单字
PCHAR TempPath = (PCHAR)malloc(MAX_PATH);
size_t Length = 0;
_dupenv_s(&TempPath, &Length, "temp");

// 双字
PWCHAR TempPath = (PWCHAR)malloc(MAX_PATH);
size_t Length = 0;
_wdupenv_s(&TempPath, &Length, L"ProgramFiles");