Προγραμμα Διαχείρισης Καταλόγου

• Προδιαγραφές Προγράμματος
• Χτίζοντας από το γενικό προς την λεπτομέρεια
• Ανάλυση του κώδικα της main
• Ανάλυση του κώδικα της MenuSelection
• Η συνάρτηση TimeString
• Η συνάρτηση AppendLine
• Η συνάρτηση PrintLines
• Η συνάρτηση ReplaceLine
• Η συνάρτηση ShowLine
• Η συνάρτηση NewWordSearch
• Η συνάρτηση OldWordSearch
• Η συνάρτηση DeleteLine
• Η κλάση string
• Οι κλάσεις fstream, ifstream, ofstream
• Παρατηρήσεις
• Ο κώδικας όλου του προγράμματος
• Λήψη εκτελέσιμου αρχείου (75Kb)

Προδιαγραφές Προγράμματος

1. Να κατασκευάσω ένα πρόγραμμα που διαχειρίζεται ένα αρχείο κειμένου.
2. Να δείχνει στον χρήστη ένα μενού από το οποίο αυτός θα επιλέγει εργασίες.
3. Το κείμενο θα αποτελείται από γραμμές σταθερού πλήθους χαρακτήρων Ν.
4. Αν η γραμμή έχει λιγότερους χαρακτήρες, θα συμπληρώνω με κενά μέχρι το Ν.
5. Σε κάθε γραμμή θα καταχωρώ πληροφορία π.χ. ονομα + τηλέφωνο(α).
6. Το πρόγραμμα μπορεί να τυπώνει όλες τις γραμμές στην οθόνη.
7. Μπορεί να τυπώνει μόνο την ν-στή γραμμή.
8. Μπορεί να βρίσκει τις γραμμές που περιέχουν μία λέξη ή αριθμό που δίδω.
9. Μπορεί να αφαιρεί μιά γραμμή από το αρχειο.
10. Μπορεί να αλλάζει το περιεχόμενο της ν-στης γραμμής.
11. Μπορεί να προσθέτει νέες γραμμές με δεδομένα.
12. Να προσθέτει στο τέλος της γραμμής αυτόματα την ημερομηνία καταχώρησής της.

Τεχνικές Προδιαγραφές

• Το πρόγραμμα θα υλοποιήται με την βοήθεια μιάς κλάσης LineFile
• Θα χρησιμοποιεί βασικές κλάσεις της C++: fstream, ifstream, ofstream και string
• Οι διάφορες εργασίες θα εκτελούνται με συναρτήσεις-μέλη της LineFile
• Ολες οι μεταβλητές της κλάσης θα είναι private
• Εισαγωγή-εξαγωγή κειμένου θα γίνεται με μιά μεταβλητή line 1024 χαρακτήρων
• Η κλάση θα έχει ειδικές μεταβλητές που διευκολύνουν το ψάξιμο γιά λέξη

Χτίζοντας από το γενικό προς την λεπτομέρεια

Η συνάρτηση main θα ορίζει την μεταβλητή τύπου LineFile με την οποία γίνεται όλη η δουλειά. Κατόπιν θα κατανέμει την κάθε επιλογή του χρήστη σε μία κατάλληλη συνάρτηση-μέλος της κλάσης η οποία θα αναλαμβάνει την διεκπεραίωση της επιλογής του χρήστη. Μετά την διεκπεραίωση της εργασίας, θα επανεμφανίζεται το μενού επιλογής. Τέλος της εργασίας του προγράμματος θα γίνεται με πληκτρολόγιση του γράμματος q. Οι άλλες επιλογές θα αντιστοιχούν σε άλλα γράμματα. Η μορφή της main να είναι η εξής:

int main(int argc, char* argv[])
{
   LineFile  lf("kat.txt");
   lf.TimeString();
   char ch(1);
   while( ch != 'q' )
   {
      ch = lf.MenuSelection();
      switch(ch)
      {
      case  'a':
         lf.AppendLine();
         break;
      case  'd':
         lf.DeleteLine();
         break;
      case  'p':
         lf.PrintLines();
         break;
      case  'r':
         lf.ReplaceLine();
         break;
      case  's':
         lf.ShowLine();
         break;
      case  'f':
         lf.NewWordSearch();
         break;
      case  'g':
         lf.OldWordSearch();
         break;
      case  'q':   //exit
         break;
      default:
         cout << "Error, please type only one of: a, d, p, r, s, f, g and q = quit" << endl;
         break;
      }
   }
}

Ανάλυση του κώδικα της main

LineFile  lf("kat.txt");

