QT将char*转QString的多种方法

#include <qstring>
#include <qdebug>

// 方法1: 使用 fromutf8 (推荐)
void convertfromutf8()
{
    const char* utf8str = "hello, 世界! 这是一个utf-8字符串。";
    
    // 转换
    qstring str = qstring::fromutf8(utf8str);
    
    qdebug() << "utf-8 转换结果:" << str;
    qdebug() << "长度:" << str.length();
    qdebug() << "字节大小:" << str.toutf8().size();
}

// 方法2: 指定长度的转换
void convertwithlength()
{
    const char* data = "hello world! 1234567890";
    
    // 只转换前5个字符
    qstring str1 = qstring::fromutf8(data, 5);
    qdebug() << "前5个字符:" << str1;  // 输出: hello
    
    // 转换整个字符串
    int len = strlen(data);
    qstring str2 = qstring::fromutf8(data, len);
    qdebug() << "整个字符串:" << str2;
}

#include <qtextcodec>
#include <qlocale>

void convertfromlocal8bit()
{
    // 本地编码的字符串
    const char* localstr = "本地编码的文本";
    
    // 方法1: 使用 fromlocal8bit
    qstring str1 = qstring::fromlocal8bit(localstr);
    qdebug() << "本地编码转换:" << str1;
    
    // 方法2: 使用 qtextcodec
    qtextcodec* codec = qtextcodec::codecforlocale();
    if (codec) {
        qstring str2 = codec->tounicode(localstr);
        qdebug() << "通过qtextcodec转换:" << str2;
    }
    
    // 获取当前系统的本地编码
    qdebug() << "系统本地编码:" << qtextcodec::codecforlocale()->name();
    qdebug() << "系统区域设置:" << qlocale::system().name();
}

void convertfromlatin1()
{
    // latin-1 编码的字符串
    const char* latinstr = "hello world! @#$%";
    
    // 使用 fromlatin1
    qstring str = qstring::fromlatin1(latinstr);
    qdebug() << "latin-1 转换:" << str;
    
    // 注意: latin-1 不支持中文
    const char* chineselatin = "中文";  // 这将产生乱码
    qstring strchinese = qstring::fromlatin1(chineselatin);
    qdebug() << "latin-1 中文转换(会乱码):" << strchinese;
}

// stringconverter.h
#ifndef stringconverter_h
#define stringconverter_h

#include <qstring>
#include <qbytearray>
#include <string>

class stringconverter
{
public:
    // 1. 从 char* 转换为 qstring
    static qstring fromcharptr(const char* str, 
                               const char* encoding = "utf-8");
    
    // 2. 从 std::string 转换为 qstring
    static qstring fromstdstring(const std::string& str,
                                const char* encoding = "utf-8");
    
    // 3. 从各种编码转换
    static qstring fromencoding(const char* str, 
                               const qbytearray& encoding);
    
    // 4. 自动检测编码并转换
    static qstring autodetectandconvert(const char* str);
    
    // 5. 安全转换（处理空指针）
    static qstring safeconvert(const char* str, 
                              const qstring& defaultvalue = qstring());
    
    // 6. 带错误处理的转换
    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 {
        // 尝试常见编码
        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);
        }
        
        // 默认使用本地编码
        return qstring::fromlocal8bit(str);
    }
}

qstring stringconverter::autodetectandconvert(const char* str)
{
    if (!str) {
        return qstring();
    }
    
    int len = strlen(str);
    qbytearray data(str, len);
    
    // 检测编码
    qbytearray encoding = detectencoding(str, len);
    
    if (!encoding.isempty()) {
        return fromencoding(str, encoding);
    }
    
    // 无法检测，尝试常见编码
    // 先尝试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("转换失败: %1").arg(e.what());
        return false;
    } catch (...) {
        if (error) *error = "转换失败: 未知异常";
        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";
        }
    }
    
    // 检测编码
    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)
{
    // 简单的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字节utf-8字符
            if (i + 1 >= size) return false;
            if ((data[i+1] & 0xc0) != 0x80) return false;
            i += 2;
        } else if ((c & 0xf0) == 0xe0) {
            // 3字节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字节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)
{
    // 简化的gb2312检测
    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检测（更宽松）
    return isgb2312(data, size);  // 简化处理
}

bool stringconverter::isbig5(const char* data, int size)
{
    // 简化的big5检测
    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;
}

#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转换:" << str1;
    
    free(copied);
    
    // 示例2: 从 getenv 获取环境变量
    const char* path = getenv("path");
    if (path) {
        qstring pathstr = qstring::fromlocal8bit(path);
        qdebug() << "path环境变量:" << pathstr.left(50) << "...";
    }
    
    // 示例3: 从 sprintf 格式化
    char buffer[100];
    sprintf(buffer, "值: %d, 浮点数: %.2f", 100, 3.14159);
    qstring formatted = qstring::fromutf8(buffer);
    qdebug() << "格式化字符串:" << formatted;
}

