ini文件的读取

已于 2022-11-08 17:18:42 修改
阅读量875 收藏
点赞数
分类专栏： Linux应用编程 文章标签： c++ c语言
于 2022-11-04 14:05:29 首次发布
本文链接：https://blog.csdn.net/m0_37844072/article/details/127683167
版权
  • ini文件:每行末尾有换行符 + 每个section之间有一空行

  • 文件
[0]
id=0
key2=def.key
start=456
end=78

[1]
id=1
key1=abc.key
start=123
end=456
  • 代码示例
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <stdarg.h>

#define LINE_SIZE 128
void get_string_from_ini2(char *title0, char *key, char *filename, char* result)
{
    char lineBuffer[LINE_SIZE] = {'0'};
    char reslt[LINE_SIZE];
    int ofst = 0;
    FILE* fp = fopen(filename, "r");
    int flag = 0;

    char title[16] = {'0'};
    snprintf(title, 16, "[%s]\n", title0);
// read fp until end
    while (!feof(fp))
    {
        // read a char to lineBuffer 
        int chr = fgetc(fp);
        lineBuffer[ofst++] = chr;

        //get a line data
        if (chr == '\n') {
            printf("=== got line [%s]\n", lineBuffer);
            // find title
            if (!strcmp(title, lineBuffer)) {
                // printf("11111 [%s]\n", title);
                flag = 1;
                ofst = 0;
                memset(lineBuffer, 0x00, LINE_SIZE);
                continue;
            }
            // find key-value
            if (flag == 1) {
                if(strstr(lineBuffer, key)) { // find key
                    
                    char* data = strstr(lineBuffer, "=");
                    // printf("====== [%s] \n value [%s]\n", lineBuffer, data);
                    if(data) { strcpy(result, data+1); }  // 拷贝 = 后的数据
                    printf("got data===[%s]\n", result);
                    return;
                }
            }
            // 两个section间的空行
            if (lineBuffer[0] == '\n') {
                flag = 0;
            }
            ofst = 0;
            memset(lineBuffer, 0x00, LINE_SIZE);
        }
    }
}




int main(int argc, char **argv)
{

char relt[32] = {"0"};
// get_string_from_ini2("1", "key0", argv[1], relt);
get_string_from_ini2("1", "key1", argv[1], relt);


}
  • 考虑到需要修改ini特定key的value,于是用一个链表来存一个ini文件，实现了对这个文件的读取，修改。
  • 大体思路：一个字节字节的读，然后把数据写入单链表，再找到需要修改的session和key，再去修改链表的值，最后去把所有的链表数据覆盖写入文件。
  • ini测试文件如下
[1]
id=0
key=key_0.key

[2]
id=3
key=key_x.key
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/*
节点模板
[0]            session[8]
id=0           id[4]
key=def.key    key[16]
*/

typedef struct Data {
	char session[8];
    char id[4];
    char key[16];
} SessionData;
 
//单向链表
typedef struct singleListNode
{
    SessionData data;
    struct singleListNode* next;
}singleListNode;
 

static singleListNode *headNode = NULL, *tailNode = NULL;
static int singleListNodeCount = 0;

// 读到filename文件的title中的key的value 
char key_list[2][16] ={
	"id",
	"key",
};

#define LINE_SIZE 1024
#define LIST_LEN (sizeof(key_list)/ sizeof(key_list[0]))

//链表在last和next之间插入一个节点
singleListNode* insertListNode(singleListNode* last, singleListNode* next)
{
    // generate a node
    singleListNode* newNode = (singleListNode*) malloc(sizeof(singleListNode));
    // new node be pointed by last node
    if (last != NULL) {last->next = newNode;}
    // new node point to next node 
    newNode->next = next;

    singleListNodeCount++;
    return newNode;
}
 
//链表删除数据
void del_ListNode(singleListNode* node)
{
    if (node == headNode) {
        singleListNode* tmp = headNode->next;
        free(headNode);
        headNode = tmp;

        if(--singleListNodeCount == 0)
        {
            headNode = NULL;
            tailNode = NULL;
        }
        return;
    }

    singleListNode* next;
    singleListNode* last = NULL, *nodeTmp=NULL;
    {
        // get next node
        next = node->next;

        // get last node
        for (nodeTmp = headNode; nodeTmp != NULL; (nodeTmp = nodeTmp->next))
        {
            if (nodeTmp->next == node) 
                last = nodeTmp;
        }
    
        // link last node to next node
        if (last)
            last->next = next;
    }
    // update tailnode val
    if (node == tailNode) {
        tailNode = last;
    }
    free(node);
    singleListNodeCount--;
    return;
}

