QT將char*轉(zhuǎn)QString的多種方法

更新時(shí)間：2026年01月05日 10:08:57 作者：SunkingYang

本文詳細(xì)介紹了在Qt中將char*轉(zhuǎn)換為QString的多種方法,文中通過(guò)示例代碼介紹的非常詳細(xì),對(duì)大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值,需要的朋友們下面隨著小編來(lái)一起學(xué)習(xí)學(xué)習(xí)吧

在 Qt 中，將 char* 轉(zhuǎn)換為 QString 有多種方法，主要取決于源字符串的編碼。以下是詳細(xì)的方法和示例：

1. 基本轉(zhuǎn)換方法

1.1 從 UTF-8 編碼轉(zhuǎn)換

#include <QString>
#include <QDebug>

// 方法1: 使用 fromUtf8 (推薦)
void convertFromUtf8()
{
    const char* utf8Str = "Hello, 世界! 這是一個(gè)UTF-8字符串。";
    
    // 轉(zhuǎn)換
    QString str = QString::fromUtf8(utf8Str);
    
    qDebug() << "UTF-8 轉(zhuǎn)換結(jié)果:" << str;
    qDebug() << "長(zhǎng)度:" << str.length();
    qDebug() << "字節(jié)大小:" << str.toUtf8().size();
}

// 方法2: 指定長(zhǎng)度的轉(zhuǎn)換
void convertWithLength()
{
    const char* data = "Hello World! 1234567890";
    
    // 只轉(zhuǎn)換前5個(gè)字符
    QString str1 = QString::fromUtf8(data, 5);
    qDebug() << "前5個(gè)字符:" << str1;  // 輸出: Hello
    
    // 轉(zhuǎn)換整個(gè)字符串
    int len = strlen(data);
    QString str2 = QString::fromUtf8(data, len);
    qDebug() << "整個(gè)字符串:" << str2;
}

1.2 從本地編碼轉(zhuǎn)換

#include <QTextCodec>
#include <QLocale>

void convertFromLocal8Bit()
{
    // 本地編碼的字符串
    const char* localStr = "本地編碼的文本";
    
    // 方法1: 使用 fromLocal8Bit
    QString str1 = QString::fromLocal8Bit(localStr);
    qDebug() << "本地編碼轉(zhuǎn)換:" << str1;
    
    // 方法2: 使用 QTextCodec
    QTextCodec* codec = QTextCodec::codecForLocale();
    if (codec) {
        QString str2 = codec->toUnicode(localStr);
        qDebug() << "通過(guò)QTextCodec轉(zhuǎn)換:" << str2;
    }
    
    // 獲取當(dāng)前系統(tǒng)的本地編碼
    qDebug() << "系統(tǒng)本地編碼:" << QTextCodec::codecForLocale()->name();
    qDebug() << "系統(tǒng)區(qū)域設(shè)置:" << QLocale::system().name();
}

1.3 從 Latin-1 編碼轉(zhuǎn)換

void convertFromLatin1()
{
    // Latin-1 編碼的字符串
    const char* latinStr = "Hello World! @#$%";
    
    // 使用 fromLatin1
    QString str = QString::fromLatin1(latinStr);
    qDebug() << "Latin-1 轉(zhuǎn)換:" << str;
    
    // 注意: Latin-1 不支持中文
    const char* chineseLatin = "中文";  // 這將產(chǎn)生亂碼
    QString strChinese = QString::fromLatin1(chineseLatin);
    qDebug() << "Latin-1 中文轉(zhuǎn)換(會(huì)亂碼):" << strChinese;
}

2. 完整的轉(zhuǎn)換函數(shù)集合

// StringConverter.h
#ifndef STRINGCONVERTER_H
#define STRINGCONVERTER_H

#include <QString>
#include <QByteArray>
#include <string>

class StringConverter
{
public:
    // 1. 從 char* 轉(zhuǎn)換為 QString
    static QString fromCharPtr(const char* str, 
                               const char* encoding = "UTF-8");
    
    // 2. 從 std::string 轉(zhuǎn)換為 QString
    static QString fromStdString(const std::string& str,
                                const char* encoding = "UTF-8");
    
