Qt写一个简易的ini文件读写类

一时失言乱红尘 2023-01-17 09:22 159阅读 0赞

.ini 文件是 Initialization File 的缩写，即初始化文件。Qt 提供的 QSettings 类可用于 ini 配置文件的读写，但还存在一些问题，比如：保存时会把已有的注释清掉，中文的分组和键编码有问题，字段长度限制，缓存问题等等。自己写一个ini读写类只是方便以后遇到问题用来替换。

ini 格式是非常简单的，一般只有分组和键值对：

[section]  #分组/节 
    ;注释      #注释/注解
    key=value  #键值对用等号连起来
    key2=123
    
    [section2]
    key=true

先看看 QSettings 对 ini 的基本读写：

{//写入
            QSettings setting(path,QSettings::IniFormat);
            setting.setIniCodec("utf-8");
            qDebug()<<"write"<<path;
            setting.setValue("BB/AA","测试");
            setting.setValue("BB/BB",true);
            setting.setValue("BB/CC",123.7);
            //保存ini会把中文写成unicode："%U4E2D%U6587"
            //但是读取ini时，手动输入的中文是不能正常读取的，
            //且保存ini的时候会修改掉手写中文的格式，如中文变成"%E4%B8%AD%E6%96%87"
            setting.setValue("中文/中文","测试中文");
        }
        {//读取
            QSettings setting(path,QSettings::IniFormat);
            setting.setIniCodec("utf-8");
            qDebug()<<"read"<<path;
            qDebug()<<setting.value("BB/AA");
            qDebug()<<setting.value("BB/BB");
            qDebug()<<setting.value("BB/CC");
            qDebug()<<setting.value("中文/中文");
            qDebug()<<setting.value("None/AA");
        }

实现思路：逐行读取并解析，遇到（;）开头则判断为注释；遇到（\[ \]）包起来的则判定为分组；遇到可以（=）split 分为两部分的则为有效的键值对。 遇到分组先设置当前分组，后面读取到的键值对都归入该分组内，最后生成的是一个树结构。对于值类型的处理参照 QSettings，在读取时都判定为字符串，只在修改时才存储为对应类型的 QVariant 值，在保存的时候再把 Qvariant 转为字符串。保存时遍历树结构逐行写入。

