c语言实现读取ini文件操作

最新推荐文章于 2024-08-04 11:02:38 发布
最新推荐文章于 2024-08-04 11:02:38 发布
阅读量3.3k 收藏
点赞数
分类专栏： 文件操作
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/haohaojian/article/details/9313549
版权

包括三部分：ini.h,ini.c,main.c，代码实现如下：

一、ini.h

#ifndef __INI_H__
#define __INI_H__

#include <windows.h>
#include <tchar.h>

#define DEF_PROFILE_NUM_LEN  64
#define ERROR_OK    0
#define ERROR_NO_SECTION  1
#define ERROR_NO_KEY   2 

typedef enum{
    false,
    true
}alexbool;

typedef struct _record
{
 char comments[DEF_PROFILE_NUM_LEN];
 char key[DEF_PROFILE_NUM_LEN];
 char value[DEF_PROFILE_NUM_LEN];
 struct _record* next;
}record;

typedef struct _section
{
 record* first;
 record* last;
 unsigned int sizeRecord;
 char comments[DEF_PROFILE_NUM_LEN];
 char name[DEF_PROFILE_NUM_LEN];
 struct _section* next;
}section;

typedef struct _content
{
 unsigned int sizeSection;
 section* first;
 section* last;
}content;

#define bool unsigned char

extern bool iniStart(const char* filename);
extern bool iniLoad(const char* filename);
bool iniLoad(const char* lpFile);
extern void iniAddSection(const char* sec, const char* comment);
extern struct _section* iniGetSection(const char* sec);
extern struct _record* iniGetRecord(struct _section* sec, const char* key);
extern char* iniGetValue(const char* sec, const char* key);
extern bool iniSave(const char* filename);
extern int iniRemoveAllSection(const char* section);
extern int iniRemoveSelSection(const char* sec, const char* key);
extern BOOL iniWriteInt(const char* lpSection, const char* lpKey, unsigned int nValue,const char* lpComment);
extern void iniGetInt(const char* lpSection, const char* lpKey, unsigned int* nDefault);
extern DWORD iniGetString(const char* lpSection, const char* lpKey, char* lpBuffer);
extern BOOL iniWriteString(const char* lpSection, const char* lpKey, const char* lpValue, const char* lpComment);
extern void iniGetBool(const char* lpSection, const char* lpKey, BOOL* bDefault);
extern BOOL iniWriteBool(const char* lpSection, const char* lpKey, BOOL bDefault, const char* lpComment);
extern DWORD iniInvertBool(const char* lpSection, const char* lpKey);

#endif


二、实现文件

//ini.c

#include "ini.h"
#include <string.h>
#include <stdio.h>

content* pContent;
char gfilename[255];

void iniGetInt(const char* lpSection, const char* lpKey, unsigned int* nDefault)
{
 char sz[DEF_PROFILE_NUM_LEN + 1] = "";

 iniGetString(lpSection, lpKey, sz);
 sscanf(sz, "%d", nDefault);
}

BOOL iniWriteInt(const char* lpSection, const char* lpKey, unsigned int nValue,
 const char* lpComment)
{
 char szValue[DEF_PROFILE_NUM_LEN + 1] = "";

 sprintf(szValue, "%d", nValue);
 return iniWriteString(lpSection, lpKey, szValue, lpComment);
}

void iniGetBool(const char* lpSection, const char* lpKey, BOOL* bDefault)
{
 char sz[DEF_PROFILE_NUM_LEN + 1] = "";

 iniGetString(lpSection, lpKey, sz);
 sscanf(sz, "%d", bDefault);
 *bDefault > 0 ? 1 : 0;
}

BOOL iniWriteBool(const char* lpSection, const char* lpKey, BOOL bDefault, const char* lpComment)
{
 char szValue[DEF_PROFILE_NUM_LEN + 1] = "";

 sprintf(szValue, "%d", bDefault > 0 ? 1 : 0);
 return iniWriteString(lpSection, lpKey, szValue, lpComment);
}