    // 3. 從各種編碼轉(zhuǎn)換
    static QString fromEncoding(const char* str, 
                               const QByteArray& encoding);
    
    // 4. 自動(dòng)檢測(cè)編碼并轉(zhuǎn)換
    static QString autoDetectAndConvert(const char* str);
    
    // 5. 安全轉(zhuǎn)換（處理空指針）
    static QString safeConvert(const char* str, 
                              const QString& defaultValue = QString());
    
    // 6. 帶錯(cuò)誤處理的轉(zhuǎn)換
    static bool tryConvert(const char* str, 
                          QString& result,
                          QString* error = nullptr);
    
    // 7. 獲取字符串的編碼
    static QByteArray detectEncoding(const char* data, int size = -1);
    
private:
    static bool isUtf8(const char* data, int size);
    static bool isGb2312(const char* data, int size);
    static bool isGbk(const char* data, int size);
    static bool isBig5(const char* data, int size);
};

#endif // STRINGCONVERTER_H

// StringConverter.cpp
#include "StringConverter.h"
#include <QTextCodec>
#include <QDebug>
#include <cstring>

QString StringConverter::fromCharPtr(const char* str, const char* encoding)
{
    if (!str) {
        return QString();
    }
    
    QByteArray encodingName(encoding);
    
    if (encodingName.isEmpty() || encodingName == "UTF-8") {
        return QString::fromUtf8(str);
    } 
    else if (encodingName == "Local8Bit") {
        return QString::fromLocal8Bit(str);
    }
    else if (encodingName == "Latin1") {
        return QString::fromLatin1(str);
    }
    else {
        QTextCodec* codec = QTextCodec::codecForName(encoding);
        if (codec) {
            return codec->toUnicode(str);
        } else {
            // 回退到UTF-8
            return QString::fromUtf8(str);
        }
    }
}

QString StringConverter::fromStdString(const std::string& str, const char* encoding)
{
    return fromCharPtr(str.c_str(), encoding);
}

QString StringConverter::fromEncoding(const char* str, const QByteArray& encoding)
{
    if (!str) {
        return QString();
    }
    
    QTextCodec* codec = QTextCodec::codecForName(encoding);
    if (codec) {
        return codec->toUnicode(str);
    } else {
        // 嘗試常見(jiàn)編碼
        if (encoding.contains("UTF-8") || encoding.contains("utf-8")) {
            return QString::fromUtf8(str);
        } else if (encoding.contains("GB") || encoding.contains("gb")) {
            // 嘗試GB2312、GBK、GB18030
            QTextCodec* gbCodec = QTextCodec::codecForName("GB18030");
            if (gbCodec) return gbCodec->toUnicode(str);
        } else if (encoding.contains("Big5") || encoding.contains("big5")) {
            QTextCodec* big5Codec = QTextCodec::codecForName("Big5");
            if (big5Codec) return big5Codec->toUnicode(str);
        }
        
        // 默認(rèn)使用本地編碼
        return QString::fromLocal8Bit(str);
    }
}

QString StringConverter::autoDetectAndConvert(const char* str)
{
    if (!str) {
        return QString();
    }
    
    int len = strlen(str);
    QByteArray data(str, len);
    
    // 檢測(cè)編碼
    QByteArray encoding = detectEncoding(str, len);
    
    if (!encoding.isEmpty()) {
        return fromEncoding(str, encoding);
    }
    
    // 無(wú)法檢測(cè)，嘗試常見(jiàn)編碼
    // 先嘗試UTF-8
    if (isUtf8(str, len)) {
        return QString::fromUtf8(str);
    }
    
    // 嘗試本地編碼
    return QString::fromLocal8Bit(str);
}

QString StringConverter::safeConvert(const char* str, const QString& defaultValue)
{
    if (!str) {
        return defaultValue;
    }
    
    try {
        return QString::fromUtf8(str);
    } catch (...) {
        return defaultValue;
    }
}

