C++ > Comparaison

// Comparaison fichiers.cpp*: définit le point d'entrée pour l'application console.
//

/////////////////////
/// Bibliothèques ///
/////////////////////

#include <stdafx.h>
#include <string>
#include <fstream>
#include <iostream>
#include <sstream>
#include <cassert>
#include <vector>
#include <algorithm>

using namespace std;


////////////////////////////////
/// Déclaration de Variables ///
////////////////////////////////

#define NBRE_COL 8

int compteur = 0;

///////////////////////////////////
/// Déclaration de structure(s) ///
///////////////////////////////////

typedef struct structure
{
        string col[8];
        bool structure::operator == ( const structure& cols ) const;
};


//////////////////////////////
/// Prototype de Fonctions ///
//////////////////////////////

ostream& operator << ( ostream& out, structure colonne_var );
void recup_ligne( ifstream& fichier, structure &colonne_var );
void affich_Tab( vector < structure > tableau );
int compare( vector < structure > Tab1, vector < structure > Tab2 );


///////////////////////////
/// Programme Principal ///
///////////////////////////

int _tmain(int argc, _TCHAR* argv[])
{
        /* Ouverture des fichiers en lecture */

        ifstream fichier1L( "C:\\Documents and Settings\\bastien\\Bureau\\Offres - Tables EDI Excel\\20090727-TABLES_EDI_petit.csv" );
        if( fichier1L.is_open( ) == false )
        {
                cout << "ERREUR LORS DE L'OUVERTURE DU FICHIER 20090727-TABLES_EDI_petit.csv" << endl;
                assert( false );
                return -1;
        }

        ifstream fichier2L( "C:\\Documents and Settings\\bastien\\Bureau\\Offres - Tables EDI Excel\\20090731-TABLES_EDI_petit.csv" );
        if ( fichier2L.is_open( ) == false )
        {
                cout << "ERREUR LORS DE L'OUVERTURE DU FICHIER 20090731-TABLES_EDI_petit.csv" << endl;
                assert( false );
                return -1;
        }

        /* Ouverture des fichiers en écriture */

        ofstream fichier1E( "C:\\Documents and Settings\\bastien\\Bureau\\Ecriture de 20090727-TABLES_EDI.txt" );
        if ( fichier1E.is_open( ) == false )
        {
                cout << "ERREUR LORS DE L'OUVERTURE DU FICHIER Ecriture de 20090727-TABLES_EDI.txt" << endl;
                assert( false );
                return -1;
        }

        ofstream fichier2E( "C:\\Documents and Settings\\bastien\\Bureau\\Ecriture de 20090731-TABLES_EDI.txt" );
        if ( fichier2E.is_open( ) == false )
        {
                cout << "ERREUR LORS DE L'OUVERTURE DU FICHIER Ecriture de 20090731-TABLES_EDI.txt" << endl;
                assert( false );
                return -1;
        }


        // Pour lire les lignes du fichier1L et les afficher:

        string ligne;
        structure colonne_var;                          // Création d'une variable "colonne_var" de type "Colonne_struct".
        vector < structure > MonTableau1;       // Création d'un tableau contenant n structures.

        while ( getline( fichier1L, ligne ) != 0 )
        {
                recup_ligne( fichier1L, colonne_var );  // Récupère les lignes du premier fichier
                cout << colonne_var.col[0] << "\t" << colonne_var.col[3] << endl;       // Affiche la première et 4ème colonne du premier fichier

                MonTableau1.push_back( colonne_var );   // Insère les lignes lues du premier fichier dans MonTableau1
                fichier1E << colonne_var.col[0] << "\t" << colonne_var.col[3] << endl;  // Ecrit la première et 4ème colonne de MonTableau1 dans un fichier .txt
        }

       
        // Pour lire les lignes du fichier2L et les affciher:

        string ligne1;
        vector < structure > MonTableau2;

        while ( getline( fichier2L, ligne1 ) != 0 )
        {
                recup_ligne( fichier2L, colonne_var );  // Récupère les lignes du second fichier
                cout << colonne_var.col[0] << "\t" << colonne_var.col[3] << endl;       // Récupère les lignes du second fichier

                MonTableau2.push_back( colonne_var );   // Insère les lignes lues du second fichier dans MonTableau2
                fichier2E << colonne_var.col[0] << "\t" << colonne_var.col[3] << endl;  // Ecrit la première et 4ème colonne dans un second fichier .txt
        }
       
        cout << endl << endl;

        // Affichage du tableau pour le fichier1L
        affich_Tab( MonTableau1 );

        // Affichage du tableau pour le fichier2L
        affich_Tab( MonTableau2 );
       
        cout << endl << endl;


        //COMPARAISON FICHIER 1 AU FICHIER 2
        compare( MonTableau1, MonTableau2 );
        cout << "Ligne(s) presente(s) dans le fichier 1 et non presente(s) dans le fichier 2: " << endl << compteur << " ligne(s)" << endl;
       
        cout << endl << endl;

        //COMPARAISON FICHIER 2 AU FICHIER 1
        compare( MonTableau2, MonTableau1 );
        cout << "Ligne(s) presente(s) dans le fichier 2 et non presente(s) dans le fichier 1: " << endl  << compteur << " ligne(s)"  << endl;
       
               
        fichier1L.close();
        fichier2L.close();      /**************************/
        fichier1E.close();      /* fermeture des fichiers */   
        fichier2E.close();      /**************************/

        return 0;
}


