[C++] Creazione di una libreria per la gestione dei file

[Salvatore_91]

Salve raga, vorrei creare una semplice libreria per gestire i file.

Ora ad esempio, ho scritto il seguente programma:

# include <iostream>
# include <stdio.h>
# include <fstream>
# include <string>
# include <sstream> 

using namespace std;

int ID;

class File
{

 public:
	void ApriFileInScrittura(string NomeFile, std::ios_base::openmode metodo)
	{
		ofstream write(NomeFile.c_str(), metodo); 
	}   
/************************************FINE**************************************/    
    void GeneraID(string NomeFile) 
    {
     ifstream trovaID("ID.txt", ios::in); //ID.txt file contentente il numero                                     // dell'ultimo ID inserito
     if (trovaID)
              {
               trovaID >> ID;
               ID=ID+1;
               trovaID.close();
              } 
              else
              ID=1; 
                 
     ofstream write(NomeFile.c_str(),ios::app); 
     write <<"L;";   /* Imposta FLAG per la CANCELLAZIONE LOGICA*/

///////////////////////////// 
     stringstream s;      //   
     string ss;          //          
     s << ID ;          //
     ss = s.str();     // /* Dimesione dell' ID = 5
     ss.resize(5);    //  dato che ss.resize(5); */
     write <<ss;     //
//////////////////////  
     write.close();
  
  // Aggiorna L'ID che viene scritto sul file ID.txt
     ofstream aggID("ID.txt", ios::out);  
     aggID << ID;    
     aggID.close();                    
    } 
/************************************FINE**************************************/    
    void ScriviCampo(string NomeFile, string Campo, int DimCampo)
    {
     ofstream write(NomeFile.c_str(),ios::app);
     Campo.resize(DimCampo);
     write << Campo;
     write.close();    
    }
/************************************FINE**************************************/    
    void ScriviUltimoCampo(string NomeFile, string Campo, int DimCampo)
    {
     ofstream write(NomeFile.c_str(),ios::app);
     Campo.resize(DimCampo);
     write << Campo << endl;
     write.close();    
    } 
};

int main()
{
    File A1;
    A1.ApriFileInScrittura("PROVA.txt", ios::app);
    A1.GeneraID("PROVA.txt");  
    A1.ScriviCampo("PROVA.txt", "Salvatore", 20);
    A1.ScriviCampo("PROVA.txt", "Ciotola", 20);
    A1.ScriviUltimoCampo("PROVA.txt", "UltimoCampo", 20);
    
    getchar();
    getchar();
}

Io ora vorrei farne di questo programma una libreria, nel senso che:
tutto il seguente codice, deve stare in un file chiamato "mialibreria.h" e il resto deve essere il mio file.cpp:

# include <iostream>
# include <stdio.h>
# include <fstream>
# include <string>
# include <sstream> 

using namespace std;

int ID;

class File
{

 public:
	void ApriFileInScrittura(string NomeFile, std::ios_base::openmode metodo)
	{
		ofstream write(NomeFile.c_str(), metodo); 
	}   
/************************************FINE**************************************/    
    void GeneraID(string NomeFile) 
    {
     ifstream trovaID("ID.txt", ios::in); //ID.txt file contentente il numero                                     // dell'ultimo ID inserito
     if (trovaID)
              {
               trovaID >> ID;
               ID=ID+1;
               trovaID.close();
              } 
              else
              ID=1; 
                 
     ofstream write(NomeFile.c_str(),ios::app); 
     write <<"L;";   /* Imposta FLAG per la CANCELLAZIONE LOGICA*/

///////////////////////////// 
     stringstream s;      //   
     string ss;          //          
     s << ID ;          //
     ss = s.str();     // /* Dimesione dell' ID = 5
     ss.resize(5);    //  dato che ss.resize(5); */
     write <<ss;     //
//////////////////////  
     write.close();
  
  // Aggiorna L'ID che viene scritto sul file ID.txt
     ofstream aggID("ID.txt", ios::out);  
     aggID << ID;    
     aggID.close();                    
    } 
/************************************FINE**************************************/    
    void ScriviCampo(string NomeFile, string Campo, int DimCampo)
    {
     ofstream write(NomeFile.c_str(),ios::app);
     Campo.resize(DimCampo);
     write << Campo;
     write.close();    
    }
/************************************FINE**************************************/    
    void ScriviUltimoCampo(string NomeFile, string Campo, int DimCampo)
    {
     ofstream write(NomeFile.c_str(),ios::app);
     Campo.resize(DimCampo);
     write << Campo << endl;
     write.close();    
    } 
};