bool StringConverter::tryConvert(const char* str, QString& result, QString* error)
{
    if (!str) {
        if (error) *error = "輸入字符串為空指針";
        return false;
    }
    
    try {
        result = QString::fromUtf8(str);
        return true;
    } catch (const std::exception& e) {
        if (error) *error = QString("轉(zhuǎn)換失敗: %1").arg(e.what());
        return false;
    } catch (...) {
        if (error) *error = "轉(zhuǎn)換失敗: 未知異常";
        return false;
    }
}

QByteArray StringConverter::detectEncoding(const char* data, int size)
{
    if (!data || size == 0) {
        return QByteArray();
    }
    
    if (size < 0) {
        size = strlen(data);
    }
    
    // 檢查BOM
    if (size >= 3) {
        unsigned char bom[3];
        memcpy(bom, data, 3);
        
        // UTF-8 BOM: EF BB BF
        if (bom[0] == 0xEF && bom[1] == 0xBB && bom[2] == 0xBF) {
            return "UTF-8";
        }
        // UTF-16 LE BOM: FF FE
        if (bom[0] == 0xFF && bom[1] == 0xFE) {
            return "UTF-16LE";
        }
        // UTF-16 BE BOM: FE FF
        if (bom[0] == 0xFE && bom[1] == 0xFF) {
            return "UTF-16BE";
        }
    }
    
    // 檢測(cè)編碼
    if (isUtf8(data, size)) {
        return "UTF-8";
    } else if (isGb2312(data, size)) {
        return "GB2312";
    } else if (isGbk(data, size)) {
        return "GBK";
    } else if (isBig5(data, size)) {
        return "Big5";
    }
    
    return QByteArray();
}

bool StringConverter::isUtf8(const char* data, int size)
{
    // 簡(jiǎn)單的UTF-8有效性檢查
    int i = 0;
    while (i < size) {
        unsigned char c = static_cast<unsigned char>(data[i]);
        
        if (c <= 0x7F) {
            i++;
        } else if ((c & 0xE0) == 0xC0) {
            // 2字節(jié)UTF-8字符
            if (i + 1 >= size) return false;
            if ((data[i+1] & 0xC0) != 0x80) return false;
            i += 2;
        } else if ((c & 0xF0) == 0xE0) {
            // 3字節(jié)UTF-8字符
            if (i + 2 >= size) return false;
            if ((data[i+1] & 0xC0) != 0x80) return false;
            if ((data[i+2] & 0xC0) != 0x80) return false;
            i += 3;
        } else if ((c & 0xF8) == 0xF0) {
            // 4字節(jié)UTF-8字符
            if (i + 3 >= size) return false;
            if ((data[i+1] & 0xC0) != 0x80) return false;
            if ((data[i+2] & 0xC0) != 0x80) return false;
            if ((data[i+3] & 0xC0) != 0x80) return false;
            i += 4;
        } else {
            return false;
        }
    }
    
    return true;
}

bool StringConverter::isGb2312(const char* data, int size)
{
    // 簡(jiǎn)化的GB2312檢測(cè)
    for (int i = 0; i < size; i++) {
        unsigned char c = static_cast<unsigned char>(data[i]);
        if (c >= 0xA1 && c <= 0xFE) {
            if (i + 1 < size) {
                unsigned char c2 = static_cast<unsigned char>(data[i+1]);
                if (c2 >= 0xA1 && c2 <= 0xFE) {
                    return true;  // 找到可能的GB2312字符
                }
            }
        }
    }
    return false;
}

bool StringConverter::isGbk(const char* data, int size)
{
    // GBK檢測(cè)（更寬松）
    return isGb2312(data, size);  // 簡(jiǎn)化處理
}

bool StringConverter::isBig5(const char* data, int size)
{
    // 簡(jiǎn)化的Big5檢測(cè)
    for (int i = 0; i < size; i++) {
        unsigned char c = static_cast<unsigned char>(data[i]);
        if (c >= 0xA1 && c <= 0xFE) {
            if (i + 1 < size) {
                unsigned char c2 = static_cast<unsigned char>(data[i+1]);
                if ((c2 >= 0x40 && c2 <= 0x7E) || 
                    (c2 >= 0xA1 && c2 <= 0xFE)) {
                    return true;  // 找到可能的Big5字符
                }
            }
        }
    }
    return false;
}