void printfData(SessionData* data) {
	char rslt[1024];
	snprintf(rslt, 1024, "session = [%s] id =[%s] key =[%s]",
	            data->session, data->id, data->key);
    printf("%s\n", rslt);
}

// print all list val
void printfListVal()
{
    singleListNode* node;
    int a = 0;
    printf("===============head %p count %d\n", headNode, singleListNodeCount);
    for (node = headNode; node != NULL; (node = node->next))
    {
        printf("node = [%p] ", node);
        printfData(&node->data);
    }
    for (node = headNode; node != NULL; (node = node->next))
    {
        printf("node %p-->%p--\n", node, node->next);
    }
    printf("===============tail %p\n", tailNode);
}

void create_NodeatTail(SessionData data)
{
    singleListNode* tmp = NULL;
    if (!headNode) {
        headNode = insertListNode(NULL, NULL);
        tailNode = headNode;
        tmp = headNode;
    } else {
        tmp = insertListNode(tailNode, NULL);
        tailNode = tmp;
    }
    memcpy(&tmp->data, &data, sizeof(SessionData));
}

// 在last和next之间插入节点并赋值
void create_NodeafterNode(SessionData* data, singleListNode* last, singleListNode* next)
{
    singleListNode* tmp = insertListNode(last, next);
    memcpy(&tmp->data, data, sizeof(SessionData));
}

void get_string_from_ini(char *title0, char *key, char *filename, char* result)
{
    char lineBuffer[LINE_SIZE] = {'0'};
    char reslt[LINE_SIZE];
    int ofst = 0;
    FILE* fp = fopen(filename, "r");
    int flag = 0;

    char title[16] = {'0'};
    snprintf(title, 16, "[%s]\n", title0);
// read fp until end
    while (!feof(fp))
    {
        // read a char to lineBuffer 
        int chr = fgetc(fp);
        lineBuffer[ofst++] = chr;

        //get a line data
        if (chr == '\n') {
            printf("=== got line [%s]\n", lineBuffer);
            // find title
            if (!strcmp(title, lineBuffer)) {
                // printf("11111 [%s]\n", title);
                flag = 1;
                ofst = 0;
                memset(lineBuffer, 0x00, LINE_SIZE);
                continue;
            }
            // find key-value
            if (flag == 1) {
                if(strstr(lineBuffer, key)) { // find key
                    
                    char* data = strstr(lineBuffer, "=");
                    // printf("====== [%s] \n value [%s]\n", lineBuffer, data);
                    if(data) { strcpy(result, data+1); }  // 拷贝 = 后的数据
                    printf("got data===[%s]\n", result);
                    return;
                }
            }
            // 两个section间的空行
            if (lineBuffer[0] == '\n') {
                flag = 0;
            }
            ofst = 0;
            memset(lineBuffer, 0x00, LINE_SIZE);
        }
    }
}

void data_set(int i, char* value, SessionData* data)
{
    printf(" len =%ld\n", strlen(value));
	switch (i)
	{
	case 0:
		strncpy(data->id, value, 4);
		break;
	case 1:
		strncpy(data->key, value, 16);
		break;
	default:
		break;
	}

}

int get_SessionData(FILE* fp, SessionData* node)
{
	int ofst = 0;
	char line[128] = {'\0'};
    char title[8];
    int size_cnt = -1;
    while (!feof(fp))
    {
        // read a char to lineBuffer 
        int chr = fgetc(fp);
		line[ofst++] = chr;
		if (chr == '\n') {
            size_cnt += strlen(line);

			if (line[0] == '\n') { // 两个session间的空格
                // ftell(fp);
                return 0;
			} else if (line[0] == '[' && line[ofst-2] == ']') { // get title
				strncpy(node->session, &line[1], (ofst-3));
			} else {
                // 替换 '\n' 为 '\0'
                if (ofst > 1) {
                    line[ofst-1]= '\0';
                }
                // 得到所有的key-value到 node
				for (int i = 0; i < LIST_LEN; i++)
				{
					char* ptr = strstr(line, key_list[i]);
					if (ptr) {
                        char* data = strstr(line, "=");
                        printf("key [%s] data[%s]",  key_list[i], data+1);
						data_set(i, data + 1, node);
                        break;
					}
				}
			}
			memset(line, 0x00, sizeof(line));
			ofst = 0;
		}
	}
    return size_cnt;




}

