Questo sito utilizza cookies solo per scopi di autenticazione sul sito e nient'altro. Nessuna informazione personale viene tracciata. Leggi l'informativa sui cookies.
Username: Password: oppure
Console File Splitter v0.2 - splitter.cpp

splitter.cpp

Caricato da:
Scarica il programma completo

  1. /*
  2. Console File Splitter v 0.2
  3.  
  4. Divide i file in più parti e all'occorrenza li ricompone.
  5. Utile per qualsiasi esigenza di spazio.
  6.  
  7. Autore:             __GiReX__
  8. Linguaggio:         C++
  9. Sistema operativo:  Qualsiasi
  10. Data:               26/11/07 20.47
  11.  
  12. Sito:               http://girex.altervusta.org/
  13. */
  14.  
  15. #include <iostream>
  16. #include <fstream>
  17. #include <cstring>
  18. #include <ctime>
  19. #include <cmath>
  20. #define SPLIT_SUCCESS 0
  21. #define MERGE_SUCCESS 4
  22. using namespace std;
  23.  
  24. void usage(char *prog);
  25. int split(char *nome_file, int parti);
  26. int merge(char *nome_file, int parti);
  27. int name_part(int n_part, char *nome_file, char *tmp);
  28.  
  29. int main(int argc, char *argv[])
  30. {
  31.   int parti, error;
  32.   clock_t sec;
  33.    char *nome_file = NULL;
  34.    
  35.     if(argc < 3 || argc > 4) {
  36.         usage(argv[0]);
  37.         return 1;
  38.     }
  39.    
  40.     if(argc == 4 && strcmp(argv[1], "-r")) {
  41.         cout << "\n\"" << argv[1] << "\" Parametro non riconosciuto!\n\n";  
  42.             usage(argv[0]);
  43.         return 2;
  44.     }                        
  45.  
  46.     if(argc == 3) {
  47.         nome_file = argv[1];
  48.           parti = atoi(argv[2]);  
  49.         error = split(nome_file, parti);                 // Splitto  
  50.    } else {
  51.         nome_file = argv[2];
  52.           parti = atoi(argv[3]);
  53.         error = merge(nome_file, parti);                 // Mergo
  54. }
  55.    sec = clock() / CLOCKS_PER_SEC;
  56.  
  57.       switch(error) {
  58.           case SPLIT_SUCCESS:
  59.                 cout << "Il file e' stato diviso in " << parti << " parti con successo!\n\n"
  60.                      << "Tempo impiegato: " << sec << " sec\n";                
  61.                 break;
  62.           case 1:
  63.                 cout << "Errore nell'apertura del file!\n\n"
  64.                      << "Controllare che il nome o percorso siano corretti!\n";
  65.                 break;
  66.           case 2:
  67.                 cout << "Errore: Numero di parti troppo elevato!\n";
  68.                 break;
  69.           case 3:
  70.                 cout << "Errore nella creazione dei file part!\n";
  71.                 break;
  72.           case -1:
  73.                 cout << "Errore nella creazione del file di destinazione!\n\n"
  74.                      << "Controllare che il file originale non risieda nella stessa cartella!";
  75.                 break;
  76.           case -2:
  77.                 cout << "Impossibile aprire i file part!\n\n"
  78.                      << "Controllare che il nome del file corrisponda al nome del file originario\n"
  79.                      << "e che il numero di parti dichiarato corrisponda!\n";
  80.                 break;
  81.           case MERGE_SUCCESS:
  82.                 cout << "Il file e' stato ricomposto con successo!\n\n"
  83.                      << "Tempo impiegato: " << sec << " sec\n";
  84.                 break;
  85.           default:
  86.                 cout << "Errore sconosciuto!\n";
  87.           }
  88.      
  89.  
  90.       cout << "\nPremere un tasto per uscire...\n";    
  91.     cin.ignore();
  92.  return 0;
  93. }
  94.    
  95. int name_part(int n_part, char *nome_file, char *tmp)
  96. {  
  97.   char buff[4] = {0};
  98.      
  99.    strcpy(tmp, nome_file);
  100.    strcat(tmp, ".part_");
  101.    strcat(tmp, itoa(n_part, buff, 10));      // Funzione per convertire int to char*
  102.  
  103.    return 0;
  104. }
  105.  
  106. int split(char *nome_file, int parti)
  107. {
  108.   ifstream *file = new ifstream(nome_file,ios::binary);// Apro file in modalità binaria
  109.   ofstream *file_part = new ofstream;  
  110.  
  111.    long double size, byte_file, last_file_size;        // Byte del file, e byte per ogni file
  112.    char nome_file_part[80] = {0};                      // Nome dei file part
  113.    
  114.     if(!file)   return 1;    
  115.        
  116.    file->seekg(0, ios::end);
  117.       size = file->tellg();                                    // Prendo lunghezza file
  118.         cout << "\nFile di: " << size << " byte" << endl;
  119.           if(size < parti*2 || parti > 30) return 2;
  120.       file->seekg(0, ios::beg);                                // Risposto il cursore all'inizio del file
  121.      byte_file = ceil(size / parti);                          // Byte per ogni file part arrotondati per eccesso
  122.    last_file_size = (size - (byte_file*parti)) + byte_file;   // Byte dell'ultimo file che differisce dagli altri
  123.  
  124.   cout << "Splitting in corso...\n";
  125.    
  126.    for(int i = 0; i < parti; i++) {
  127.    
  128.    name_part(i, nome_file, nome_file_part);              // Prendo nome dei file part
  129.    
  130.       file_part->open(nome_file_part, ios::binary);       // Apro i file in modalità binaria
  131.      
  132.       if(!file_part) return 3;
  133.    
  134.      
  135.       if( i == (parti - 1)) {                                   // Se è l'ultimo file..
  136.            for(register int i2 = 0; i2 < last_file_size; i2++)
  137.                   file_part->put(file->get());
  138.     } else {
  139.            for(register int i2 = 0; i2 < byte_file; i2++)
  140.                   file_part->put(file->get());                    // Un byte alla volta copio n byte per file nel file part
  141.            }
  142.            
  143.      file_part->close();
  144.    }
  145.    file->close();
  146.  return SPLIT_SUCCESS;
  147. }
  148.  
  149. int merge(char *nome_file, int parti)
  150. {
  151.   char bit, nome_part[80] = {0};
  152.    ofstream *file = new ofstream(nome_file, ios::binary);
  153.    ifstream *file_part = new ifstream;
  154.    
  155.     if(!file) return -1;
  156.  
  157.     cout << "\nRicomponimento (merge) in corso...\n";    
  158.    
  159.      for(int i = 0; i < parti; i++) {
  160.       name_part(i, nome_file, nome_part);                             // Prendo il nome dei file part
  161.        file_part->open(nome_part, ios::binary);                        // Apro i file part
  162.        
  163.        if(!file_part)  return -2;
  164.  
  165.         while(!file_part->eof())     {                                 // Se npn è un eofbit lo copio nel file
  166.              file_part->get(bit);
  167.         if(!(file_part->rdstate() & ifstream::eofbit)) file->put(bit);  // Copio i file part nel file di destinazione
  168.      }
  169.      
  170.          file_part->clear();
  171.       file_part->close();                                              // Chiudo file part
  172. }
  173.    
  174.     file->close();
  175.  return MERGE_SUCCESS;
  176. }
  177.  
  178. void usage(char *prog)
  179. {
  180.      cout << "Usage:\n\n"
  181.           << "Per dividere: " << prog << " <file_da_dividere> <numero_parti>\n\n"
  182.           << "Per ricomporre: " << prog << " -r <file_origine> <numero_parti>\n\n"
  183.           << "Dove <file_origine> e' il nome del file che e' stato diviso\n"
  184.           << "e <numero_parti> le parti in cui e' stato diviso!\n";
  185. }