lf.TimeString();
lf.MenuSelection();
lf.AppendLine();
lf.DeleteLine();
lf.PrintLines();
lf.ReplaceLine();
lf.ShowLine();
lf.NewWordSearch();
lf.OldWordSearch();

 
ch = lf.MenuSelection();
switch(ch)
{
  case  'a':
............
  case  'g':
      lf.OldWordSearch();
    break;
  case  'q':   //exit
    break;
  default:
      cout << "Error ...
    break;
}
 

Ανάλυση του κώδικα της MenuSelection

char   LineFile::MenuSelection()
{
   WriteMessage("<MENU>\n AddLine (a)  , DeleteLine (d) , PrintLines (p) , ReplaceLine (r)");
   WriteMessage(" ShowLine (s) , WordSearch (f) , AgainSearch (g) , Quit (q)");
   WriteMessage("</MENU>");
   cin.getline(line,MXCH); // eat all the line but use only  1st char
   if( GetLineLength() >10 )  // append !! *** user forgot to press a before !!
   {
      AppendLineEndFile();
   }
   return line[0];
}

   int    LineFile::GetLineLength() { return strlen(line);}

void  LineFile::WriteMessage( char* mess )
{
   cout << mess << endl;
}

void LineFile::AppendLineEndFile()
{
   fstream  kata(fName, ios::app);      // open to append 
   WriteLine( kata );
   kata.close();
}

void LineFile::WriteLine( fstream & kata )
{
   kata << line <<  setw(MAIN_LINE_WIDTH-GetLineLength())  << myTime
                 << setw(MARGIN) << "**\n";
}

if( GetLineLength() >10 )  // append !! *** user forgot to press a before !!
{
  AppendLineEndFile();
}

Βλέπουμε εδώ ένα χαρακτηριστικό στιγμιότυπο της ιεραρχίας των συναρτήσεων. Κάθε μιά τους διασπά την δουλειά σε άλλες μικρότερες (διαίρει και βασίλευε) και τις παραπέμπει σε άλλες συναρτήσεις οι οποίες με την σειρά τους διασπούν την δουλειά τους σε άλλες κ.ο.κ. Το πράγμα θυμίζει την υπαλληλική ιεραρχεία, στην οποία ο διευθυντής αναθέτει στους υποδιευθυντές, αυτοί στους τμηματάρχες κτλ. κτλ. μέχρι να φτάσει η δουλειά κάτω-κάτω στους τελευταίους υπαλλήλους, που ο καθένας τους κάνει μιά εντελώς συγκεκριμένη και περιορισμένη εργασία.

Η συνάρτηση TimeString

void LineFile::TimeString()
{
    time_t long_time;      // get time is seconds
    time( &long_time );

    struct tm *newtime;    // to format time-info
    newtime = localtime( &long_time ); // transform to date

   sprintf(myTime, "%2d/%2d/%2d ", newtime->tm_mday ,
                           newtime->tm_mon+1,
                           newtime->tm_year-100 );
}

Η συνάρτηση AppendLine

void LineFile::AppendLine( )
{
   WriteMessage( "write a line") ;     // WARNING check length ?????
   cin.getline(line,MXCH);          // get line from cin
   AppendLineEndFile();
}

Η συνάρτηση PrintLines

void LineFile::PrintLines()
{
   int n(0);
   WriteMessage("-----------");
   ifstream kata;             // open file to read from
   kata.open(fName);
   while( kata.getline( line, MXCH ) )
   {
      cout << line << endl;
      n++;
   }
   WriteMessage("-----------");
   cout << n << " lines in " << fName << endl;
}

Η συνάρτηση ReplaceLine

void LineFile::ReplaceLine(  )
{
   int n = AcceptDelete();       // ask user etc...
   if(n == 0) return;            // user canceled
   WriteMessage("Write new line");
   cin.getline(line,MXCH);       // get line from user
   fstream kata;
   OpenSeekLine(kata, n, false );   // false = to write
   WriteLine( kata );
   kata.close();
}

   OpenSeekLine(kata, n, false );   // false = to write

void LineFile::OpenSeekLine( fstream & kata, int count, bool toRead /*true*/ )
{
   fstream::pos_type pos((count-1)*TOTAL_WIDTH);
   kata.open(fName, ios::in | ios::out  );  // WARNING errors ??
   if(toRead) kata.seekg(pos);
   else kata.seekp(pos);
}

int  LineFile::GetAnInteger()
{
   int N = NumOfLines();
   cout << "Give an integer  0 < n <= " << N << endl;
   cin.getline(line,MXCH);
   int n = atoi(line);           // transform to int
   if( (n<=N) && ( n > 0) ) return n; // normal case
   else if( n <=0 ) return 1;   // if <0 replace by  1
   else return N;          // if > N replace by  N
}

