ho diviso in 2 il programma un file .h e un .c

il File asf_file.c è

codice:
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#include <assert.h>
#include "asf_file.h"

static void MVWelcome (){
	printf ("CompileDate: %s;\n", __DATE__);
	printf ("CompileTime: %s;\n", __TIME__);
	
}

int main () 
	{
		int aFCloseResult = 0; // serve per la chiusura del file sorgente
		int sRead =0; // serve per spostra il puntatore all'interno del file sul inizio del carattere da dove si vuole iniziare a copiare
		int retValue = 0; //valore di ritorno del main
		int count =5; // serve per contare la dimensione per l'array di chart - parte da 5 perchè incremeto solo se trovo la stringa "<?xml"
		MVWelcome ();
		FILE * fp = fopen("Prova.tar","rb"); // apre il file sorgente
		
		if(NULL != fp) // controllo se il file è aperto in modo corretto
		{ 
			int aOffset=SaveAllChar(fp , count); // Funzione dichiarata su asf_file.h 
			sRead=fseek(fp, aOffset-5, SEEK_SET); // sposto il puntatore all'inizio del carattere "<"
			SavedChar(sRead , count , fp); // funzione esterna si asf_file.h salva i caratteri che devo copiare
			aFCloseResult  = fclose(fp); // chiudo il file sorgente
		 	fp = NULL;
		} 
		else // in caso di errori all'apertura del file sorgente ...
		{	
			printf ("Error: %d; %s;\n", errno, strerror (errno)); // ... blocco tutto e stanpo in console l'errore
			retValue = 1; 
		}
 		return retValue;
	}
e il file asf_file.h



codice:
#ifndef asf_file_h
#define asf_file_h

#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#include <assert.h>
#include "asf_file.h"

typedef enum
	{  // definisco gli stati che mi porteranno a iniziare la copia del file
		eStatusNothing = 0,
		eStatusPapabile_1,
		eStatusPapabile_2,
		eStatusPapabile_3,
		eStatusPapabile_4,
		eStatusPapabile_5
		
	} EStatus;

// Prototipi delle funzione contenute nel file 
void WriteCharSaved(int count , char * aBufferToWrite);
EStatus ControllerEStatusPapabile(char aChar);
void SavedChar(int sRead , int count , FILE * fp);
int SaveAllChar(FILE * fp , int count);
// Fine proptotipi 


 // INIZIO FUNZIONE WriteCharSaved 

void WriteCharSaved(int count , char * aBufferToWrite)
	{ // scrivo sul file di destinazione i caratteri che ho salvato 
		int aFCloseResult1 = 0; // serve per la chiusura del file di destinazione
		FILE * fp1 = fopen("new.tar","w+b"); // apre il file di destinazione in scrittura binaria
		if (NULL != fp1)// controllo che sia aperto bene
		{
			// inizio a scrivere su file di destinazione
			const int aWriteReesult = fwrite(aBufferToWrite ,sizeof (char),count ,fp1); 
			if (aWriteReesult == count) // se ho scritto tutti i valori
			{
				printf ("File salvato con successo !!!! ;\n");
			}
			
		aFCloseResult1 = fclose(fp1); // chiudo il file di destinazione
		fp1 = NULL;
		}
	}
	
	
 // INIZIO SECONDA FUNZIONE ControllerEStatusPapabile() 
	
