MessageBoxA 和 MessageBoxW的使用用法

2023-12-16 01:56:06

文章目录

1、MessageBoxA 和 MessageBoxW
2、LPCWSTR宽字符字符串（Unicode）与 LPCSTR窄字符字符串（ANSI）的转换
- - 2.1、从 LPCSTR 转换到 LPCWSTR
  - 2.2、从 LPCWSTR 转换到 LPCSTR：
3、宽字符窄字符相互转换

1、MessageBoxA 和 MessageBoxW

1.1、代码实例

WINUSERAPI
int
WINAPI
MessageBoxA(
    __in_opt HWND hWnd,
    __in_opt LPCSTR lpText,
    __in_opt LPCSTR lpCaption,
    __in UINT uType);
WINUSERAPI
int
WINAPI
MessageBoxW(
    __in_opt HWND hWnd,
    __in_opt LPCWSTR lpText,
    __in_opt LPCWSTR lpCaption,
    __in UINT uType);
#ifdef UNICODE
#define MessageBox  MessageBoxW
#else
#define MessageBox  MessageBoxA
#endif // !UNICODE 函数讲解并例子

MessageBoxA 和 MessageBoxW 是 Windows API 中用于显示消息框的函数，分别用于处理 ANSI 字符集（A 表示 ANSI）和 Unicode 字符集（W 表示 Wide）。

1.2、MessageBoxA 函数

int WINAPI MessageBoxA(
    HWND hWnd,
    LPCSTR lpText,
    LPCSTR lpCaption,
    UINT uType
);

hWnd: 指定消息框的父窗口句柄。可以为 NULL。
lpText: 指定消息框中显示的文本。
lpCaption: 指定消息框的标题栏文本。
uType: 指定消息框的样式和按钮，例如 MB_OK 表示只有一个确定按钮。

1.3、MessageBoxW 函数

int WINAPI MessageBoxW(
    HWND hWnd,
    LPCWSTR lpText,
    LPCWSTR lpCaption,
    UINT uType
);

参数和功能同 MessageBoxA，但处理的是宽字符集（Unicode）。

1.4、条件编译

#ifdef UNICODE
#define MessageBox  MessageBoxW
#else
#define MessageBox  MessageBoxA
#endif // !UNICODE

这段代码通过 #ifdef UNICODE 条件编译，根据编译时是否定义了 UNICODE 宏来选择使用 MessageBoxW 还是 MessageBoxA。

1.5、示例代码

#include <windows.h>

int main() {
    LPCWSTR wideText = L"Hello, this is a wide character string!";
    LPCWSTR wideCaption = L"MessageBox Example";
    
    // 使用 MessageBoxW 显示 Unicode 字符串消息框
    MessageBox(NULL, wideText, wideCaption, MB_OK);

    #ifndef UNICODE
    LPCSTR narrowText = "Hello, this is an ANSI character string!";
    LPCSTR narrowCaption = "MessageBox Example";
    
    // 使用 MessageBoxA 显示 ANSI 字符串消息框
    MessageBox(NULL, narrowText, narrowCaption, MB_OK);
    #endif

    return 0;
}

在上述示例中，根据是否定义了 UNICODE 宏，选择调用相应版本的 MessageBox 函数。在实际开发中，如果你使用宽字符字符串，建议使用 MessageBoxW 函数以支持 Unicode。

2、LPCWSTR宽字符字符串（Unicode）与 LPCSTR窄字符字符串（ANSI）的转换

LPCWSTR 和 LPCSTR 分别代表宽字符字符串**（Unicode）和窄字符字符串（ANSI）**。在 Windows 环境中，这两种类型的字符串使用的字符编码不同，需要谨慎处理转换。

2.1、从 LPCSTR 转换到 LPCWSTR

可以使用 MultiByteToWideChar 函数进行转换。

#include <windows.h>
#include <iostream>

int main() {
    LPCSTR narrowString = "ANSI String";
    int wideStrLen = MultiByteToWideChar(CP_ACP, 0, narrowString, -1, nullptr, 0);
    wchar_t* wideString = new wchar_t[wideStrLen];
    MultiByteToWideChar(CP_ACP, 0, narrowString, -1, wideString, wideStrLen);

    // 使用 wideString，它是 Unicode 字符串
    std::wcout << L"Converted Wide String: " << wideString << std::endl;

    delete[] wideString;

    return 0;
}

2.2、从 LPCWSTR 转换到 LPCSTR：

可以使用 WideCharToMultiByte 函数进行转换。

#include <windows.h>
#include <iostream>

int main() {
    LPCWSTR wideString = L"Unicode String";
    int narrowStrLen = WideCharToMultiByte(CP_ACP, 0, wideString, -1, nullptr, 0, nullptr, nullptr);
    char* narrowString = new char[narrowStrLen];
    WideCharToMultiByte(CP_ACP, 0, wideString, -1, narrowString, narrowStrLen, nullptr, nullptr);

    // 使用 narrowString，它是 ANSI 字符串
    std::cout << "Converted Narrow String: " << narrowString << std::endl;

    delete[] narrowString;

    return 0;
}

在上述示例中，MultiByteToWideChar 用于将窄字符字符串转换为宽字符字符串，WideCharToMultiByte 用于将宽字符字符串转换为窄字符字符串。在使用这些函数时，请确保考虑字符编码和释放动态分配的内存。

3、宽字符窄字符相互转换

在 C++ 中，宽字符（Wide Characters）和窄字符（Narrow Characters） 之间的相互转换可以使用一些函数来完成。主要的函数有
在这里插入图片描述