#include <qstring>
#include <qbytearray>
#include <qdebug>

void convertnetworkdata()
{
    // 模拟从网络接收的数据
    const char* networkdata = "http/1.1 200 ok\r\n"
                              "content-type: text/html; charset=utf-8\r\n"
                              "\r\n"
                              "<html>hello, 世界!</html>";
    
    // 查找正文开始位置
    const char* bodystart = strstr(networkdata, "\r\n\r\n");
    if (bodystart) {
        bodystart += 4;  // 跳过空行
        
        // 转换为qstring
        qstring html = qstring::fromutf8(bodystart);
        qdebug() << "html内容:" << html;
    }
    
    // 处理二进制数据
    char binarydata[] = {0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x00};  // "hello\0"
    
    // 使用qbytearray作为中介
    qbytearray bytearray(binarydata, 6);
    qstring frombinary = qstring::fromutf8(bytearray);
    qdebug() << "二进制数据转换:" << frombinary;
}

#include <qstring>
#include <qfile>
#include <qtextstream>
#include <qdebug>
#include <cstdio>

void fileoperations()
{
    // 使用c标准库读取文件
    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';
        
        // 转换为qstring
        qstring content = qstring::fromutf8(buffer, filesize);
        qdebug() << "文件内容:" << content.left(100) << "...";
        
        delete[] buffer;
        fclose(file);
    }
    
    // 混合使用qt和c标准库
    qfile qtfile("data.txt");
    if (qtfile.open(qiodevice::readonly)) {
        qbytearray data = qtfile.readall();
        const char* cstr = data.constdata();
        
        // 转换
        qstring str = qstring::fromutf8(cstr);
        qdebug() << "通过qbytearray转换:" << str.length() << "个字符";
    }
}

#include <qstring>
#include <qtextcodec>
#include <qdebug>

void encodingconversions()
{
    // 定义不同编码的字符串
    const char* utf8str = "utf-8: 你好，世界！";
    const char* gbkstr = "\xce\xd2\xc3\xc7";  // "我们"的gbk编码
    
    // 创建转换器
    qtextcodec* utf8codec = qtextcodec::codecforname("utf-8");
    qtextcodec* gbkcodec = qtextcodec::codecforname("gbk");
    qtextcodec* big5codec = qtextcodec::codecforname("big5");
    
    // utf-8 转 qstring
    qstring str1 = utf8codec->tounicode(utf8str);
    qdebug() << "utf-8 -> qstring:" << str1;
    
    // gbk 转 qstring
    if (gbkcodec) {
        qstring str2 = gbkcodec->tounicode(gbkstr);
        qdebug() << "gbk -> qstring:" << str2;
        
        // qstring 转 gbk
        qbytearray gbkdata = gbkcodec->fromunicode(str2);
        qdebug() << "qstring -> gbk 字节:" << 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;
        }
    }
}

#include <qstring>
#include <qbytearray>
#include <qdebug>

void detectandconvert()
{
    // 测试不同编码的字符串
    struct testcase {
        const char* name;
        const char* data;
        int size;
    };
    
    testcase testcases[] = {
        {"utf-8中文", "中文测试", -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() << "  检测编码:" << (detected.isempty() ? "未知" : detected.constdata());
        qdebug() << "  转换结果:" << result;
    }
}

#include <qstring>
#include <qbytearray>
#include <qdebug>

class optimizedstringconverter
{
public:
    // 使用引用避免复制
    static qstring convertwithoutcopy(const qbytearray& bytearray)
    {
        return qstring::fromutf8(bytearray);
    }
    
    // 使用移动语义
    static qstring convertwithmove(qbytearray&& bytearray)
    {
        return qstring::fromutf8(std::move(bytearray));
    }
    
    // 原地转换（修改原始数据）
    static qstring convertinplace(char* data)
    {
        if (!data) return qstring();
        
        // 如果知道数据不会再用，可以避免复制
        qbytearray bytearray = qbytearray::fromrawdata(data, strlen(data));
        qstring result = qstring::fromutf8(bytearray);
        
        return result;
    }
    
    // 批量转换
    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;
    }
};

#include <qstring>
#include <qstringview>
#include <qdebug>

void useqstringview()
{
    const char* cstr = "hello, world!";
    
    // 转换为qstring
    qstring str = qstring::fromutf8(cstr);
    
    // 使用qstringview（不复制数据）
    qstringview view(str);
    
    qdebug() << "qstringview 内容:" << view.tostring();
    qdebug() << "qstringview 长度:" << view.length();
    qdebug() << "qstringview 是否为空:" << view.isempty();
    
    // 获取子视图
    qstringview subview = view.mid(0, 5);
    qdebug() << "子视图:" << subview.tostring();
}