DWORD iniInvertBool(const char* lpSection, const char* lpKey)
{
 BOOL bDefault;
 char szValue[DEF_PROFILE_NUM_LEN + 1] = "";
 struct _section* psection = iniGetSection(lpSection);
 struct _record* precord = iniGetRecord(psection, lpKey);

 iniGetBool(lpSection,lpKey,&bDefault);
 bDefault > 0 ? 1 : 0;
 sprintf(szValue, "%d", !bDefault);   
 
 if (psection == NULL)
 {
  return ERROR_NO_SECTION;
 } 
  
 if (precord == NULL)
 {
  return ERROR_NO_KEY;
 }

 strcpy(precord->key, lpKey);
 {
  strcpy(precord->value, szValue);
 }
 return ERROR_OK;
}

DWORD iniGetString(const char* lpSection, const char* lpKey, char* lpBuffer)
{
 struct _section* psection = iniGetSection(lpSection);
    struct _record* precord = iniGetRecord(psection, lpKey); 
 if (psection == NULL)
 {
  return ERROR_NO_SECTION;
 }
 
 if (precord == NULL)
 {
  return ERROR_NO_KEY;
 }
 else
 {
  strcpy(lpBuffer, precord->value);
  return ERROR_OK;
 }
}

BOOL iniWriteString(const char* lpSection, const char* lpKey, const char* lpValue,
 const char* lpComment)
{
 struct _section* psection = iniGetSection(lpSection);
    struct _record* precord = iniGetRecord(psection, lpKey);
 if (psection == NULL)
 {
  iniAddSection(lpSection, "");
  psection = iniGetSection(lpSection);
 }
  
 if (precord == NULL)
 {
  precord = (struct _record *) malloc(sizeof(struct _record));
  if (precord == NULL)
  {
   printf("cannot malloc memory !\n");
   return ERROR;
  }
  precord->next = NULL;  

  psection->sizeRecord++;

  if (psection->first == NULL)
  {
   psection->first = precord;
   psection->last = precord;
  }
  else
  {
   psection->last->next = precord;
   psection->last = precord;
  }
 }
 if ((lpComment[0] != '#' || lpComment[0] != ';') && (strlen(lpComment) > 0))
 {
  sprintf(precord->comments, "#%s", lpComment);
 }
 else
 {
  strcpy(precord->comments, lpComment);
 }
 strcpy(precord->key, lpKey);
 {
  strcpy(precord->value, lpValue);
 }
 return ERROR_OK;
}

bool iniStart(const char* lpFile)
{
 pContent = (content *) malloc(sizeof(content));
 if (pContent == NULL)
 {
  printf("cannot malloc memory !\n");
  return false;
 }

 pContent->sizeSection = 0; 
 pContent->first = NULL;
 pContent->last = NULL;

 memcpy(gfilename, lpFile, sizeof(gfilename));
 if (iniLoad(gfilename) == false)
 {
  printf("initial parse file error !\n");
  return false;
 };
 return true;
}

bool iniLoad(const char* lpFile)
{
 FILE* fp;
 char buffer[255];
 char comments[1024];
 char NowSection[255];  
 char key[255];
 char value[255];
 char* pdest;
 int index;

 strcpy(comments, "");
 strcpy(NowSection, "");

 if ((fp = fopen(lpFile, "r")) != NULL)
 {
  while (fgets(buffer, sizeof(buffer), fp) != NULL)
  {
   if (buffer[strlen(buffer) - 1] == '\n')
   {
    buffer[strlen(buffer) - 1] = '\0';
   }
   switch (buffer[0])
   {
   case '[':
    pdest = strrchr(buffer, ']');
    if (pdest == NULL)
    {
     fclose(fp);
     printf("parse ini error!\n");
     return false;
    }
    index = pdest - buffer;
    memcpy(NowSection, buffer + 1, index - 1);
    NowSection[index - 1] = '\0';
    iniAddSection(NowSection, comments); 
    strcpy(comments, "");
    break;
   case '#' :
   case ';' :
    if (strlen(comments) > 0)
    {
     strcat(comments, "\n");
    }
    strcat(comments, buffer);
    break;
   default :
    pdest = strrchr(buffer, '=');
    if (pdest == NULL)
    {
     fclose(fp);
     printf("parse ini error\n");
     return false;
    }
    index = pdest - buffer;
    memcpy(key, buffer, index);
    key[index] = '\0';
    memcpy(value, buffer + index + 1, strlen(buffer) - index);

    if (strcmp(NowSection, "") == 0)
    {
     fclose(fp);
     printf("parse ini error\n");
     return false;
    }
    else
    {
     iniWriteString(NowSection, key, value, comments);
     strcpy(comments, "");
    }
    break;
   }
  }
  fclose(fp);
 }
 else
 {
  printf("open file error !\n");
  return false;
 }
 return true;
}

