Recherche dans un fichier ini

Salut à tous !!
Je désirerais savoir comment faire une recherche de toutes les clés présentes dans un fichier ini précis et les stocker dans une variable.

Par exemple :
for (i = 0; i < 100;i++)
GetPrivateProfileString("Connaissances",NULL,"",file[i],sizeof(file),destination);

Mais il y a un problème car dans mon char file[100][100], je possède toujours la meme chaine de caractères..
Aidez moi svp
   

Salut manta7,

Si tu connais le format des données contenues dans le .ini, il te suffit de lire le fichier ligne par ligne ou caractères par caractère ou autre méthode selon le format.

YOYO, @+.
YOYO

/*************************************************
 *
 Ce n'est pas parfait comme code
 mais ca te donne une idée de
 comment proceder.

 Le code ne prend que les clées/données.
 Les sections ne sont pas gardées.

 Je n'est pas testé le code, désolé.
 Bloc-notes Power!
 *
 *************************************************/

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#define _IS_COMMENT(str) ( *(char *)str == ';' )
#define _IS_SECTION(str) ( *(char *)str == '[' && strchr( (char *)str, ']' ) )
#define _IS_KEY_VALUE(str) ( NULL != strchr( (char *)str, '=' ) )

typedef struct _ini_data
{
 char * key;
 char * value;
}INI_DATA;

typedef struct _ini
{
 INI_DATA * data;
 size_t count;
 size_t size;
}INI;

char * skipspace( const char * str )
{
 while ( *str && !(*str - ' ') )
  ++str;
 return (char *) str;
}

int add_key_value( INI * ini, const char * key, const char * value )
{

 INI_DATA * d;

 /* manque de place ? */
 if ( ini->count-1 >= ini->size )
 {

  { /* augmente la taille du tableau */

   INI_DATA * nd;
   if ( !(nd = realloc( ini->data, (ini->size + 100) * sizeof(INI_DATA) )) )
    return -1;

   ini->data = nd;
   ini->size += 100;

  }

 }

 d = &(ini->data[ ini->count ]);
 if ( d->key = _strdup( key ) && d->value = _strdup( value ) )
 {

  ++(ini->count);
  return 0;

 }

 if ( d->key )
  free( d->key );

 return -1;

}

int read_ini_file( INI * ini, const char * fname )
{

 FILE * fd;
 char buffer[4097];
 char * ptr;
 char * kptr, * vptr;

 if ( !(fd = fopen(fname, "rt")) )
  return -1;

 while ( !feof( fd ) )
 {

  if ( !fgets( buffer, 4096, fd ) )
   break;

  ptr = skipspace( buffer );
  if ( *ptr && !_IS_COMMENT( ptr ) )
  {

   if ( _IS_KEY_VALUE( ptr ) )
   {

    kptr = ptr; /* la clée */
    vptr = strchr( ptr, '=' ); /* la valeur/donnée */
    *vptr++ = '\0'; /* supprime le caractère `=` */

    if ( (ptr = strchr( vptr, '\n' )) )
     *ptr = '\0'; /* supprime le retour à la ligne */

    if ( (ptr = strchr( vptr, ';' )) )
     *ptr = '\0'; /* supprime le commentaire s'il y en à un */

    if ( add_key_value( ini, kptr, vptr ) )
     break; /* ERROR!!! */

   }
   else if ( _IS_SECTION( ptr ) )
   {
    /* continue; */
   }

  }

 }

 fclose( fd );
 return 0; /* no error */

}

void free_ini( INI * ini )
{

 INI_DATA * p;

 if ( (p = ini->data) )
 {

  for ( ; p < ini->data + ini->count; p++ )
  {

   if ( p->key )
    free( p->key );

   if ( p->value )
    free( p->value );

  }

  free( ini->data );

 }

}

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

 INI ini;
 INI_DATA * p;

 ini.size = 100;
 if ( !(ini.data = calloc( ini.size * sizeof(INI_DATA) )) )
  return -1;

 ini.count = 0;
 if ( !read_ini_file( &ini, ".\\mon_fichier.ini" ) )
  puts("SUCCESS");
 else
  puts("ERROR");

 for ( p = ini.data; p < ini.data + ini.count; p++ )
  printf("%s => %s\n", p->key, p->value);

 /* ou encore:

  for ( size_t i = 0; i < ini.count; i++ )
   printf("%s => %s\n", ini.data[i].key, ini.data[i].value);

 */

 printf("count => %u\nsize => %u\n", ini.count, ini.size);
 printf("realloue %u fois\n", (ini.size / 100));

 free_ini( &ini );

 return 0;

}

 

 

 