Pero non ci riesco, qualkuno di voi puo dirmi come fare?

[sebaldar]

come già più volte sottolineato in questo forum i file .h o .hpp non sono librerie ma file inclusi.
Per creare una libreria devi scrivere un sorgente che contenga le funzioni o le classi che vuoi esportare ma senza il main, che è in questo caso inutile.
Questo sorgente va poi compilato e linkato con quanto necessario per creare una libreria statica o dinamica, a secondo di quella che si voglia utilizzare.
Per creare queste librerie ci sono istruzioni apposite da dare al compilatore.
Dopo che hai creato la tua libreria la potrai utilizzare nei tuoi programmi senza che questa venga nuovamente compilata e, nel caso delle librerie dinamiche, senza che faccia neanche parte del tuo eseguibile
ciao
sergio

[Salvatore_91]

Scusami per la mia ignoranza.
Ma non e' che potresti indicarmi come scrivere (o suddividere i file)??? Ho postato il codice sorgente apposta.

[sebaldar]

forse non vuoi creare una libreria ma semplicemente scriver un file header.
In questo caso tieni presente che è meglio inserire nel file header solo le dichiarazioni e non il corpo delle funzioni
Nel tuo caso il file header dovrebbe essere qualcosa simile a

# include <iostream>
# include <stdio.h>
# include <fstream>
# include <string>
# include <sstream> 

using namespace std;

int ID;

class File
{

 public:
    void ApriFileInScrittura(string NomeFile, std::ios_base::openmode metodo);
    void GeneraID(string NomeFile) ;
    void ScriviCampo(string NomeFile, string Campo, int DimCampo);
    void ScriviUltimoCampo(string NomeFile, string Campo, int DimCampo);
};

l'mplementazione la dovrai invece mettere nel file cpp e verrà qualcosa del tipo

    void File::GeneraID(string NomeFile) 
    {
     ifstream trovaID("ID.txt", ios::in); //ID.txt file contentente il numero                                     // dell'ultimo ID inserito
     if (trovaID)
              {
               trovaID >> ID;
               ID=ID+1;
               trovaID.close();
              } 
              else
              ID=1; 
                 
     ofstream write(NomeFile.c_str(),ios::app); 
     write <<"L;";   /* Imposta FLAG per la CANCELLAZIONE LOGICA*/

///////////////////////////// 
     stringstream s;      //   
     string ss;          //          
     s << ID ;          //
     ss = s.str();     // /* Dimesione dell' ID = 5
     ss.resize(5);    //  dato che ss.resize(5); */
     write <<ss;     //
//////////////////////  
     write.close();
  
  // Aggiorna L'ID che viene scritto sul file ID.txt
     ofstream aggID("ID.txt", ios::out);  
     aggID << ID;    
     aggID.close();                    
    } 
/************************************FINE**************************************/

e così via
ciao
sergio

[Salvatore_91]

scusa ma non ho capito.

Io vorrei suddividere il mio programma in :
una libreria.h e un programma.cpp


Non so come fare?? potresti spiegarti meglio?, specificando come chiamare i file

[sebaldar]

allora un file header (.h o .hpp) non è una libreria!
Normalmente in C++ nel file header dovresti inserire le dichiarazioni e nel file .cpp le implementazione.
La struttura del file .h te la ho già scritta, salvo errori od omissioni.
Il file .cpp dovrà invece, prima di tutto, includere il file .h e questo si fa con la direttiva del preprocessore

#include "mio_header.h"

e quindi la implementazione, nel tuo caso, della classe File.
Questo si fa come ti ho indicato nel precedente post, cioè scrivi la funzione facendo precedere il nome della tua funzione dal nome della classe seguito da :: .
Nel file .cpp dovrai quindi inserire il tuo main.