3. 實(shí)際應(yīng)用示例

3.1 從 C 庫(kù)函數(shù)獲取字符串

#include <QString>
#include <QDebug>
#include <cstring>
#include <cstdlib>

void convertFromCLibrary()
{
    // 示例1: 從 strdup 獲取
    const char* original = "Hello from C string";
    char* copied = strdup(original);
    
    QString str1 = QString::fromUtf8(copied);
    qDebug() << "從strdup轉(zhuǎn)換:" << str1;
    
    free(copied);
    
    // 示例2: 從 getenv 獲取環(huán)境變量
    const char* path = getenv("PATH");
    if (path) {
        QString pathStr = QString::fromLocal8Bit(path);
        qDebug() << "PATH環(huán)境變量:" << pathStr.left(50) << "...";
    }
    
    // 示例3: 從 sprintf 格式化
    char buffer[100];
    sprintf(buffer, "值: %d, 浮點(diǎn)數(shù): %.2f", 100, 3.14159);
    QString formatted = QString::fromUtf8(buffer);
    qDebug() << "格式化字符串:" << formatted;
}

3.2 處理網(wǎng)絡(luò)數(shù)據(jù)

#include <QString>
#include <QByteArray>
#include <QDebug>

void convertNetworkData()
{
    // 模擬從網(wǎng)絡(luò)接收的數(shù)據(jù)
    const char* networkData = "HTTP/1.1 200 OK\r\n"
                              "Content-Type: text/html; charset=utf-8\r\n"
                              "\r\n"
                              "<html>Hello, 世界!</html>";
    
    // 查找正文開(kāi)始位置
    const char* bodyStart = strstr(networkData, "\r\n\r\n");
    if (bodyStart) {
        bodyStart += 4;  // 跳過(guò)空行
        
        // 轉(zhuǎn)換為QString
        QString html = QString::fromUtf8(bodyStart);
        qDebug() << "HTML內(nèi)容:" << html;
    }
    
    // 處理二進(jìn)制數(shù)據(jù)
    char binaryData[] = {0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x00};  // "Hello\0"
    
    // 使用QByteArray作為中介
    QByteArray byteArray(binaryData, 6);
    QString fromBinary = QString::fromUtf8(byteArray);
    qDebug() << "二進(jìn)制數(shù)據(jù)轉(zhuǎn)換:" << fromBinary;
}

3.3 文件操作

#include <QString>
#include <QFile>
#include <QTextStream>
#include <QDebug>
#include <cstdio>

void fileOperations()
{
    // 使用C標(biāo)準(zhǔn)庫(kù)讀取文件
    FILE* file = fopen("test.txt", "rb");
    if (file) {
        fseek(file, 0, SEEK_END);
        long fileSize = ftell(file);
        fseek(file, 0, SEEK_SET);
        
        char* buffer = new char[fileSize + 1];
        fread(buffer, 1, fileSize, file);
        buffer[fileSize] = '\0';
        
        // 轉(zhuǎn)換為QString
        QString content = QString::fromUtf8(buffer, fileSize);
        qDebug() << "文件內(nèi)容:" << content.left(100) << "...";
        
        delete[] buffer;
        fclose(file);
    }
    
    // 混合使用Qt和C標(biāo)準(zhǔn)庫(kù)
    QFile qtFile("data.txt");
    if (qtFile.open(QIODevice::ReadOnly)) {
        QByteArray data = qtFile.readAll();
        const char* cstr = data.constData();
        
        // 轉(zhuǎn)換
        QString str = QString::fromUtf8(cstr);
        qDebug() << "通過(guò)QByteArray轉(zhuǎn)換:" << str.length() << "個(gè)字符";
    }
}

4. 編碼轉(zhuǎn)換示例

4.1 不同編碼之間的轉(zhuǎn)換

#include <QString>
#include <QTextCodec>
#include <QDebug>