~(.:: NitRic ::.)~

j'ai une classe qui fait ça....

c'est pour eVC (PDA) mais ça marchera directement sur VC je pense.



#ifdef _DEBUG
#undef THIS_FILE

static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif /* _DEBUG */

#include "stdafx.h"
//#include "QualiTel.hpp"
#include "GestionFichierIni.hpp"

 

BFichierIniPDA::BFichierIniPDA(LPCTSTR lpFileName)
{
/// ------------------------------------------------------------------------------------
/// ---------------- BFichierIniPDA::BFichierIniPDA(LPCTSTR lpFileName) ----------------
/// ------------------------------------------------------------------------------------
/// -----  Objectif : Constructeur de la classe : BFichierIniPDA
/// -----  Auteur(s) : Magic_Nono 17/01/05
/// -----  PostCond : Toutes les variables de la classe doivent être instanciées avec une valeur par défaut ou contextuelle
/// -----  Etat  : 1   (-1<0<1<2)
/// ------------------------------------------------------------------------------------
/// -----  LPCTSTR lpFileName : Chemin complet + nom du fichier de style INI
/// ------------------------------------------------------------------------------------
/// -----  Var Utilisées de la classe (1) : m_sNomFichier
/// -----  Var Muettes (cf.partie préc) (1) : lpFileName
/// -----  Var In  (1) : lpFileName
/// -----  Var Out (1) : m_sNomFichier
 m_sNomFichier=lpFileName;
 // Création de la map en lisant le fichier
 initArbre();
}

 

BFichierIniPDA::~BFichierIniPDA()
{
/// -------------------------------------------------------------------
/// ---------------- BFichierIniPDA::~BFichierIniPDA() ----------------
/// -------------------------------------------------------------------
/// -----  Objectif : Destructeur de la classe : BFichierIniPDA
/// -----  Auteur(s) : Magic_Nono 17/01/05
/// -----  PostCond : Toutes les variables de la classe sont détruites
/// -----  Etat  : 1   (-1<0<1<2)
/// -------------------------------------------------------------------
 m_mapValeurs.RemoveAll();
}

 

bool BFichierIniPDA::lireLigne()
{
/// ---------------------------------------------------------------------
/// ---------------- BFichierIniPDA::lireLigne() -> bool ----------------
/// ---------------------------------------------------------------------
/// -----  Objectif : Lire une ligne du fichier
/// -----  Auteur(s) : Magic_Nono 17/01/05
/// -----  PreCond : /
/// -----  PostCond : /
/// -----  Etat  : 1   (-1<0<1<2)
/// ---------------------------------------------------------------------
/// -----  retour (bool) : succès
/// ---------------------------------------------------------------------
/// -----  Var Utilisées de la classe (1) : m_sContenuLigne
/// -----  Var Internes à la fonction (3) : c ,l_bFinBoucle ,nbRead
/// -----  Var In  Globales Constantes (1) : WCHAR
/// -----  Var Out (1) : m_sContenuLigne
 bool l_bFinBoucle=false;
 m_sContenuLigne.Empty();
 int nbRead=0;
 while(l_bFinBoucle!=true)
 {
  unsigned char c;
  nbRead=m_fichier.Read(&c,1);
  if(nbRead==1)
  {
   if(c==10)
    /// algo : fin de ligne
    l_bFinBoucle=true;
   else
    if(c!=13)
    /// algo : ignorer '\r'
     m_sContenuLigne+=(WCHAR)c;
  }
  else 
  /// algo : fin de fichier
   l_bFinBoucle=true;
 }
 return(nbRead==1 || m_sContenuLigne.GetLength()>0);
}

 