void iniAddSection(const char* lpSection, const char* lpComment)
{
 struct _section* psection;
 psection = iniGetSection(lpSection);

 if (psection == NULL)
 {
  psection = (struct _section *) malloc(sizeof(struct _section));

  if (psection == NULL)
  {
   printf("cannot malloc memory !\n");
   return;
  }

  strcpy(psection->name, lpSection);

  if ((lpComment[0] != '#' || lpComment[0] != ';') && (strlen(lpComment) > 0))
  {
   sprintf(psection->comments, "#%s", lpComment);
  }
  else
  {
   strcpy(psection->comments, lpComment);
  }

  psection->first = NULL;
  psection->last = NULL;
  psection->next = NULL;
  psection->sizeRecord = 0;

  pContent->sizeSection++;

  if (pContent->first == NULL)
  {
   pContent->first = psection;
   pContent->last = psection;
  }
  else
  {
   pContent->last->next = psection;
   pContent->last = psection;
  }
 }
 else
 {
  strcpy(psection->name, lpSection);
  if ((lpComment[0] != '#' || lpComment[0] != ';') && (strlen(lpComment) > 0))
  {
   sprintf(psection->comments, "#%s", lpComment);
  }
  else
  {
   strcpy(psection->comments, lpComment);
  }
 }
}

struct _section* iniGetSection(const char* lpSection)
{
 bool found = false;

 struct _section* psection = pContent->first;
 while (psection != NULL)
 {
  if (strcmp(psection->name, lpSection) == 0)
  {
   found = true;
   break;
  }    
  psection = psection->next;
 }

 if (found == true)
 {
  return psection;
 }
 else
 {
  return NULL;
 }
}

struct _record* iniGetRecord(struct _section* psection, const char* lpKey)
{
 bool found = false;
 struct _record* pRecord;

 if (psection != NULL)
 {
  pRecord = psection->first;

  while (pRecord != NULL)
  {
   if (strcmp(lpKey, pRecord->key) == 0)
   {
    found = true;
    break;
   }
   pRecord = pRecord->next;
  }
  if (found == true)
  {
   return pRecord;
  }
  else
  {
   return NULL;
  }
 }
 else
 {
  return NULL;
 }
}

char* iniGetValue(const char* lpSeciton, const char* lpKey)
{
 struct _section* psection = iniGetSection(lpSeciton);
    struct _record* precord = iniGetRecord(psection, lpKey);
 if (psection == NULL)
 {
  return "NO Section!";
 }
  
 if (precord == NULL)
 {
  return "No Key!";
 }
 else
 {
  return precord->value;
 }
}

bool iniSave(const char* lpFile)
{
 FILE* fp;
 struct _section* psection = pContent->first;
 struct _record* precord; 


 if ((fp = fopen(lpFile, "w")) == NULL)
 {
  printf("open file error\n");
  return false;
 }

 while (psection != NULL)
 {
  if (strlen(psection->comments) != 0)
  {
   fprintf(fp, "%s\n", psection->comments);
  }
  fprintf(fp, "[%s]\n", psection->name);
  precord = psection->first;
  while (precord != NULL)
  {
   if (strlen(precord->comments) != 0)
   {
    fprintf(fp, "%s\n", precord->comments);
   }
   fprintf(fp, "%s=%s\n", precord->key, precord->value);

   precord = precord->next;
  }  
  psection = psection->next;
 } 
 fclose(fp);
 return true;
}