github 链接：[https://github.com/gongjianbo/MyTestCode2021/tree/master/Qt/TestQt\_20210425\_ini][https_github.com_gongjianbo_MyTestCode2021_tree_master_Qt_TestQt_20210425_ini]

实现代码：

#pragma once
    
    #include <QObject>
    #include <QVariant>
    #include <QList>
    
    namespace Tool {
    
    /**
     * @brief 简易的ini读写类
     * @author 龚建波
     * @date 2021-04-25
     * @details
     * 用于替代QSettings读写ini文件
     * 因为QSettings不支持中文key/groups/;注释等
     * 不支持并发操作
     * 无缓存
     * 无异常处理
     * @note
     * 测试编码为utf-8
     */
    class EasyIni : public QObject
    {
        Q_OBJECT
    public:
        //操作模式
        enum Mode
        {
            ReadOnly,
            WriteOnly,
            ReadWrite
        };
    public:
        explicit EasyIni(const QString &filepath,
                         EasyIni::Mode mode = EasyIni::ReadWrite,
                         QObject *parent = nullptr);
        ~EasyIni();
    
        //打印ini信息
        void dumpInfo() const;
        //分组列表
        QStringList groups() const;
        //分组内所有key
        QStringList keys(const QString &group) const;
        //获取值
        QVariant value(const QString &group, const QString &key) const;
        //设置值，group或key不存在则创建
        void setValue(const QString &group, const QString &key, const QVariant &value);
        //保存
        void save();
        //加载
        void load(const QString &filepath = QString());
    
    private:
        //判断当前路径是否可写
        bool isWritable() const;
        //解析ini文件
        void parse(const QString &filepath);
        //variant转str copy from qsettings
        static QString variantToString(const QVariant &v);
        //str转variant copy from qsettings
        static QVariant stringToVariant(const QString &s);
        //stringToVariant中用到的分割 copy from qsettings
        static QStringList splitArgs(const QString &s, int idx);
    
    private:
        //ini文件路径
        QString inipath;
        //操作模式
        EasyIni::Mode iniMode = EasyIni::ReadWrite;
    
        //【】数据结构
        //一行的数据
        struct IniRow{
            //是否有效，无效则仅保存在写入时恢复原格式
            bool isValid = false;
            //行key
            QString key;
            //行value
            QVariant value;
        };
        //一个分组的数据
        struct IniGroup{
            //是否为默认初始分组
            bool isHead = false;
            //分组名
            QString group;
            //分组行列表
            QList<IniRow> rows;
            //group key列表
            //无效行为空
            QList<QString> allkeys;
        };
        //ini分组列表
        struct IniData{
            //标记数据改变了，在析构时写入文件
            //或者主动写入文件
            bool change = false;
            //分组数据
            QList<IniGroup> datas;
            //group name列表
            //head和无效为空
            QList<QString> allgroups;
        };
    
        //ini数据
        IniData iniData;
    };
    
    }

#include "EasyIni.h"
    #include <QTextStream>
    #include <QDataStream>
    #include <QTemporaryFile>
    #include <QFileInfo>
    #include <QFile>
    #include <QDir>
    #include <QRect>
    #include <QSize>
    #include <QDebug>
    
    using namespace Tool;
    
    EasyIni::EasyIni(const QString &filepath, EasyIni::Mode mode, QObject *parent)
        : QObject(parent), inipath(filepath), iniMode(mode)
    {
        load();
    }
    
    EasyIni::~EasyIni()
    {
        save();
    }
    
    void EasyIni::dumpInfo() const
    {
        qDebug()<<"[dump ini info]";
        for(auto agroup:iniData.datas)
        {
            if(!agroup.isHead)
                qDebug()<<"[group]"<<agroup.group;
            for(auto arow:agroup.rows)
            {
                if(arow.isValid){
                    qDebug()<<"\t[key]"<<arow.key<<"[value]"<<arow.value;
                }else{
                    qDebug()<<"\t[unknown]"<<arow.key;
                }
            }
        }
        //qDebug()<<iniData.allgroups;
    }
    
    QStringList EasyIni::groups() const
    {
        auto result = iniData.allgroups;
        result.removeAll(QString());
        return result;
    }
    
    QStringList EasyIni::keys(const QString &group) const
    {
        QStringList key_list;
        int group_index = iniData.allgroups.indexOf(group);
        if(group.isEmpty()||group_index<0)
            return key_list;
        auto result = iniData.datas.at(group_index).allkeys;
        result.removeAll(QString());
        return result;
    }
    
    QVariant EasyIni::value(const QString &group, const QString &key) const
    {
        int group_index = iniData.allgroups.indexOf(group);
        if(group.isEmpty()||key.isEmpty()||group_index<0)
            return QVariant();
    
        int key_index = iniData.datas.at(group_index).allkeys.indexOf(key);
        if(key_index<0)
            return QVariant();
    
        return iniData.datas.at(group_index).rows.at(key_index).value;
    }
    
    void EasyIni::setValue(const QString &group, const QString &key, const QVariant &value)
    {
        if(group.isEmpty()||key.isEmpty())
            return;
        //如果是不存在的分组则创建
        int group_index = iniData.allgroups.indexOf(group);
        if(group_index<0){
            IniGroup ini_group;
            ini_group.isHead = false;
            ini_group.group = group;
            iniData.datas.push_back(ini_group);
            iniData.allgroups.push_back(group);
            group_index = iniData.allgroups.count()-1;
        }
        //如果不存在key则创建
        int key_index = iniData.datas.at(group_index).allkeys.indexOf(key);
        if(key_index<0){
            IniRow ini_row;
            ini_row.isValid = true;
            ini_row.key = key;
            //ini_row.value = value;
            iniData.datas[group_index].rows.push_back(ini_row);
            iniData.datas[group_index].allkeys.push_back(key);
            key_index = iniData.datas.at(group_index).allkeys.count()-1;
        }
        //插入这里有点疑问，就是
        iniData.datas[group_index].rows[key_index].value = value;
        //标记为已修改状态，在save时判断
        iniData.change = true;
    }
    
    void EasyIni::save()
    {
        //只读
        if(EasyIni::ReadOnly == iniMode)
            return;
    
        if(iniData.change && isWritable()){
            qDebug()<<"save ini"<<inipath;
            QFile file(inipath);
            //QIODevice::Text on windows endl=\r\n
            if(file.open(QIODevice::WriteOnly|QIODevice::Truncate|QIODevice::Text))
            {
                QTextStream t_s(&file);
                t_s.setCodec("utf-8");
                for(auto agroup:iniData.datas)
                {
                    if(!agroup.isHead){
                        t_s<<'['<<agroup.group<<']'<<endl;
                    }
    
                    for(auto arow:agroup.rows)
                    {
                        if(arow.isValid){
                            t_s<<arow.key<<'='<<variantToString(arow.value)<<endl;
                        }else{
                            t_s<<arow.key<<endl;
                        }
                    }
                }
                file.close();
            }
        }
    }
    
    void EasyIni::load(const QString &filepath)
    {
        //保存当前的
        save();
    
        iniData = IniData{ };
        const QString path = filepath.isEmpty()?inipath:filepath;
        inipath = path;
    
        QFile file(path);
        if((EasyIni::WriteOnly == iniMode) ||
                !file.exists() ||
                !file.open(QIODevice::ReadOnly|QIODevice::Text)){
            return;
        }
    
        qDebug()<<"load ini"<<inipath;
    
        IniData ini_data;
        IniGroup ini_group;
        IniRow ini_row;
        QTextStream t_s(&file);
        t_s.setCodec("utf-8");
        //qDebug()<<"all"<<t_s.readAll();
    
        //默认分组
        ini_group.isHead=true;
        while(!t_s.atEnd()){
            //去掉首尾空格
            QString line_data=t_s.readLine().trimmed();
            //qDebug()<<"-- line:"<<line_data<<line_data.length();
    
            if(line_data.count()<3||
                    line_data[0]==';'||
                    line_data[0]=='#'){
                //长度小于三无效: a=0 or [a] 注释暂不考虑
                ini_row.isValid=false;
                ini_row.key=line_data;
                ini_row.value.clear();
    
                ini_group.rows.push_back(ini_row);
                ini_group.allkeys.push_back(QString());
                //qDebug()<<"invalid"<<line_data;
            }else if(line_data[0]=='['&&
                     line_data[line_data.length()-1]==']'){
                //分组
                ini_data.datas.push_back(ini_group);
                ini_data.allgroups.push_back(ini_group.group);
    
                ini_group.isHead=false;
                ini_group.group=line_data.mid(1,line_data.count()-2);
    
                ini_group.rows.clear();
                ini_group.allkeys.clear();
                //qDebug()<<"group"<<ini_group.group;
            }else{
                ini_row.isValid=false;
                int split_index=line_data.indexOf('=');
                if(split_index>0&&split_index<line_data.length()-1){
                    QString key=line_data.mid(0,split_index).trimmed();
                    QString value=line_data.mid(split_index+1,line_data.length()-split_index-1).trimmed();
                    if(!key.isEmpty()&&!value.isEmpty()){
                        ini_row.isValid=true;
                        ini_row.key=key;
                        ini_row.value=stringToVariant(value);
    
                        ini_group.rows.push_back(ini_row);
                        ini_group.allkeys.push_back(key);
                        //qDebug()<<"key-value"<<key<<value;
                    }
                }
                if(!ini_row.isValid){
                    ini_row.key=line_data;
                    ini_row.value.clear();
    
                    ini_group.rows.push_back(ini_row);
                    ini_group.allkeys.push_back(QString());
                    //qDebug()<<"invalid"<<line_data;
                }
            }
        }
        file.close();
    
        //最后一个分组的数据
        if(ini_group.isHead||(ini_data.allgroups.count()>0&&ini_group.isHead!=true)){
            ini_data.datas.push_back(ini_group);
            ini_data.allgroups.push_back(ini_group.group);
        }
    
        iniData = ini_data;
    }
    
    bool EasyIni::isWritable() const
    {
        bool result=false;
        QFileInfo fileinfo(inipath);
        if(fileinfo.exists()){
            QFile file(inipath);
            result=file.open(QFile::ReadWrite);
            file.close();
        }else{
            QDir dir(fileinfo.absolutePath());
            if(dir.exists()||dir.mkpath(dir.absolutePath())){
                //临时文件
                QTemporaryFile file(inipath);
                result=file.open();
                file.close();
            }
        }
        return result;
    }
    
    QString EasyIni::variantToString(const QVariant &v)
    {
        QString result;
    
        switch (v.type()) {
        case QVariant::Invalid:
            result = QLatin1String("@Invalid()");
            break;
    
        case QVariant::ByteArray: {
            QByteArray a = v.toByteArray();
            result = QLatin1String("@ByteArray(")
                    + QLatin1String(a.constData(), a.size())
                    + QLatin1Char(')');
            break;
        }
    
        case QVariant::String:
        case QVariant::LongLong:
        case QVariant::ULongLong:
        case QVariant::Int:
        case QVariant::UInt:
        case QVariant::Bool:
        case QVariant::Double:
        case QVariant::KeySequence: {
            result = v.toString();
            if (result.contains(QChar::Null))
                result = QLatin1String("@String(") + result + QLatin1Char(')');
            else if (result.startsWith(QLatin1Char('@')))
                result.prepend(QLatin1Char('@'));
            break;
        }
    #ifndef QT_NO_GEOM_VARIANT
        case QVariant::Rect: {
            QRect r = qvariant_cast<QRect>(v);
            result = QString::asprintf("@Rect(%d %d %d %d)", r.x(), r.y(), r.width(), r.height());
            break;
        }
        case QVariant::Size: {
            QSize s = qvariant_cast<QSize>(v);
            result = QString::asprintf("@Size(%d %d)", s.width(), s.height());
            break;
        }
        case QVariant::Point: {
            QPoint p = qvariant_cast<QPoint>(v);
            result = QString::asprintf("@Point(%d %d)", p.x(), p.y());
            break;
        }
    #endif // !QT_NO_GEOM_VARIANT
    
        default: {
    #ifndef QT_NO_DATASTREAM
            QDataStream::Version version;
            const char *typeSpec;
            if (v.type() == QVariant::DateTime) {
                version = QDataStream::Qt_5_6;
                typeSpec = "@DateTime(";
            } else {
                version = QDataStream::Qt_4_0;
                typeSpec = "@Variant(";
            }
            QByteArray a;
            {
                QDataStream s(&a, QIODevice::WriteOnly);
                s.setVersion(version);
                s << v;
            }
    
            result = QLatin1String(typeSpec)
                    + QLatin1String(a.constData(), a.size())
                    + QLatin1Char(')');
    #else
            Q_ASSERT(!"stringToVariant: Cannot save custom types without QDataStream support");
    #endif
            break;
        }
        }
    
        return result;
    }
    
    QVariant EasyIni::stringToVariant(const QString &s)
    {
        if (s.startsWith(QLatin1Char('@'))) {
            if (s.endsWith(QLatin1Char(')'))) {
                if (s.startsWith(QLatin1String("@ByteArray("))) {
                    return QVariant(s.midRef(11, s.size() - 12).toLatin1());
                } else if (s.startsWith(QLatin1String("@String("))) {
                    return QVariant(s.midRef(8, s.size() - 9).toString());
                } else if (s.startsWith(QLatin1String("@Variant("))
                           || s.startsWith(QLatin1String("@DateTime("))) {
    #ifndef QT_NO_DATASTREAM
                    QDataStream::Version version;
                    int offset;
                    if (s.at(1) == QLatin1Char('D')) {
                        version = QDataStream::Qt_5_6;
                        offset = 10;
                    } else {
                        version = QDataStream::Qt_4_0;
                        offset = 9;
                    }
                    QByteArray a = s.midRef(offset).toLatin1();
                    QDataStream stream(&a, QIODevice::ReadOnly);
                    stream.setVersion(version);
                    QVariant result;
                    stream >> result;
                    return result;
    #else
                    Q_ASSERT(!"stringToVariant: Cannot load custom types without QDataStream support");
    #endif
    #ifndef QT_NO_GEOM_VARIANT
                } else if (s.startsWith(QLatin1String("@Rect("))) {
                    QStringList args = splitArgs(s, 5);
                    if (args.size() == 4)
                        return QVariant(QRect(args[0].toInt(), args[1].toInt(), args[2].toInt(), args[3].toInt()));
                } else if (s.startsWith(QLatin1String("@Size("))) {
                    QStringList args = splitArgs(s, 5);
                    if (args.size() == 2)
                        return QVariant(QSize(args[0].toInt(), args[1].toInt()));
                } else if (s.startsWith(QLatin1String("@Point("))) {
                    QStringList args = splitArgs(s, 6);
                    if (args.size() == 2)
                        return QVariant(QPoint(args[0].toInt(), args[1].toInt()));
    #endif
                } else if (s == QLatin1String("@Invalid()")) {
                    return QVariant();
                }
    
            }
            if (s.startsWith(QLatin1String("@@")))
                return QVariant(s.mid(1));
        }
    
        return QVariant(s);
    }
    
    QStringList EasyIni::splitArgs(const QString &s, int idx)
    {
        int l = s.length();
        Q_ASSERT(l > 0);
        Q_ASSERT(s.at(idx) == QLatin1Char('('));
        Q_ASSERT(s.at(l - 1) == QLatin1Char(')'));
    
        QStringList result;
        QString item;
    
        for (++idx; idx < l; ++idx) {
            QChar c = s.at(idx);
            if (c == QLatin1Char(')')) {
                Q_ASSERT(idx == l - 1);
                result.append(item);
            } else if (c == QLatin1Char(' ')) {
                result.append(item);
                item.clear();
            } else {
                item.append(c);
            }
        }
    
        return result;
    }

connect(ui->myWrite,&QPushButton::clicked,this,[this]{
            using namespace Tool;
            const QString path=qApp->applicationDirPath()+"/ini/"+ui->myEdit->text();
            qDebug()<<"write"<<path;
            EasyIni ini(path,EasyIni::WriteOnly);
            ini.setValue("AA","AA","测试");
            ini.setValue("BB","AA","测试");
            ini.setValue("BB","BB",1);
            ini.setValue("BB","CC",true);
            ini.setValue("中文组","中文键","中文值");
        });
        connect(ui->myRead,&QPushButton::clicked,this,[this]{
            using namespace Tool;
            const QString path=qApp->applicationDirPath()+"/ini/"+ui->myEdit->text();
            qDebug()<<"read"<<path;
            EasyIni ini(path,EasyIni::ReadOnly);
            ini.dumpInfo();
            qDebug()<<ini.groups();
            qDebug()<<ini.keys("AA");
            qDebug()<<ini.keys("A");
            qDebug()<<ini.value("BB","AA");
            qDebug()<<ini.value("BB","BB");
            qDebug()<<ini.value("BB","CC");
            qDebug()<<ini.value("BB","QWER");
            ini.setValue("BB","CC",true);
            ini.setValue("BB","QWER",12345);
            qDebug()<<ini.value("BB","CC");
            qDebug()<<ini.value("BB","QWER");
            qDebug()<<ini.value("BB","QWER2");
        });

[https_github.com_gongjianbo_MyTestCode2021_tree_master_Qt_TestQt_20210425_ini]: https://github.com/gongjianbo/MyTestCode2021/tree/master/Qt/TestQt_20210425_ini