EStatus ControllerEStatusPapabile(char aChar)
{	
	EStatus s = eStatusNothing; // inizializzo lo stato 
	
	switch (aChar) // inizio a controllare gli stati in base alle informazioni lette fin ora
		{
			case '<' :  { s=eStatusPapabile_1; }
				break;
			case '?' : 
				{
					if (eStatusPapabile_1 == s)
						 { s = eStatusPapabile_2; }
					else { s = eStatusNothing; }
				}
				break;
			case 'x' :
				{
					if (eStatusPapabile_2 == s)
						{ s = eStatusPapabile_3; }
					else{ s = eStatusNothing; }
				}
				break;
			case 'm' :
				{
					if (eStatusPapabile_3 == s)
						{ s = eStatusPapabile_4; }
					else{ s = eStatusNothing; }
				}
				break;
			case 'l' :
				{
					if (eStatusPapabile_4 == s)
						 { s = eStatusPapabile_5; } // ho trovato la stringa che cercavo "<?xml"				
					else { s = eStatusNothing; }
				}
				break;
			default: s = eStatusNothing;
				break;
		}  // fine switch (aChar)
		
		return s;
}


 // INIZIO TERZA FUNZIONE void SavedChar(int sRead); 

void SavedChar(int sRead , int count , FILE * fp)
{
	int ReadChar =0;  // serve per leggere il file sorgente dal punto in cui iniziao i caratteri da copiare
	
	if (-1 == sRead ) // controllo che non ci siano valori sbagliati
	{
		printf("errno %d: %s" , errno,strerror (errno));
	}
	else 
	{
		char * aBufferToWrite = (char *) malloc (sizeof (char) * count); // mi riservo la memoria per inserire i caratteri da copiare
		if (NULL != aBufferToWrite)
		{
			memset (aBufferToWrite, 0, sizeof (char) * count); // pulisco la zona di memoria che utilizzo per copiare il file
			
			int i = 0;
			while (EOF != (ReadChar = fgetc (fp))) // inizio a leggere solo i caratteri che devo copiare
				{
					aBufferToWrite [i] = ReadChar;	// salvo i caratteri che mi servono
					++i;
					//printf ("%c", ReadChar);
				}
			printf ("buffer begin: %s\n", aBufferToWrite);
			printf ("buffer end;\n");

			WriteCharSaved(count , aBufferToWrite); 
			
		}
			free (aBufferToWrite); // libero la memoria 
			aBufferToWrite = NULL; // che ho allocato prima
	}

}

 // INIZIO QUARTA FUNZIONE SaveAllChar(FILE * fp) 

int SaveAllChar(FILE * fp , int count)
{
	int aChar = 0;  // serve per il leggere il file sorgente
	int aOffset = 0; // serve per settare il punto di inizio per la copia (il valore sono tutti i caratteri da scartare)
	EStatus s = eStatusNothing; // inizializzo lo stato
	int i = 0;
	char aBuffer [1024 * 1024]; // mi riservo 1MB di memoria 
	memset(aBuffer, 0, sizeof (aBuffer)); // pulisco la zona di memoria che utilizzo per analizzare il file
	 
		while (EOF != (aChar = fgetc (fp)))
		{  // inizio lettura di tutto il file 
				aBuffer [i] = aChar; // memorizzo tutti i caratteri letti
				++i;
				printf ("%c", isprint (aChar)? aChar: ('\n' == aChar?'\n':'.')); // stampo quello che sto leggendo a console
				
				if (eStatusPapabile_5 != s)
				{ // se mi trovo in stato 5 allora non serve il controllo degli stati
					++aOffset;
					ControllerEStatusPapabile(aChar);
				} // fine if (eStatusPapabile_5 != s)
				else
				{
					++count; // raggiungiamo lo stato papabile 5 allora conto da ora in poi il numero di caratteri in più a i primi 5
				}
				
		}  
		
	printf ("\n"); 
	printf ("aOffset: %d;\n", aOffset - 5); // stampo i valori che
	printf ("count: %d;\n", count);		   //  ho trovato a console
	
	return aOffset;
}

#endif


Per trasformare tutto in C++ volevo creare una classe dentro il file .h e far diventare le funzioni dei metodi.

Ma mi è stato detto che esistono già delle funzioni standard del C++ che fanno la stessa cosa delle mie ma la fanno meglio e di usare quelle senza crearne di nuove.

Ora vorrei sapere quali sono e come si usano.


Grazie