int iniRemoveAllSection(const char* lpSection)
{
 struct _section* psection = iniGetSection(lpSection);
 struct _record* precord;
 int remove = 0;

 if (psection == NULL)
  return 0;

 precord = psection->first;
 while (precord != NULL)
 {
  psection->first = precord->next;
  psection->sizeRecord--;
  free(precord);
  remove++;
  precord = psection->first;
 }
 return remove;
}

int iniRemoveSelSection(const char* lpSection, const char* lpKey)
{
 struct _section* psection = iniGetSection(lpSection);
 struct _record* precord1, * precord2;
 int remove = 0;

 if (psection == NULL)
  return 0;

 precord1 = psection->first;

 if (precord1 == NULL)
  return 0;

 if (strcmp(lpKey, precord1->key) == 0)
 {
  psection->first = precord1->next;
  psection->sizeRecord--;
  free(precord1);
  return 1;
 }

 while (precord1 != NULL)
 {
  if (precord1->next != NULL)
  {
   if (strcmp(lpKey, precord1->next->key) == 0)
   {
    precord2 = precord1->next;    
    precord1->next = precord1->next->next;
    psection->sizeRecord--;
    free(precord2);    
    remove = 1;
    break;
   }
  }  
  precord1 = precord1->next;
 }  
 return remove;
}


三、实现实例//main.c

#include "ini.h"
#include "stdio.h"

void main(void)
{
  char buf[20];
 unsigned int data;
 BOOL bTest;

 iniStart("e:/PG/VC/ini/sample.ini");

 iniWriteString("section1","key1","1","");
 iniWriteString("section1","key2","2","comment2");
 iniWriteInt("section2","key1",1234,"");
 iniWriteInt("section2","key2",5678,"comment2");
 iniWriteBool("section3","key1",100,"bool comment1 true");
 iniWriteBool("section3","key2",0,"bool comment2 false");
 iniInvertBool("section3","key1");
 iniInvertBool("section3","key2");

 iniGetString("section1","key1",buf);
 printf("key1=%s\n",buf);
 iniGetString("section1","key2",buf);
 printf("key2=%s\n",buf);
 iniGetInt("section2","key1",&data);
 printf("key1=%d\n",data);
 iniGetInt("section2","key2",&data);
 printf("key2=%d\n",data);
 iniGetBool("section3","key1",&bTest);
 printf("key1=%d\n",bTest);
 iniGetBool("section3","key2",&bTest);
 printf("key2=%d\n",bTest);

 

 iniSave("e:/PG/VC/ini/sample.ini");
}