int LineFile::NumOfLines()
{
   fstream kata(fName, ios::binary  | ios_base::in );
   kata.seekg(0,ios_base::end);     // set ptr to end of file
   int  n ( kata.tellg()/TOTAL_WIDTH); // this is the total line-nr
   kata.close();
   return n;
}

Η συνάρτηση ShowLine

void LineFile::ShowLine( )
{
   int n = GetAnInteger();
   GetThisLine(n);
   DisplayNrCommentLine( n , "-line is:" );
}

void  LineFile::GetThisLine( int count )
{
   fstream kata;
   OpenSeekLine(kata, count);
   kata.getline( line, MXCH );
   kata.close();
}

void LineFile::DisplayNrCommentLine( int n, char* comment )
{
   WriteMessage("-----------");
   cout << n << comment << endl <<line << endl;
   WriteMessage("-----------");
}

Η συνάρτηση NewWordSearch

void  LineFile::NewWordSearch()
{
   wordFound=false;                 // not found yet
   wordLineStart=1;                 // line to start search
   if( GetWordSearchFor( wordSearch ) )   // is a real word ??
   {
      int lineFound = FindLineWord( wordSearch , wordLineStart);
      if( lineFound >-1 )              // if some line found
      {
         wordFound = true;          // prepare for next search
         ShowLineFound( lineFound );
      }
      else //nothing found
         cout << "passed end of file" << endl;  // inform user that no other line ...
   }
   else
      cout << "no word to search for" << endl;
}

bool LineFile::GetWordSearchFor( string &  str )
{
   static  char seps[]   = " ,\t\n";

   WriteMessage(" Give a word to search for:");
   cin.getline( line, MXCH );       // get a line from user 
   if(strlen(line)==0) return false;   // nothing to search for
   else
    str = strtok( line, seps );        // its first word (token)
   return true;
}

int LineFile::FindLineWord( string & word , int lineToStart)
{
   fstream kata;
   OpenSeekLine( kata, lineToStart );  // open and go to start of <lineToStart>
   int n(lineToStart);
   int result;
   while( kata.getline( line, MXCH ) )  // read line from file
   {
      result = (int)WordInLine( word ) ;         // test if word there
      if( result > -1 ){ kata.close(); return n;}
      n++;
   }
   kata.close();
   return -1;
}

Η συνάρτηση OldWordSearch

void  LineFile::OldWordSearch()
{
   if( wordFound )               // something has been found previously
   {
      int lineFound;
      if( !(wordLineStart<NumOfLines()) ||
         (lineFound = FindLineWord( wordSearch , wordLineStart+1)) == -1 )
      {
         cout << "passed end of file" << endl;  // nothing new found 
         wordLineStart = 1;                  // to restart search
      }
      else
      {
         ShowLineFound( lineFound );
      }
   }
   else
      NewWordSearch();  // start a new search
}

Η συνάρτηση DeleteLine

void LineFile::DeleteLine( )
{
   unsigned int n = (unsigned int)AcceptDelete();  // ask user etc...
   if(n == 0 ) return ;        // user canceled ... do nothing

   unsigned int    N       = NumOfLines();   // find total lines
   unsigned int   totpos      = (N-1)*TOTAL_WIDTH; // size after deletion
   unsigned int   beforeSize  = (n-1)*TOTAL_WIDTH; // size before line
   unsigned int   afterSize   = totpos-beforeSize; // size after line

   char *  pch  = new char[ totpos ];      // to receive the new text
   if(n>1)                          // if not first line delete
      PutInBuffer( pch, 0, beforeSize );   // store upper part to buffer
   if(n != N)                       // i.e. if not last line to delete
      PutInBuffer( pch+beforeSize, n*TOTAL_WIDTH,  afterSize );
                                // store lower part to buffer
   OverideFileWithBuffer( pch, totpos ); // write back buffer to file
   delete[] pch;                   // WARNING  memory ???
}

void LineFile::PutInBuffer( char* pch, unsigned int offset, unsigned int size )
{
   fstream kata(fName, ios::binary | ios_base::out | ios_base::in );
   kata.seekg(offset);        // start here reading from file
   kata.read( pch, size );    // ... put <size> bytes in pch
   kata.close();
}

void LineFile::OverideFileWithBuffer( char * pch, unsigned int size )
{
   ofstream  kata(fName, ios::binary | ios_base::trunc );
   kata.write( pch, size );
   kata.close();
}

   char *  pch  = new char[ totpos ];      
   delete[] pch;