//根据fp不同选择插入模式
void update_FileBySessionData(FILE* fp, SessionData* dataSession)
{

    char rslt[1024] = {'\0'};

    {
        // write session
        snprintf(rslt, 1024, "[%s]\n"
                                "id=%s\n"
                                "key=%s\n"
                                "\n",
                    dataSession->session, dataSession->id, dataSession->key);
        fprintf(fp, "%s", rslt);
        printf("%s", rslt);
    }

}

// updata data after session which find by listtable
void updateFile_AfterSession(FILE* fp, SessionData* data, char* session)
{

// update data to linktable
    singleListNode* node;
    printfListVal();
    for (node = headNode; node != NULL; (node = node->next))
    {
        if (!strcmp(node->data.session, session))
        {
            create_NodeafterNode(data, node, node->next);
            break;
        }
    }
    printfListVal();
// write linktable to file
    for (node = headNode; node != NULL; (node = node->next))
        update_FileBySessionData(fp, &node->data);
}

int main()
{

    char* filename;
//从ini文件读数据：链表的形式
    {
        /*
        [0]
        id=0
        key=key_0.key

        [1]
        id=1
        key=key_s.key

        [2]
        id=3
        key=key_x.key

        */
//         FILE* fp = fopen("Conf.ini", "r");
//         SessionData tmp;  
// 		memset(&tmp, 0x00, sizeof(tmp));
// //把数据放入链表
//         while (!feof(fp))
//         {
//             // 读一个session并把数据放入tmp
//             get_SessionData(fp, &tmp);  // &tmp = 0x7fffffffe050
//             // 创建链表节点
//             create_NodeatTail(tmp);
//     		memset(&tmp, 0x00, sizeof(tmp));
//         }
// //删除链表
//         printfListVal();
//         del_ListNode(headNode);
//         printfListVal();
//         del_ListNode(tailNode);
//         printfListVal();
//         del_ListNode(tailNode);
//         printfListVal();
    }

//从ini文件读数据：解析字符串
	{
	    //char result[32];
        //get_string_from_ini("0", "id", "config.ini", result);
	}

// 往ini文件写数据
    {
        // SessionData tmp1 = {
        //     .session = "3",

        //     .id = "4",
        //     .key = "key_9.key",
        // };

        // create_NodeatTail(tmp1);

        // // FILE* fp = fopen("Conf.ini", "r+"); // 不覆盖
        // // FILE* fp = fopen("Conf.ini", "w"); // 覆盖写到开头
        // FILE* fp = fopen("Conf.ini", "a+"); // 不覆盖写到末尾

        // update_FileBySessionData(fp, &tmp1);
    }

// 在某个节点之后写入session
    {

        FILE* fp = fopen("Conf.ini", "r");
        SessionData tmp;  
		memset(&tmp, 0x00, sizeof(tmp));
//把数据放入链表
        while (!feof(fp))
        {
            // 读一个session并把数据放入tmp
            if (-1 != get_SessionData(fp, &tmp)) {
                // 创建链表节点
                create_NodeatTail(tmp);
                memset(&tmp, 0x00, sizeof(tmp));
            }
        }
        printfListVal();
        fclose(fp);

        FILE* fp2 = fopen("Conf.ini", "w+");
// 在session [1]之后插入 tmp1
        SessionData tmp1 = {
            .session = {'5', '\0', '\0'},
            .id = {'4', '\0', '\0'},
            .key = {'k', 'e', 'y', '_', '9', '.', 'k', 'e', 'y', '\0', '\0'},
        };
        updateFile_AfterSession(fp2, &tmp1, "1");
        fclose(fp2);

    }
	return 0;
}