void encodingConversions()
{
    // 定義不同編碼的字符串
    const char* utf8Str = "UTF-8: 你好，世界！";
    const char* gbkStr = "\xCE\xD2\xC3\xC7";  // "我們"的GBK編碼
    
    // 創(chuàng)建轉(zhuǎn)換器
    QTextCodec* utf8Codec = QTextCodec::codecForName("UTF-8");
    QTextCodec* gbkCodec = QTextCodec::codecForName("GBK");
    QTextCodec* big5Codec = QTextCodec::codecForName("Big5");
    
    // UTF-8 轉(zhuǎn) QString
    QString str1 = utf8Codec->toUnicode(utf8Str);
    qDebug() << "UTF-8 -> QString:" << str1;
    
    // GBK 轉(zhuǎn) QString
    if (gbkCodec) {
        QString str2 = gbkCodec->toUnicode(gbkStr);
        qDebug() << "GBK -> QString:" << str2;
        
        // QString 轉(zhuǎn) GBK
        QByteArray gbkData = gbkCodec->fromUnicode(str2);
        qDebug() << "QString -> GBK 字節(jié):" << gbkData.toHex();
    }
    
    // 列出所有可用的編解碼器
    qDebug() << "\n可用的文本編解碼器:";
    QList<QByteArray> codecs = QTextCodec::availableCodecs();
    for (const QByteArray& codec : codecs) {
        if (codec.contains("UTF") || codec.contains("GB") || codec.contains("Big5")) {
            qDebug() << "  " << codec;
        }
    }
}

4.2 編碼檢測(cè)和轉(zhuǎn)換

#include <QString>
#include <QByteArray>
#include <QDebug>

void detectAndConvert()
{
    // 測(cè)試不同編碼的字符串
    struct TestCase {
        const char* name;
        const char* data;
        int size;
    };
    
    TestCase testCases[] = {
        {"UTF-8中文", "中文測(cè)試", -1},
        {"GBK中文", "\xD6\xD0\xCE\xC4", 4},  // "中文"的GBK編碼
        {"純英文", "Hello World!", -1},
        {"混合", "Hello 世界!", -1},
    };
    
    for (const auto& test : testCases) {
        int size = test.size;
        if (size < 0) {
            size = strlen(test.data);
        }
        
        QByteArray detected = StringConverter::detectEncoding(test.data, size);
        
        QString result;
        if (!detected.isEmpty()) {
            result = StringConverter::fromEncoding(test.data, detected);
        } else {
            result = QString::fromUtf8(test.data, size);
        }
        
        qDebug() << test.name << ":";
        qDebug() << "  檢測(cè)編碼:" << (detected.isEmpty() ? "未知" : detected.constData());
        qDebug() << "  轉(zhuǎn)換結(jié)果:" << result;
    }
}

5. 性能優(yōu)化

5.1 避免不必要的復(fù)制

#include <QString>
#include <QByteArray>
#include <QDebug>

class OptimizedStringConverter
{
public:
    // 使用引用避免復(fù)制
    static QString convertWithoutCopy(const QByteArray& byteArray)
    {
        return QString::fromUtf8(byteArray);
    }
    
    // 使用移動(dòng)語(yǔ)義
    static QString convertWithMove(QByteArray&& byteArray)
    {
        return QString::fromUtf8(std::move(byteArray));
    }
    
    // 原地轉(zhuǎn)換（修改原始數(shù)據(jù)）
    static QString convertInPlace(char* data)
    {
        if (!data) return QString();
        
        // 如果知道數(shù)據(jù)不會(huì)再用，可以避免復(fù)制
        QByteArray byteArray = QByteArray::fromRawData(data, strlen(data));
        QString result = QString::fromUtf8(byteArray);
        
        return result;
    }
    
    // 批量轉(zhuǎn)換
    static QList<QString> batchConvert(const QList<QByteArray>& byteArrays)
    {
        QList<QString> result;
        result.reserve(byteArrays.size());
        
        for (const QByteArray& ba : byteArrays) {
            result.append(QString::fromUtf8(ba));
        }
        
        return result;
    }
};

5.2 使用 QStringView 避免內(nèi)存分配

#include <QString>
#include <QStringView>
#include <QDebug>