bool BFichierIniPDA::isSection()const
{
/// ---------------------------------------------------------------------
/// ---------------- BFichierIniPDA::isSection() -> bool ----------------
/// ---------------------------------------------------------------------
/// -----  Objectif : Teste si la ligne est une section
/// -----  Auteur(s) : Magic_Nono 17/01/05
/// -----  PreCond : /
/// -----  PostCond : /
/// -----  Etat  : 1   (-1<0<1<2)
/// ---------------------------------------------------------------------
/// -----  retour (bool) : section?
/// ---------------------------------------------------------------------
 return(!m_sContenuLigne.IsEmpty() && m_sContenuLigne.GetAt(0)=='[');
}

 

bool BFichierIniPDA::isCommentaire()const
{
/// -------------------------------------------------------------------------
/// ---------------- BFichierIniPDA::isCommentaire() -> bool ----------------
/// -------------------------------------------------------------------------
/// -----  Objectif : Teste si la ligne est un commentaire
/// -----  Explic : commentaire = ligne commençant par ";"
/// -----  Auteur(s) : Magic_Nono 17/01/05
/// -----  PreCond : /
/// -----  PostCond : /
/// -----  Etat  : 1   (-1<0<1<2)
/// -------------------------------------------------------------------------
/// -----  retour (bool) : cf objectif
/// -------------------------------------------------------------------------
 return(!m_sContenuLigne.IsEmpty() && m_sContenuLigne.GetAt(0)==';');
}

 

void BFichierIniPDA::addEntree()
{
/// -------------------------------------------------------------
/// ---------------- BFichierIniPDA::addEntree() ----------------
/// -------------------------------------------------------------
/// -----  Objectif : Ajouter une entrée dans la map du fichier
/// -----  Auteur(s) : Magic_Nono 17/01/05
/// -----  PreCond : /
/// -----  PostCond : /
/// -----  Etat  : 1   (-1<0<1<2)
/// -------------------------------------------------------------
/// -----  Var Utilisées de la classe (3) : m_sCle ,m_sValeurEntree ,m_tailleArbre
/// -----  Var Internes à la fonction (1) : cle
/// -----  Var In  (3) : m_sCle ,m_sValeurEntree ,m_tailleArbre
 m_tailleArbre++;
 CString cle=getNomSection()+';';
 cle+=m_sCle;
 m_mapValeurs.SetAt(cle,m_sValeurEntree);
}

 

void BFichierIniPDA::initArbre()
{
/// -------------------------------------------------------------
/// ---------------- BFichierIniPDA::initArbre() ----------------
/// -------------------------------------------------------------
/// -----  Objectif : Lecture du fichier et création de la map représentant l'arbre du fichier
/// -----  Auteur(s) : Magic_Nono 17/01/05
/// -----  PreCond : /
/// -----  PostCond : /
/// -----  Etat  : 1   (-1<0<1<2)
/// -------------------------------------------------------------
/// -----  Var : classes externes dont on appelle des méthodes (1) : CFile
/// -----  Var Utilisées de la classe (7) : m_isOpen ,m_sCle ,m_sContenuLigne ,m_sNomFichier ,m_sSection ,m_sValeurEntree ,m_tailleArbre
/// -----  Var In  (2) : m_sContenuLigne ,m_sNomFichier
/// -----  Var In  Globales (1) : modeRead
/// -----  Var Out (5) : m_isOpen ,m_sCle ,m_sSection ,m_sValeurEntree ,m_tailleArbre
 m_tailleArbre=0;
 m_mapValeurs.RemoveAll();
 m_isOpen=(0!=m_fichier.Open(m_sNomFichier,CFile::modeRead));
 if(m_isOpen)
 {
  // Génération de la map des valeurs
  while(lireLigne())
   if(!m_sContenuLigne.IsEmpty() && !isCommentaire())
    if(isSection())
     m_sSection=m_sContenuLigne;
    else
    {
     // On est sur une entrée potentielle
     int positionEgale=m_sContenuLigne.Find('=');
     if(positionEgale>=0)
     {
      // On est sur une entrée!
      m_sCle=m_sContenuLigne.Left(positionEgale);
      m_sValeurEntree=m_sContenuLigne.Mid(positionEgale+1);
      addEntree();
     }
    }
  m_fichier.Close();
 }
}

 