////////////////////////////////
/// Déclaration de Fonctions ///
////////////////////////////////

/* Fonction pour récupérer les lignes d'un fichier */
void recup_ligne( ifstream &fichier, structure &variable )
{
        for ( int i = 0; i < 7; ++i )
        {
                getline( fichier, variable.col[i], ';' );
        }
        getline( fichier, variable.col[7] );
}

/* Fonction pour afficher le contenu d'un tableau */
void affich_Tab( vector < structure > tableau )
{
        for ( unsigned int i = 0; i < tableau.size( ) ; ++i )
        {
                cout << tableau[i] << "\t";
        }
        cout << endl;
}      

/* Fonction pour déclarer un opérateur == */
bool structure::operator == (const structure & cols) const
{
        for ( int i = 0; i < NBRE_COL; ++i)
        {
                if ( col[i] != cols.col[i] )
                                return false;
        }
                return true;
}

/* Fonction pour déclarer un opérateur << */
ostream& operator << ( ostream& out, structure colonne_var )
{
        for ( int i = 0; i < NBRE_COL; ++i )
        {
                out << colonne_var.col[i] << " ";
        }
        out << endl;
        return out;
}

/* Fonction pour comparer le contenu des deux tableaux */
int compare( vector < structure > Tab1, vector < structure > Tab2 )
{
        compteur = 0;

        vector < structure >::iterator itCurrent1;                              // Création d'un vector de type "Colonne_struct" qui est un iterator de nom "itCurrent1".
        vector < structure >::iterator itEnd1 = Tab1.end( );    // Création d'un vector de type "Colonne_struct" qui est un iterator de nom "itEnd1" initialisé à la fin d'un tableau.

        vector < structure >::iterator itCurrent2;                              // Idem
        vector < structure >::iterator itEnd2 = Tab2.end( );    // Idem
       
        cout << endl;
       

        itCurrent1 = Tab1.begin ( );                                   
        for ( ; itCurrent1 != itEnd1; ++itCurrent1 )                            // Deux boucles for imbriquées permettent la comparaison;
        {                                                                                                                       // On compare chaque ligne du tableau1 à l'ensemble des
                bool trouve = 0;                                                                                // lignes du tableau2.                                                                 
                                                                                                                                // Pour une ligne du tableau1, on parcour l'ensemble du tableau2
                itCurrent2 = Tab2.begin ( );                                                    // Si la ligne est trouvée, on place "trouve" à true et on sort
                for ( ; itCurrent2 != itEnd2; ++itCurrent2 )                    // de la seconde boucle for.
                {                                                                                                               // Si la ligne n'est pas trouvée, "trouve" est à "false", on incrémente un compteur
                        if ( *itCurrent2 == *itCurrent1 )                                       // (qui sera chargé de renseigner par la suite le nombre de lignes absentes)
                        {                                                                                                       // et on affiche la ligne qui ne se trouve pas dans le tableau2.
                                trouve = true;                                                                  // Enfin, lorsque la comparaison est finie, on renvoi la valeur du compteur.
                                break;
                        }
                }      

                if( trouve == false )
                {
                        compteur = compteur++;
                        cout << *itCurrent1;
                }
        }
        return compteur;
}