void useQStringView()
{
    const char* cstr = "Hello, World!";
    
    // 轉(zhuǎn)換為QString
    QString str = QString::fromUtf8(cstr);
    
    // 使用QStringView（不復(fù)制數(shù)據(jù)）
    QStringView view(str);
    
    qDebug() << "QStringView 內(nèi)容:" << view.toString();
    qDebug() << "QStringView 長(zhǎng)度:" << view.length();
    qDebug() << "QStringView 是否為空:" << view.isEmpty();
    
    // 獲取子視圖
    QStringView subView = view.mid(0, 5);
    qDebug() << "子視圖:" << subView.toString();
}

6. 常見(jiàn)問(wèn)題解決方案

6.1 處理空指針

QString safeCharPtrToString(const char* cstr)
{
    // 方法1: 使用三元運(yùn)算符
    QString str1 = cstr ? QString::fromUtf8(cstr) : QString();
    
    // 方法2: 使用默認(rèn)值
    QString str2 = QString::fromUtf8(cstr ? cstr : "");
    
    // 方法3: 使用輔助函數(shù)
    auto safeConvert = const char* ptr -> QString {
        if (!ptr || ptr[0] == '\0') {
            return QString();
        }
        return QString::fromUtf8(ptr);
    };
    QString str3 = safeConvert(cstr);
    
    return str1;
}

6.2 處理無(wú)效字符

QString convertWithInvalidChars(const char* cstr, int length = -1)
{
    if (!cstr) {
        return QString();
    }
    
    if (length < 0) {
        length = strlen(cstr);
    }
    
    // 方法1: 使用QString::fromUtf8，它會(huì)處理無(wú)效UTF-8序列
    QString str1 = QString::fromUtf8(cstr, length);
    
    // 方法2: 使用QTextCodec，設(shè)置轉(zhuǎn)換選項(xiàng)
    QTextCodec* codec = QTextCodec::codecForName("UTF-8");
    if (codec) {
        QTextCodec::ConverterState state;
        QString str2 = codec->toUnicode(cstr, length, &state);
        
        if (state.invalidChars > 0) {
            qWarning() << "發(fā)現(xiàn)" << state.invalidChars << "個(gè)無(wú)效字符";
        }
        
        return str2;
    }
    
    return str1;
}

6.3 內(nèi)存管理

#include <memory>

class StringManager
{
public:
    // 使用智能指針管理內(nèi)存
    static QString convertSmartPtr(const std::unique_ptr<char[]>& data)
    {
        if (!data) {
            return QString();
        }
        return QString::fromUtf8(data.get());
    }
    
    static QString convertSharedPtr(const std::shared_ptr<char>& data)
    {
        if (!data) {
            return QString();
        }
        return QString::fromUtf8(data.get());
    }
    
    // 從C風(fēng)格數(shù)組轉(zhuǎn)換
    static QString fromCArray(const char* array[], int count)
    {
        QStringList list;
        for (int i = 0; i < count; ++i) {
            if (array[i]) {
                list.append(QString::fromUtf8(array[i]));
            }
        }
        return list.join(", ");
    }
};

7. 完整的示例程序