void BFichierIniPDA::copyArbre(LPCTSTR nomFichier)
{
/// -------------------------------------------------------------------------------
/// ---------------- BFichierIniPDA::copyArbre(LPCTSTR nomFichier) ----------------
/// -------------------------------------------------------------------------------
/// -----  Objectif : Recopier la map dans le fichier d'origine
/// -----  Auteur(s) : Magic_Nono 17/01/05
/// -----  PreCond : /
/// -----  PostCond : /
/// -----  Etat  : 1   (-1<0<1<2)
/// -----  TODO  : prise en compte des commentaires !!!
/// -------------------------------------------------------------------------------
/// -----  LPCTSTR nomFichier : Chemin complet + nom du fichier de style INI
/// -------------------------------------------------------------------------------
/// -----  Var : classes externes dont on appelle des méthodes (1) : CFile
/// -----  Var Utilisées de la classe (1) : m_isOpen
/// -----  Var Muettes (cf.partie préc) (1) : nomFichier
/// -----  Var Internes à la fonction (11) : l_Index1 ,l_Index2 ,l_iIndex ,l_iPositionVirgule ,l_sBuffer ,l_sCle ,l_sIdentifiant ,l_sMapBuffer ,l_sSection ,l_sValeur ,l_usCaractere
/// -----  Var In  (1) : nomFichier
/// -----  Var In  Globales (2) : modeCreate ,modeWrite
/// -----  Var Out (1) : m_isOpen
 /// algo : Réinit a 0 du fichier si il existe, sinon création du fichier Accés en écriture
 m_isOpen=(0!=m_fichier.Open(nomFichier,CFile::modeCreate|CFile::modeWrite));
 if(m_isOpen)
 {
  CMapStringToString l_sMapBuffer;
  CString l_sValeur,l_sIdentifiant,l_sSection,l_sCle,l_sBuffer;
  POSITION l_Index1,l_Index2;
  int l_iPositionVirgule,l_iIndex;
  unsigned short l_usCaractere;
  /// algo : Récup toutes les sections
  l_sMapBuffer.RemoveAll();
  l_Index1=m_mapValeurs.GetStartPosition();
  while(l_Index1 != NULL)
  {
   m_mapValeurs.GetNextAssoc(l_Index1,l_sIdentifiant,l_sValeur);
   // contenu de l_sKey -> section;clé
   l_iPositionVirgule=l_sIdentifiant.Find(';');
   l_sSection=l_sIdentifiant.Left(l_iPositionVirgule);
   l_sMapBuffer.SetAt(l_sSection,NULL);
  }
  /// algo : Copie les sections dans le fichier
  l_Index1=l_sMapBuffer.GetStartPosition();
  while(l_Index1 != NULL)
  {
   l_sMapBuffer.GetNextAssoc( l_Index1,l_sSection,l_sValeur);
   m_fichier.Write("[",1);
   // Copie caractère par caractère
   for(l_iIndex=0;l_iIndex<l_sSection.GetLength();l_iIndex++)
   {
    l_usCaractere=l_sSection.GetAt(l_iIndex);
    m_fichier.Write(&l_usCaractere,1);
   }
   m_fichier.Write("]",1);
   m_fichier.Write("\r\n",2);
   /// algo : Pour chaques sections
   l_Index2=m_mapValeurs.GetStartPosition();
   while(l_Index2 != NULL)
   {
    /// algo : Recherche de chaques clés et valeurs associées à cette section
    /// algo : copie dans le fichier
    m_mapValeurs.GetNextAssoc(l_Index2,l_sIdentifiant,l_sValeur);
    // contenu de l_sKey -> section;clé
    l_iPositionVirgule=l_sIdentifiant.Find(';');
    /// algo : Si c'est la bonne section
    if(l_sSection.Compare(l_sIdentifiant.Left(l_iPositionVirgule))==0)
    {
     /// algo : écrit la clé et la valeur ds le fic
     l_sCle=l_sIdentifiant.Mid(l_iPositionVirgule+1,l_sIdentifiant.GetLength()-1);
     // Copie caractère par caractère
     for(l_iIndex=0;l_iIndex<l_sCle.GetLength();l_iIndex++)
     {
      l_usCaractere=l_sCle.GetAt(l_iIndex);
      m_fichier.Write(&l_usCaractere,1);
     }
     m_fichier.Write("=",1);
     // Copie caractère par caractère
     for(l_iIndex=0;l_iIndex<l_sValeur.GetLength();l_iIndex++)
     {
      l_usCaractere=l_sValeur.GetAt(l_iIndex);
      m_fichier.Write(&l_usCaractere,1);
     }
     m_fichier.Write("\r\n",2);
    }
   }
   m_fichier.Write("\r\n",2);
  }
  m_fichier.Close();
 }
}

 