Non entro in merito nella classe che sembra contenere solo funzioni statiche, dato che non so l'uso che ne vuoi fare.
ciao
sergio

[Salvatore_91]

scusami... ma non ci siamo capiti.

Indipendemente, io vorrei che in un file ci siano le funzioni o metodi (con tutto il loro codice), mentre in un altro file, c'e' il programma, che esegue le funzioni o metodi dell'altro.

[Ippo343]

No salvatore sei tu che non hai capito.

Ti servono 3 file:

main.cpp
mio_header.h
mio_header.cpp

in main.cpp devi scrivere:

#include "mio_header.h"

int main()
{
    //Qui ci metti il tuo programma
}

In mio_header.h ci metti solo i prototipi delle funzioni che si trovano in mio_header.ccp, e in quest'ultimo file scrivi le implementazioni delle funzioni che hai dichiarato nell'header.

[Salvatore_91]

ti ringrazio, ma sto impazzendo non sto capendo niente.

Cmq questo e il mio programma, non e' che potresti dividermelo tu??
SPecificando il codice da inserire in tutti e tre i file??
Ad esempio in Main.cpp, mi dici cosa scrivere

codice

In mio_header.h

codice

mio_header.cpp

codice

Ecco tutto il mio codice:

# include <iostream>
# include <stdio.h>
# include <fstream>
# include <string>
# include <sstream> 

using namespace std;

int ID;

class File
{

 public:
	void ApriFileInScrittura(string NomeFile, std::ios_base::openmode metodo)
	{
		ofstream write(NomeFile.c_str(), metodo); 
	}   
/************************************FINE**************************************/    
    void GeneraID(string NomeFile) 
    {
     ifstream trovaID("ID.txt", ios::in); //ID.txt file contentente il numero                                     // dell'ultimo ID inserito
     if (trovaID)
              {
               trovaID >> ID;
               ID=ID+1;
               trovaID.close();
              } 
              else
              ID=1; 
                 
     ofstream write(NomeFile.c_str(),ios::app); 
     write <<"L;";   /* Imposta FLAG per la CANCELLAZIONE LOGICA*/

///////////////////////////// 
     stringstream s;      //   
     string ss;          //          
     s << ID ;          //
     ss = s.str();     // /* Dimesione dell' ID = 5
     ss.resize(5);    //  dato che ss.resize(5); */
     write <<ss;     //
//////////////////////  
     write.close();
  
  // Aggiorna L'ID che viene scritto sul file ID.txt
     ofstream aggID("ID.txt", ios::out);  
     aggID << ID;    
     aggID.close();                    
    } 
/************************************FINE**************************************/    
    void ScriviCampo(string NomeFile, string Campo, int DimCampo)
    {
     ofstream write(NomeFile.c_str(),ios::app);
     Campo.resize(DimCampo);
     write << Campo;
     write.close();    
    }
/************************************FINE**************************************/    
    void ScriviUltimoCampo(string NomeFile, string Campo, int DimCampo)
    {
     ofstream write(NomeFile.c_str(),ios::app);
     Campo.resize(DimCampo);
     write << Campo << endl;
     write.close();    
    } 
};

    File A1;
    A1.ApriFileInScrittura("PROVA.txt", ios::app);
    A1.GeneraID("PROVA.txt");  
    A1.ScriviCampo("PROVA.txt", "Salvatore", 20);
    A1.ScriviCampo("PROVA.txt", "Ciotola", 20);
    A1.ScriviUltimoCampo("PROVA.txt", "UltimoCampo", 20);
    getchar();
    getchar();

[sebaldar]

il main.cpp potrebbe essere così

#include "mio_header.h"

int main()
{
    File A1;
    A1.ApriFileInScrittura("PROVA.txt", ios::app);
    A1.GeneraID("PROVA.txt");  
    A1.ScriviCampo("PROVA.txt", "Salvatore", 20);
    A1.ScriviCampo("PROVA.txt", "Ciotola", 20);
    A1.ScriviUltimoCampo("PROVA.txt", "UltimoCampo", 20);
    
    getchar();
    getchar();

      return ( 0 ) ; 
}