智能高科
关注
专栏目录
c语言实现ini文件读写操作
04-08
C语言实现的INI文件读写操作是软件开发中常用的一种配置管理技术。INI文件以其简单的结构和易于编辑的特性，成为了存储程序设置和配置信息的首选格式。通过使用C语言编写的读写操作函数，开发者可以轻松地在程序中...
C语言读写ini配置文件
06-18 2435
环境windows 10 64bitClion 2023.1ini简介ini 文件格式是一种用于保存配置信息的简单文本格式。它通常由多个节(section)组成，每个节包含多个键值对(key-value pair)。下面是 ini 文件的基本语法规则一个ini文件由多个节组成，每个节用方括号([])括起来节后面可以跟一个或多个键值对，每个键值对占一行，格式为key=value键值对中，键(key)...
C语言读取ini配置文件
C or CPP
04-17 814
在这个代码中，我们首先使用 iniparser_load 函数一次性地加载整个INI文件，并将其保存在 dictionary 类型的结构体中。最后，我们使用 iniparser_freedict 函数释放加载的INI文件所占用的内存。如果你想一次性地读取INI文件并将其保存在内存中，我会推荐你使用 iniparser 库。它是一个用纯C写的库，可以解析INI文件，而且它的设计方式是一次性地读取整个INI文件到内存中，方便后续的值读取。但这是一个常见的任务，所以有许多可供选择的库。
C++解析ini文件
最新发布
长弓的博客
08-04 1307
ini文件其实就是一种配置文件，常见于Windows的系统配置文件，当然也可以是其他用途，你的用法你说了算。
C语言读取 ini 配置文件，修改/添加键值对
yishuihanq的博客
02-21 1319
C语言读取 ini 配置文件，对section中的键值对进行修改/添加，如果section不存在，则在末尾将新的section/key/value 添加进去。
C语言读取写入 ini 配置文件
赵凯月的博客
04-05 1078
ini 文件是Initialization File的缩写，即初始化文件，这是用来配置应用软件以实现不同用户的要求。
C语言读写INI配置文件
曹晓林的博客
08-29 777
【代码】C语言读写INI配置文件。
C语言实现ini文件读写操作（C语言）
04-08
通过这种方式，我们可以在C语言中实现ini文件的读写操作，满足应用程序配置管理和存储的需求。这种实现方法虽然相对简单，但在实际项目中可能会遇到性能、安全性及兼容性等问题，因此在处理大文件或高并发场景时，...
c语言实现ini文件读写操作.zip
02-28
本主题聚焦于C语言实现对INI文件的读写操作，INI文件是一种简单的文本配置文件格式，常用于存储应用程序的设置和配置信息。下面我们将深入探讨这个主题，了解如何使用C语言来处理INI文件。 首先，我们需要理解INI...
用C语言读取.ini文件
12-06
在Windows下可以用GetPrivateProfileString或GetPrivateProfileInt方便读取.ini配置文件内容，自己尝试写了一下这个函数。还有一些bug,后面慢慢改。
纯C语言读写ini配置文件
10-17
在C语言中，由于没有内置的库来直接处理ini文件，因此开发者需要自定义函数来实现读取和写入功能。 该示例程序在VC6环境下编译，这意味着它兼容较旧的Microsoft Visual C++ 6.0开发环境。代码中可能包含了必要的...
c 读写config.ini
wxliu1989的专栏
06-09 872
项目需要，今天写了个加载config.ini文件的模块和生成
C语言读写ini、json、csv文件
weixin_46467752的博客
05-06 921
运用C语言读写配置文件中.ini或.json或.csv合适的文件方法。二、读写json格式的配置文件。一、读写ini格式的配置文件。三、读写csv格式的配置文件。
C/C++ 操作ini文件(SinpleIni 跨平台库)
cpp_learner的博客
03-10 6665
超详细介绍simpleini库的使用；C/C++操作ini文件；跨平台。
C语言 实现对INI初始化文件参数的读写
weixin_51091447的博客
04-19 556
C语言实现对INI初始化配置文件的读写
C语言实现读取ini文件简单程序,C语言实现的配置文件读取功能
weixin_35215870的博客
05-17 856
1. 首先声明， 代码主要是从Linux udev程序中提取出来的。2. 支持的配置文件格式如下：#commentvar_name1 = "XXX" #commentvar_name2 = "QQQ" #comment3. config_file.h#include #include #include#define MAX_PATH_LEN (512)#define MAX_FILE_NAME_L...
c语言直接读写ini配置文件
热门推荐
独行猫a 的沉淀、积累、总结。天天学习，好好向上...c/c++,嵌入式 linux,Android,HarmonyOS)
12-12 2万+
现场好多地方反馈记录全采出来，无法入库。实际上采集部门专门做有一数据分析入库工具，但不是标准的，每个地方都需要采集部门特殊改。 于是想到自己做一工具，模拟车载机通信，把全采出来的数据通过连接采集前置传至采集本地库。但是遇到一问题，参数和配置如何保存？ windows系统中有一种ini配置文件，可以用它来保存配置。高级语言操作ini文件很简单，有现有的库，但c语言，只能自己做一个了。分享下 C...
C语言实现读写ini配置文件代码示例
Shayne_Li的专栏
01-31 3378
/******************main.c*******************/ #define _CRT_SECIRE_NO_WARNINGS #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;string.h&gt; #include"CfgFile.h" void menu() {     print...
C语言读取.ini配置文件实战指南
总结来说，C语言读取.ini文件的实例详解主要关注的是如何在没有操作系统内建支持的情况下，使用C语言实现跨平台的配置文件读取。通过学习这个实例，开发者可以掌握如何在自己的项目中实现类似的功能，无论是在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值