CString BFichierIniPDA::getNomSection()const
{
/// ----------------------------------------------------------------------------
/// ---------------- BFichierIniPDA::getNomSection() -> CString ----------------
/// ----------------------------------------------------------------------------
/// -----  Objectif : Récupérer le nom de la section
/// -----  Auteur(s) : Magic_Nono 17/01/05
/// -----  PreCond : /
/// -----  PostCond : /
/// -----  Etat  : 1   (-1<0<1<2)
/// ----------------------------------------------------------------------------
/// -----  retour (CString) : Nom de la section sans crochets
/// ----------------------------------------------------------------------------
/// -----  Var Utilisées de la classe (1) : m_sSection
/// -----  Var Internes à la fonction (1) : nomSection
/// -----  Var In  (1) : m_sSection
 CString nomSection=m_sSection;
 nomSection.Remove('[');
 nomSection.Remove(']');
 return(nomSection);
}

 

int BFichierIniPDA::get(LPCTSTR lpAppName,LPCTSTR lpKeyName,LPCTSTR lpDefault,LPTSTR lpReturnedString)const
{
/// ----------------------------------------------------------------------------------------------------------------------------------------------
/// ---------------- BFichierIniPDA::get(LPCTSTR lpAppName ,LPCTSTR lpKeyName ,LPCTSTR lpDefault ,LPTSTR lpReturnedString) -> int ----------------
/// ----------------------------------------------------------------------------------------------------------------------------------------------
/// -----  Objectif : Lire une chaine dans un fichier de style INI
/// -----  Auteur(s) : Magic_Nono 17/01/05
/// -----  PreCond : /
/// -----  PostCond : /
/// -----  Etat  : 1   (-1<0<1<2)
/// ----------------------------------------------------------------------------------------------------------------------------------------------
/// -----  LPCTSTR lpAppName : section
/// -----  LPCTSTR lpKeyName : clef
/// -----  LPCTSTR lpDefault : Valeur par défaut
/// -----  LPTSTR lpReturnedString : Pointeur sur buffer qui va contenir la valeur lue
/// ----------------------------------------------------------------------------------------------------------------------------------------------
/// -----  retour (int) : Taille de la chaine lue
/// ----------------------------------------------------------------------------------------------------------------------------------------------
/// -----  Var Muettes (cf.partie préc) (4) : lpAppName ,lpDefault ,lpKeyName ,lpReturnedString
/// -----  Var Internes à la fonction (3) : cle ,l_iValeurRetour ,valeur
/// -----  Var Utilisées par adresse (1) : lpReturnedString
/// -----  Var In  (3) : lpAppName ,lpDefault ,lpKeyName
/// -----  Var In-Out (1) : lpReturnedString
 int l_iValeurRetour=0;
 CString cle=lpAppName;
 cle+=';';
 cle+=lpKeyName;
 CString valeur;
 if(m_mapValeurs.Lookup(cle,valeur))
 {
  // on a bien trouvé l'entrée
  wcsncpy(lpReturnedString,valeur,valeur.GetLength());
  // Ajout du caractère de fin de chaine
  lpReturnedString[valeur.GetLength()]='\0';
  l_iValeurRetour=valeur.GetLength();
 }
 else // On n'a pas trouve l'entrée
  wcsncpy(lpReturnedString,lpDefault,wcslen(lpDefault));
 return(l_iValeurRetour);
}

 