qstring safecharptrtostring(const char* cstr)
{
    // 方法1: 使用三元运算符
    qstring str1 = cstr ? qstring::fromutf8(cstr) : qstring();
    
    // 方法2: 使用默认值
    qstring str2 = qstring::fromutf8(cstr ? cstr : "");
    
    // 方法3: 使用辅助函数
    auto safeconvert = const char* ptr -> qstring {
        if (!ptr || ptr[0] == '\0') {
            return qstring();
        }
        return qstring::fromutf8(ptr);
    };
    qstring str3 = safeconvert(cstr);
    
    return str1;
}

qstring convertwithinvalidchars(const char* cstr, int length = -1)
{
    if (!cstr) {
        return qstring();
    }
    
    if (length < 0) {
        length = strlen(cstr);
    }
    
    // 方法1: 使用qstring::fromutf8，它会处理无效utf-8序列
    qstring str1 = qstring::fromutf8(cstr, length);
    
    // 方法2: 使用qtextcodec，设置转换选项
    qtextcodec* codec = qtextcodec::codecforname("utf-8");
    if (codec) {
        qtextcodec::converterstate state;
        qstring str2 = codec->tounicode(cstr, length, &state);
        
        if (state.invalidchars > 0) {
            qwarning() << "发现" << state.invalidchars << "个无效字符";
        }
        
        return str2;
    }
    
    return str1;
}

#include <memory>

class stringmanager
{
public:
    // 使用智能指针管理内存
    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风格数组转换
    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(", ");
    }
};

// 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* 转 qstring 示例程序 ===";
    
    // 示例1: 基本转换
    qdebug() << "\n1. 基本转换示例:";
    {
        const char* teststr = "hello, 世界!";
        
        qstring utf8str = qstring::fromutf8(teststr);
        qstring localstr = qstring::fromlocal8bit(teststr);
        qstring latin1str = qstring::fromlatin1("ascii only");
        
        qdebug() << "utf-8转换:" << utf8str;
        qdebug() << "本地编码转换:" << localstr;
        qdebug() << "latin1转换:" << latin1str;
    }
    
    // 示例2: 使用转换器类
    qdebug() << "\n2. 使用stringconverter类:";
    {
        const char* multilang = "multi-language: 中文, english, 日本語";
        
        qstring result1 = stringconverter::fromcharptr(multilang, "utf-8");
        qstring result2 = stringconverter::safeconvert(multilang);
        
        qdebug() << "指定utf-8编码:" << result1;
        qdebug() << "安全转换:" << result2;
        
        // 尝试转换
        qstring result3;
        qstring error;
        if (stringconverter::tryconvert(multilang, result3, &error)) {
            qdebug() << "尝试转换成功:" << result3;
        } else {
            qdebug() << "尝试转换失败:" << error;
        }
    }
    
    // 示例3: 处理空指针和边界情况
    qdebug() << "\n3. 边界情况处理:";
    {
        const char* nullstr = nullptr;
        const char* emptystr = "";
        const char* whitespacestr = "   ";
        
        qstring nullresult = stringconverter::safeconvert(nullstr, "默认值");
        qstring emptyresult = stringconverter::safeconvert(emptystr);
        qstring whitespaceresult = qstring::fromutf8(whitespacestr);
        
        qdebug() << "空指针转换:" << nullresult;
        qdebug() << "空字符串转换:" << emptyresult << "(长度:" << emptyresult.length() << ")";
        qdebug() << "空白字符串转换:" << "'" << whitespaceresult << "'";
    }
    
    // 示例4: 性能测试
    qdebug() << "\n4. 性能比较:";
    {
        const int iterations = 100000;
        const char* testdata = "这是一个测试字符串，用于性能比较。";
        
        // 方法1: 直接转换
        qelapsedtimer timer1;
        timer1.start();
        for (int i = 0; i < iterations; ++i) {
            qstring str = qstring::fromutf8(testdata);
            q_unused(str);
        }
        qint64 time1 = timer1.nsecselapsed();
        
        // 方法2: 通过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() << "直接转换时间:" << time1 / 1000000.0 << "ms";
        qdebug() << "通过qbytearray时间:" << time2 / 1000000.0 << "ms";
        qdebug() << "性能提升:" << (time2 - time1) * 100.0 / time2 << "%";
    }
    
    // 示例5: 从命令行参数转换
    qdebug() << "\n5. 命令行参数转换:";
    for (int i = 0; i < argc; ++i) {
        qstring arg = qstring::fromlocal8bit(argv[i]);
        qdebug() << "参数" << i << ":" << arg;
    }
    
    return 0;
}