Η κλάση string

  string  a, b, c, d;
  a = "Omiros";
  b = "Platon";
  c = a;
  int n = a.length(); // το n = 6 (πλήθος χαρακτήρων)
  char    myText[20];
  string  myString(myText);  // στο myString αποδίδεται το περιεχόμενο του myText

  //Στην επόμενη εντολή δημιουργήται πάλι ένα string και αποδίδεται και περιεχόμενο.
  string  myBigString("to be or not to be, that is the question!");

  string  mySmall("to");
  int n = myBigString.find( mySmall );  // ψάχνει να βρει το mySmall στο myBigString
										//επιστρέφει -1 αν δεν το βρει
  bool  what  = mySmall.empty() );  // επιστρέφει true αν το string  ειναι άδειο (χωρις κείμενο)
  char  ch    = myBigString[11]; // το 11-το γράμμα του
  const char*  string::data();  // μιά συνάρτηση της κλάσης που επιστρέφει την διεύθυνση 
				// του πρώτου χαρακτήρα από τον ορμαθό χαρακτήρων που περιέχει η string.
  string  a, b, c;
  a += b;   // αυτή επεκτείνει το a , προσθέτοντας στο τέλος του  όλους τους χαρακτήρες του b
  a += "some text"; // ανάλογα προς την προηγούμενη
  a = b + c; // το a περιέχει την συνένωση των χαρακτήρων των δύο ορμαθών

Οι κλάσεις fstream, ifstream, ofstream

  fstream   kata ;	//  ρεύμα ανάγνωσης+εγγραφής χαρακτήρων
  ifstream ikata;	// ρεύμα ανάγνωσης χαρακτήρων
  ofstream okata;	// ρεύμα εγγραφής χαρακτήρων

  kata.open(fName, ios::app);	    // σύνδεση ρεύματος με το αρχείο με όνομα fName
								 // προς εγγραφή στο τέλος του αρχείου, ισοδύναμα:
  fstream kata(fName, ios::app); // ισοδύναμη προς προηγούμενη εντολή
  ofstream kata(fName, ios::app);// ισοδύναμη προς προηγούμενη εντολή
  // οι δύο τελευταίες είναι constructors των αντιστοίχων κλάσεων και ανοίγουν το αντίστοιχο
  // αρχείο αμέσως μετά την κατασκευή του αντικειμένου
  
  // η γνωστή μας κονσόλα cout είναι μιά ειδική ostream 
  // (σαν την ofstream χωρίς σύνδεση με αρχείο)
  // η γνωστή μας κονσόλα cin είναι μιά ειδική istream
  
  ikata.getline( buffer, length ); // inctl μπορεί να είναι ifstream ή fstream
  // buffer είναι διάνυσμα χαρακτήρων (char* ...) και length ο μέγιστος αριθμός
  // χαρακτήρων προς ανάγνωση

  okata << myString;  // okata είναι fstream ή ofstream
  okata << buffer;
  cout << "my name";    // ..οπως ήδη συναντήσαμε

  ofstream  kata(fName, ios::binary | ios_base::trunc );
  // σύνδεση με αρχείο fName για εγγραφή δυαδικών δεδομένων (ios::binary)
  // ενδεχόμενα περιεχόμενα του  αρχείου διαγράφονται (ios_base::trunc)
  kata.write( buffer, length  ); // εγγραφή δυαδικών δεδομένων (bytes) απο το buffer
  kata.read( buffer, length );	//  ανάγνωση από το kata στο buffer length bytes
  kata.close();					// κλείσιμο αρχείου
  kata.seekg(pos);  // τοποθέτηση δείκτη ανάγνωσης (από που ξεκινά επόμενη ανάγνωση)
  kata.seekp(pos);  // τοποθέτηση δείκτη εγγραφής (από που ξεκινά επόμενη εγγραφή)
					// η πρώτη εντολή μόνο για fstream και ifstream
					//  η δεύτερη μόνο γιά fstream και ofstream
  kata.seekg( position, ios_base::end);	//τοποθέτηση δείκτη ανάγνωσης στην θέση position
										// μετρώντας από το τέλος του αρχείου 
  totpos = kata.tellg(); // λήψη του δείκτη ανάγνωσης (που αρχίζει επόμενη ανάγνωση) 
  totpos = kata.tellp(); // λήψη του δείκτη εγγραφής  
  // μπορούμε να χρησιμοποιούμε τους τελεστές << και >> γιά όλους τους στανταρτ τύπους 
  // μεταβλητών :
  int  a;
  char b;
  unsigned int c;
  double  dbl;
  float   flt;
  okata  << a << b << c << dbl << flt << endl;
  ikata  >> a >> b >> c >> dbl >> flt ;
	// όλα αυτά είναι flags, συμβολικοί ακέραιοι που  καθορίζουν ιδιότητες των streams
  ios::app		// καθορίζει ότι θα γίνει καταχώρηση στο τέλος αρχείου
  ios::in       // ότι το αρχείο είναι γιά εγγραφή
  ios::out      // ότι το αρχείο είναι γιά ανάγνωση
  ios::trunc    // ότι θα διαγραφούν τα παλιά και θα εγγραφούν νέα δεδομένα
  ios::binary   // ότι θα γίνει διαχείριση bytes και όχι χαρακτήρων (κειμένου)
  // ορισμένες απ' αυτές μπορούν να συνδιασθούν με το λογικό |:
  (ios::in | ios:: out | ios::binary)  // ...διαχείριση bytes για εγγραφή + ανάγνωση