void BFichierIniPDA::set(LPCTSTR lpAppName,LPCTSTR lpKeyName,LPCTSTR lpString)
{
/// -------------------------------------------------------------------------------------------------------------
/// ---------------- BFichierIniPDA::set(LPCTSTR lpAppName ,LPCTSTR lpKeyName ,LPCTSTR lpString) ----------------
/// -------------------------------------------------------------------------------------------------------------
/// -----  Objectif : Ecrire une chaine dans un fichier de style INI
/// -----  Auteur(s) : Magic_Nono 17/01/05
/// -----  PreCond : /
/// -----  PostCond : /
/// -----  Etat  : 1   (-1<0<1<2)
/// -------------------------------------------------------------------------------------------------------------
/// -----  LPCTSTR lpAppName : section
/// -----  LPCTSTR lpKeyName : clé
/// -----  LPCTSTR lpString : valeur
/// -------------------------------------------------------------------------------------------------------------
/// -----  Var Utilisées de la classe (1) : m_sNomFichier
/// -----  Var Muettes (cf.partie préc) (3) : lpAppName ,lpKeyName ,lpString
/// -----  Var Internes à la fonction (1) : cle
/// -----  Var In  (4) : lpAppName ,lpKeyName ,lpString ,m_sNomFichier
 CString cle=lpAppName;
 cle+=';';
 cle+=lpKeyName;
 // Inscription d'une nouvelle chaîne ou mise à jour si elle existe déjà
 m_mapValeurs.SetAt(cle,lpString);
 // Mise à jour du fichier
 copyArbre(m_sNomFichier);
}

 

int BFichierIniPDA::getInt(LPCTSTR lpAppName,LPCTSTR lpKeyName,int nDefault)const
{
/// -------------------------------------------------------------------------------------------------------------------
/// ---------------- BFichierIniPDA::getInt(LPCTSTR lpAppName ,LPCTSTR lpKeyName ,int nDefault) -> int ----------------
/// -------------------------------------------------------------------------------------------------------------------
/// -----  Objectif : Lire un entier dans un fichier de style INI
/// -----  Auteur(s) : Magic_Nono 17/01/05
/// -----  PreCond : /
/// -----  PostCond : /
/// -----  Etat  : 1   (-1<0<1<2)
/// -------------------------------------------------------------------------------------------------------------------
/// -----  LPCTSTR lpAppName : Nom de la section
/// -----  LPCTSTR lpKeyName : Nom de la clé
/// -----  int nDefault(par défaut : '0') : Valeur par défaut
/// -------------------------------------------------------------------------------------------------------------------
/// -----  retour (int) : Valeur lue
/// -------------------------------------------------------------------------------------------------------------------
/// -----  Var Muettes (cf.partie préc) (3) : lpAppName ,lpKeyName ,nDefault
/// -----  Var Internes à la fonction (3) : cle ,l_iValeurRetour ,valeur
/// -----  Var In  (3) : lpAppName ,lpKeyName ,nDefault
 int l_iValeurRetour=nDefault;
 CString cle=lpAppName;
 cle+=';';
 cle+=lpKeyName;
 CString valeur;
 if(m_mapValeurs.Lookup(cle,valeur))
  // on a bien trouvé l'entrée
  if(!valeur.IsEmpty())
   l_iValeurRetour=_tcstol(valeur,NULL,0);
 return(l_iValeurRetour);
}

 

void BFichierIniPDA::setInt(LPCTSTR lpAppName,LPCTSTR lpKeyName,int nValeur)
{
/// -----------------------------------------------------------------------------------------------------------
/// ---------------- BFichierIniPDA::setInt(LPCTSTR lpAppName ,LPCTSTR lpKeyName ,int nValeur) ----------------
/// -----------------------------------------------------------------------------------------------------------
/// -----  Objectif : Ecrire un entier dans un fichier de style INI
/// -----  Auteur(s) : Magic_Nono 17/01/05
/// -----  PreCond : /
/// -----  PostCond : /
/// -----  Etat  : 1   (-1<0<1<2)
/// -----------------------------------------------------------------------------------------------------------
/// -----  LPCTSTR lpAppName : section
/// -----  LPCTSTR lpKeyName : clé
/// -----  int nValeur : Valeur à écrire
/// -----------------------------------------------------------------------------------------------------------
/// -----  Var Utilisées de la classe (1) : m_sNomFichier
/// -----  Var Muettes (cf.partie préc) (3) : lpAppName ,lpKeyName ,nValeur
/// -----  Var Internes à la fonction (2) : cle ,valeur
/// -----  Var In  (4) : lpAppName ,lpKeyName ,m_sNomFichier ,nValeur
 CString cle=lpAppName;
 cle+=';';
 cle+=lpKeyName;
 CString valeur;
 valeur.Format(_T("%d"),nValeur);
 // Inscription d'une nouvelle valeur ou mise à jour si elle existe déjà
 m_mapValeurs.SetAt(cle,valeur);
 // Mise à jour du fichier
 copyArbre(m_sNomFichier);
}

 