3.1、窄字符到宽字符的转换

mbstowcs_s: 将多字节字符串（窄字符）转换为宽字符字符串。

mbstowcs: 与 mbstowcs_s 类似，但在某些环境中可能不是线程安全的。

示例代码：

#include <iostream>
#include <cstring>

int main() {
    const char narrowStr[] = "Narrow String";
    const size_t bufferSize = 100;
    wchar_t wideStr[bufferSize];

    size_t convertedChars = 0;
    mbstowcs_s(&convertedChars, wideStr, narrowStr, _TRUNCATE);

    std::wcout << L"Wide String: " << wideStr << std::endl;

    return 0;
}

3.1.1、mbstowcs: 与 mbstowcs_s 区别

mbstowcs 和 mbstowcs_s 函数都用于将多字节字符串（char）转换为宽字符字符串（wchar_t），但它们之间有一些关键的区别，主要涉及到安全性和错误处理。**

安全性和错误处理：
- mbstowcs 函数不提供安全性检查，因此在进行转换时，需要确保目标缓冲区足够大以容纳转换后的字符串。如果目标缓冲区不足以容纳字符串，可能导致缓冲区溢出。
- mbstowcs_s 是 C11 标准引入的函数，提供了安全性检查。它接受目标缓冲区的大小作为参数，以及用于指示溢出的处理方式。如果目标缓冲区不足，mbstowcs_s 会截断字符串，避免缓冲区溢出。
函数原型：
- mbstowcs 的原型是：
- size_t mbstowcs(wchar_t *wcstr, const char *mbstr, size_t count);
- 其中 count 表示要转换的多字节字符数。
- mbstowcs_s 的原型是：
- errno_t mbstowcs_s(size_t *pReturnValue, wchar_t *wcstr, size_t sizeInWords, const char *mbstr, size_t count);
- 其中 sizeInWords 表示目标缓冲区的大小（以字为单位），pReturnValue 用于返回转换后的字符数。
返回值：
- mbstowcs 返回转换后的字符数，如果出错则返回 size_t(-1)。
- mbstowcs_s 的返回值是一个错误码 errno_t，成功返回 0，失败返回错误码。
以下是一个简单的示例，演示了如何使用 mbstowcs 和 mbstowcs_s 进行多字节到宽字符的转换：

#include <iostream>
#include <cstdlib>

int main() {
    const char* narrowString = "Hello, this is a narrow character string!";

    // 使用 mbstowcs
    size_t bufferSize = mbstowcs(nullptr, narrowString, 0);
    wchar_t* wideString = new wchar_t[bufferSize + 1];  // 加上 null 终止符的位置
    size_t convertedChars = mbstowcs(wideString, narrowString, bufferSize);

    std::wcout << L"Converted Wide String (mbstowcs): " << wideString << std::endl;

    delete[] wideString;

    // 使用 mbstowcs_s
    size_t convertedChars_s = 0;
    errno_t err = mbstowcs_s(&convertedChars_s, nullptr, 0, narrowString, 0);
    wchar_t* wideString_s = new wchar_t[convertedChars_s + 1];  // 加上 null 终止符的位置
    err = mbstowcs_s(&convertedChars_s, wideString_s, convertedChars_s + 1, narrowString, _TRUNCATE);

    std::wcout << L"Converted Wide String (mbstowcs_s): " << wideString_s << std::endl;

    delete[] wideString_s;

    return 0;
}

在这个例子中，mbstowcs 和 mbstowcs_s 都被用于将多字节字符串转换为宽字符字符串，并输出转换结果。

3.2、宽字符到窄字符的转换：

wcstombs_s: 将宽字符字符串转换为多字节字符串。

wcstombs: 与 wcstombs_s 类似，但在某些环境中可能不是线程安全的。

wcstombs_s 函数是用于将宽字符字符串（wchar_t*）转换为多字节字符串（char*）的安全版本。这个函数是 C11 标准引入的，并且在 Microsoft Visual Studio 中提供了对该函数的支持。
以下是 wcstombs_s 函数的原型：

errno_t wcstombs_s(
   size_t *pReturnValue,
   char *mbstr,
   size_t sizeInBytes,
   const wchar_t *wcstr,
   size_t count
);

其中：
- pReturnValue：指向存储转换后的字符数的变量的指针。
- mbstr：指向目标多字节字符串缓冲区的指针。
- sizeInBytes：目标缓冲区的大小（以字节为单位）。
- wcstr：指向源宽字符字符串的指针。
- count：要转换的宽字符的最大数量。
这个函数的目标是将 wcstr 中的宽字符字符串转换为多字节字符串，并将结果存储在 mbstr 中。函数会计算转换后的字符数，存储在 pReturnValue 中，以便检查缓冲区是否足够大以容纳转换后的字符串。

#include <iostream>
#include <locale>
#include <cstdlib>

int main() {
    const wchar_t* wideString = L"Hello, this is a wide character string!";
    size_t convertedChars = 0;

    // 计算需要的缓冲区大小
    size_t bufferSize = 0;
    wcstombs_s(&convertedChars, nullptr, 0, wideString, 0);
    bufferSize = convertedChars + 1; // 加上 null 终止符的位置

    // 分配缓冲区
    char* narrowString = new char[bufferSize];

    // 进行转换
    wcstombs_s(&convertedChars, narrowString, bufferSize, wideString, _TRUNCATE);

    // 输出结果
    std::cout << "Converted Narrow String: " << narrowString << std::endl;

    // 释放内存
    delete[] narrowString;

    return 0;
}

以下是一个简单的示例：