Παρατηρήσεις

• Το πρόγραμμα στην παρούσα μορφή του λειτουργεί σωστά και με σχετική ευστάθεια. Χρειάζεται ωστόσο πολλές βελτιώσεις. Π.χ. την εξέταση σφαλμάτων κατά το άνοιγμα κλείσιμο αρχείων.
• Στο σημείο που ζητάμε μνήμη από τον σωρό (χώρος ελεύθερης μνήμης) πρέπει, πρίν χρησιμοποιήσουμε αυτά που ζητήσαμε, να δούμε αν πήραμε ακριβώς την μνήμη που θέλαμε.
• H C++ έχει δικό της μηχανισμό διαχείρισης σφαλμάτων, που υλοποιήται πάλι με κλάσεις ονομαζόμενες exceptions.
• Το πρόγραμμα δεν είναι αρκετά αντικειμενοστραφές. Η χρήση κλάσεων είναι υποτυπώδης. Αποτελεί ωστόσο μιά βάση στην οποία μπορούμε να δουλέψουμε. Ενας καλύτερος σχεδιασμός θα περιελάμβανε τρείς κλάσεις: Μιά για την οθόνη, μιά για το αρχείο και μία γιά τον μεσολαβητή που πάει δεδομένα από την οθόνη στο αρχείο και τούμπαλιν.
• Χρειάζεται μιά λεπτομερέστερη και πιό αφηρημένη διαδικασία κατακερματισμού των εργασιών σε επι μέρους συναρτήσεις. Μπορεί να αναπτυχθεί πρώτα ένα είδος ψευδοπρογράμματος το οποίο να γεμίσει αργότερα με πραγματικό κώδικα. Π.χ.

  char   LineFile::MenuSelection()
  {
     ΓράψεΜήνυμαΟθόνη();
     ΠάρεΚείμενοΑποΧρήστη();
     ΚάνεΕλεγχοΤιΕγραψε();
     ΕπίστρεψεΠρώτοΧαρακτήρα();
  }
  

  ανάλογη ανάλυση όλων των κυρίων συναρτήσεων θα προσδιορίσει τις δευτερεύουσες π.χ.

  void LineFile::DeleteLine( )
  {
  	ΠάρεΑριθμόΓραμμήςΑπόΧρήστη();
  	ΠαρουσίασεΓραμμήΠροςΑφαίρεση();
  	ΠάρεΒεβαίωσηΓιαΣβύσιμο();
  	ΔιαδικασίαΣβυσίματοςΓραμμής(ν);
  }
  void LineFile::ΔιαδικασίαΣβυσίματοςΓραμμής(ν)
  {
  	ΒρεςΜεροςΑρχειουΠρινΓραμμη(ν);
  	ΒρεςΜέροςΑρχειουΜετάΓραμμή(ν);
  	ΓράψεΤαΔύοΜερηΣτηΜνήμη();
  	ΣυνένωσεΤα();
  	ΞαναμετάφερεΣτοΑρχείο();
  }
  

• Προσθήκη επί πλέον δυνατοτήτων π.χ. Διάταξη αλφαβητική αρχείου, αρίθμηση γραμμών, διεύρυνση ή σμίκρυνση γραμμών αρχείου, καταχώρηση γραμμής σε συγγεκριμένη θέση, διόρθωση συγκεκριμένης λέξεως συγκεκριμένης γραμμής (να μην ξαναγράφω γραμμή αν αλλάζει αριθμός τηλεφώνου μόνο), εκτύπωση γραμμών που περιέχουν δοθήσα λέξη, διαμορφωμένη εκτύπωση (formated) κτλ. κτλ.