void BFichierIniPDA::delSection(CString p_sSectionSupprime)
{
/// ----------------------------------------------------------------------------------------
/// ---------------- BFichierIniPDA::delSection(CString p_sSectionSupprime) ----------------
/// ----------------------------------------------------------------------------------------
/// -----  Objectif : Supprimer une section entière
/// -----  Auteur(s) : Magic_Nono 17/01/05
/// -----  PreCond : /
/// -----  PostCond : /
/// -----  Etat  : 1   (-1<0<1<2)
/// ----------------------------------------------------------------------------------------
/// -----  CString p_sSectionSupprime : Nom de la section à supprimer
/// ----------------------------------------------------------------------------------------
/// -----  Var Utilisées de la classe (1) : m_sNomFichier
/// -----  Var Muettes (cf.partie préc) (1) : p_sSectionSupprime
/// -----  Var Internes à la fonction (4) : l_Position ,l_iIndex ,l_sSection ,l_sValeur
/// -----  Var In  (1) : m_sNomFichier
 POSITION l_Position;
 int l_iIndex;
 CString l_sSection;
 CString l_sValeur;
 l_Position=m_mapValeurs.GetStartPosition();
 while(l_Position!=NULL)
 {
  m_mapValeurs.GetNextAssoc(l_Position,l_sSection,l_sValeur);
  // Recherche de la position de la virgule qui sépare la section de la clé
  l_iIndex=l_sSection.Find(_T(";"),0);
  // Compare la section à supprimer et la section actuelle
  if(p_sSectionSupprime.Compare(l_sSection.Left(l_iIndex))==0)
   // supprime
   m_mapValeurs.RemoveKey(l_sSection);
 }
 copyArbre(m_sNomFichier);
}

 

bool BFichierIniPDA::isVide()const
{
/// ------------------------------------------------------------------
/// ---------------- BFichierIniPDA::isVide() -> bool ----------------
/// ------------------------------------------------------------------
/// -----  Objectif : fichier vide?
/// -----  Auteur(s) : Magic_Nono 10/02/05
/// -----  PreCond : /
/// -----  PostCond : /
/// -----  Etat  : 1   (-1<0<1<2)
/// ------------------------------------------------------------------
/// -----  retour (bool) : cf.objectif
/// ------------------------------------------------------------------
/// -----  Var Utilisées de la classe (1) : m_tailleArbre
/// -----  Var In  (1) : m_tailleArbre
 return(0==m_tailleArbre);
}

Magic Nono: l'informagicien!

Renvoi toute les sections du fichier ini

DWORD GetPrivateProfileSectionNames(
    LPTSTR lpszReturnBuffer,    // address of return buffer
    DWORD nSize,    // size of return buffer
    LPCTSTR lpFileName    // address of initialization filename
   );

Renvoi toute les clefs de la section spécifiée

DWORD GetPrivateProfileSectionNames(
    LPTSTR lpszReturnBuffer,    // address of return buffer
    DWORD nSize,    // size of return buffer
    LPCTSTR lpFileName    // address of initialization filename
   );

Oki alkove c'est ce que je cherchais mais après je ne sais pas m'en servir de ton code....

me suis trompé pour la deuxième fonction c'est

DWORD GetPrivateProfileSection(
  LPCTSTR lpAppName,
  LPTSTR lpReturnedString,
  DWORD nSize,
  LPCTSTR lpFileName
);

en fait ces fonctions retournes une chaine de caractère dans laquel sont les réponsses séparrées par des caractères null, et a la fin de la chaine il y a deux caractères null

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/sysinfo/base/getprivateprofilesection.asp
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/sysinfo/base/getprivateprofilesectionnames.asp

ok les gars
mais pourquoi faire simple?
 
autant tout gérer, cela explique vraiement la philosophie
ensuite, on peut jouer avec des lib
et là seulement, on les exploite au mieux.

sinon, ben bien Alkove ... je ne connaissais pas ces fonctions

Magicalement

Nono: l'informagicien!

je suis d'accord pour tout gèrer, mais bon, là c'est réinventer la roue  ;)