L7256
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ini配置文件读取方法
ellis993的博客
03-25 120
head file #pragma once #include <windows.h> #include <tchar.h> class IniFile { public: enum { MAX_BUFFER_SIZE = 1024 }; IniFile(); explicit IniFile(const char *FileName); ~IniFile(); bool Open(); bool Open(const ch.
ini文件读取
05-09
二、ini文件读取 读取ini文件主要涉及以下步骤： 1. 打开文件：使用`fopen()`函数打开ini文件，通常以只读模式`"r"`打开。 2. 逐行读取：通过`fgets()`或`getline()`函数逐行读取文件内容。 3. 分析内容：解析每一...
【C++】基础：读取ini配置信息
DevFrank的博客
06-20 2305
ini读取配置示例
实现Python对.ini配置文件内容的读取和写入
sunny
08-16 371
这段代码首先使用`configparser.ConfigParser()`方法创建了一个`ConfigParser`对象，并使用`read()`方法读取了`config.ini`文件。接着，使用`get()`、`getint()`、`getfloat()`和`getboolean()`方法获取了配置项的值。然后，使用`set()`方法修改了配置项的值，使用`add_section()`方法添加了新的配置项，使用`remove_option()`方法删除了配置项。
ini文件的读取和修改
xucoco1的博客
04-26 250
ini文件操作
Java读取INI文件详解及案例
故事不长丨的博客
07-17 2425
通过本文的介绍，我们了解了如何使用Java读取和解析INI文件。通过使用Java标准库或第三方库，我们可以轻松地处理INI文件的配置信息，并根据需要获取特定的属性值。
initestt_INI文件读取_
10-02
然而，尽管INI文件传统上与Windows环境紧密相关，但在Linux系统中也可以通过编程方式实现读取。本文将详细介绍如何在Linux下实现INI文件的读取，不依赖于Windows的特定API。 INI文件的基本结构通常包括多个节...
inifile.rar_ini_ini 文件_ini 文件读取
07-14
C++语言虽然没有内置的库来直接操作ini文件，但我们可以自定义函数或者利用第三方库来实现读取和写入ini文件的功能。 在C++中，实现ini文件的操作通常涉及到以下几个关键知识点： 1. **文件流（File Streams）**：...
labview源码ini文件读取
02-17
labview源码ini文件读取本资源系百度网盘分享地址
config_ini配置文件读取_
10-03
它自动处理ini文件的格式，并提供了一种更简洁的方式来读写键值对。使用`QSettings`，你可以直接通过键名来存取值。 ```cpp QSettings settings("path_to_config/config.ini", QSettings::IniFormat); QString key ...
Iniparser——非常好用的ini文件读写代码
04-19
Iniparser——非常好用的ini文件读写源代码，供大家学习研究
ini文件读写
01-03
ini文件读写C#
py内置库configparser
lijianping962464的博客
06-14 138
python内置库configparser
C# INI文件读取串口参数，string转枚举
m0_47020592的博客
09-13 297
在使用ini读取串口配置时，ini文件读取的数据类型为string ，而串口的参数设置校验位和停止位为枚举类型，因类型不匹配，读取出来的字符串不能直接使用，需要作进一步处理，将字符串转换为枚举类型。
C# INI配置文件的读写
weixin_65414269的博客
09-25 2763
initialization file的缩写，即初始化文件，通常存放的是一个程序的初始化信息，是Windows的系统配置文件所采用的存储格式，统管windows的各项配置。ini文件的后缀名不一定是.ini，也可以是.cfg、.conf、或者是.tx*。：最基本元素，包含参数名（name）和参数值（value），号后直到行尾均为注释。组成，每个 key 可以赋相应的值。：所有的参数以节为单位结合在一起。组成，每个section由若干。，而这只要借助几个函数即可完成。
Qt 读取ini中文字符
qq_44269651的博客
06-13 1298
Qt读取ini文件中文字符。
c程序解析ini配置文件
jack8126的博客
05-18 2093
c程序解析ini配置文件 很多程序都有配置文件，配置文件有很多种类型，以下实现ini配置文件中的参数读取功能。 1、ini配置文件 配置文件名称为test.ini，内容如下： [bmpinfo] width=1920 height=1080 bit=3 blue=0 green=0 red=255 [bmpinfo_end] 2、c程序代码 主要函数是get_string_from_ini和GetIniKeyString两个。功能是获取ini配置文件中的字符串。如果是整形的配置文件，可以通过atoi转换。
Win32汇编教程十三 INI 文件的操作
蝈蝈俊.net
12-15 2535
--------------------------------------------------------------------------------概述在程序中经常要用到设置或者其他少量数据的存盘，以便程序在下一次执行的时候可以使用，比如说保存本次程序执行时窗口的位置、大小、一些用户设置的数据等等，在 Dos 下编程的时候，我们一般自己产生一个文件，由自己把这些数据写到文件中，然后在下
pytest.ini文件读取
最新发布
06-26
当你使用pytest运行测试时，它会先查找当前目录下的pytest.ini文件，如果找不到则会向上级目录查找，直到找到或者到达根目录。 pytest.ini通常包含以下部分： 1. [pytest] 或者 [tool:pytest] 部分：包含了全局的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值