// main.cpp
#include <QCoreApplication>
#include <QDebug>
#include "StringConverter.h"
#include <vector>
#include <memory>

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    
    qDebug() << "=== char* 轉(zhuǎn) QString 示例程序 ===";
    
    // 示例1: 基本轉(zhuǎn)換
    qDebug() << "\n1. 基本轉(zhuǎn)換示例:";
    {
        const char* testStr = "Hello, 世界!";
        
        QString utf8Str = QString::fromUtf8(testStr);
        QString localStr = QString::fromLocal8Bit(testStr);
        QString latin1Str = QString::fromLatin1("ASCII only");
        
        qDebug() << "UTF-8轉(zhuǎn)換:" << utf8Str;
        qDebug() << "本地編碼轉(zhuǎn)換:" << localStr;
        qDebug() << "Latin1轉(zhuǎn)換:" << latin1Str;
    }
    
    // 示例2: 使用轉(zhuǎn)換器類
    qDebug() << "\n2. 使用StringConverter類:";
    {
        const char* multiLang = "Multi-language: 中文, English, 日本語(yǔ)";
        
        QString result1 = StringConverter::fromCharPtr(multiLang, "UTF-8");
        QString result2 = StringConverter::safeConvert(multiLang);
        
        qDebug() << "指定UTF-8編碼:" << result1;
        qDebug() << "安全轉(zhuǎn)換:" << result2;
        
        // 嘗試轉(zhuǎn)換
        QString result3;
        QString error;
        if (StringConverter::tryConvert(multiLang, result3, &error)) {
            qDebug() << "嘗試轉(zhuǎn)換成功:" << result3;
        } else {
            qDebug() << "嘗試轉(zhuǎn)換失敗:" << error;
        }
    }
    
    // 示例3: 處理空指針和邊界情況
    qDebug() << "\n3. 邊界情況處理:";
    {
        const char* nullStr = nullptr;
        const char* emptyStr = "";
        const char* whitespaceStr = "   ";
        
        QString nullResult = StringConverter::safeConvert(nullStr, "默認(rèn)值");
        QString emptyResult = StringConverter::safeConvert(emptyStr);
        QString whitespaceResult = QString::fromUtf8(whitespaceStr);
        
        qDebug() << "空指針轉(zhuǎn)換:" << nullResult;
        qDebug() << "空字符串轉(zhuǎn)換:" << emptyResult << "(長(zhǎng)度:" << emptyResult.length() << ")";
        qDebug() << "空白字符串轉(zhuǎn)換:" << "'" << whitespaceResult << "'";
    }
    
    // 示例4: 性能測(cè)試
    qDebug() << "\n4. 性能比較:";
    {
        const int iterations = 100000;
        const char* testData = "這是一個(gè)測(cè)試字符串，用于性能比較。";
        
        // 方法1: 直接轉(zhuǎn)換
        QElapsedTimer timer1;
        timer1.start();
        for (int i = 0; i < iterations; ++i) {
            QString str = QString::fromUtf8(testData);
            Q_UNUSED(str);
        }
        qint64 time1 = timer1.nsecsElapsed();
        
        // 方法2: 通過(guò)QByteArray
        QElapsedTimer timer2;
        timer2.start();
        for (int i = 0; i < iterations; ++i) {
            QByteArray ba(testData);
            QString str = QString::fromUtf8(ba);
            Q_UNUSED(str);
        }
        qint64 time2 = timer2.nsecsElapsed();
        
        qDebug() << "直接轉(zhuǎn)換時(shí)間:" << time1 / 1000000.0 << "ms";
        qDebug() << "通過(guò)QByteArray時(shí)間:" << time2 / 1000000.0 << "ms";
        qDebug() << "性能提升:" << (time2 - time1) * 100.0 / time2 << "%";
    }
    
    // 示例5: 從命令行參數(shù)轉(zhuǎn)換
    qDebug() << "\n5. 命令行參數(shù)轉(zhuǎn)換:";
    for (int i = 0; i < argc; ++i) {
        QString arg = QString::fromLocal8Bit(argv[i]);
        qDebug() << "參數(shù)" << i << ":" << arg;
    }
    
    return 0;
}

8. 重要注意事項(xiàng)

編碼問(wèn)題：
- 明確知道源字符串的編碼
- 使用正確的轉(zhuǎn)換函數(shù)
- 處理編碼轉(zhuǎn)換失敗的情況
內(nèi)存管理：
- 確保源字符串在轉(zhuǎn)換期間有效
- 處理空指針
- 避免內(nèi)存泄漏
性能考慮：
- 避免不必要的轉(zhuǎn)換
- 對(duì)于大量數(shù)據(jù)，考慮批量處理
- 使用移動(dòng)語(yǔ)義避免復(fù)制
國(guó)際化：
- 在可能的情況下使用UTF-8
- 正確處理多語(yǔ)言文本
- 考慮區(qū)域設(shè)置
錯(cuò)誤處理：
- 檢查轉(zhuǎn)換結(jié)果
- 處理無(wú)效字符
- 提供有意義的錯(cuò)誤信息