Οργάνωση προγραμμάτων: σχεδιασμός σε τμήματα αφηρημένοι τύποι δεδομένων

Χωρισμός του προγράμματος σε αρχεία

• Μεγαλύτερα προγράμματα οργανώνονται καλύτερα σε πολλαπλά αρχεία. Η οργάνωση αυτή διευκολύνει την ομαδική εργασία, τον έλεγχο των τμημάτων του έργου και τη συντήρηση. Σε πραγματικά μεγάλα συστήματα ο χωρισμός ενός προγράμματος σε πολλά αρχεία επιδρά θετικά και στο χρόνο που απαιτείται για τη μεταγλώττιση.
• Για να χωρίσουμε ένα πρόγραμμα σε πολλά αρχεία απλώς χωρίζουμε τις συναρτήσεις και τις καθολικές μεταβλητές σε λογικές ομάδες και γράφουμε τις συναρτήσεις και μεταβλητές κάθε ομάδας σε ένα ξεχωριστό αρχείο.
• Κάθε καθολική συνάρτηση ή μεταβλητή πρέπει να εμφανίζεται σε ένα και μόνο ένα αρχείο.
• Κάθε αρχείο μεταγλωττίζεται ξεχωριστά και έτσι πρέπει να έχει τα δικά του #include στην αρχή.
• Ο τρόπος που χρησιμοποιούμε καθολικές μεταβλητές και συναρτήσεις που έχουν οριστεί σε ένα αρχείο, σε άλλο αναλύεται στις επόμενες ενότητες.

Ξεχωριστή μεταγλώττιση

• Η μεταγλώττιση και η σύνδεση ενός προγράμματος που αποτελείται από πολλά αρχεία γίνεται σε πολλαπλά βήματα.
• Αρχικά μεταγλωττίζουμε κάθε αρχείο C με την εντολή:

  cl -c file.c
  

  (Στο Unix χρησιμοποιούμε την εντολή cc αντί της εντολής cl).
• Η μεταγλώττιση δημιουργεί ένα αρχείο του τύπου file.obj (ή file.o στο Unix).
• Στη συνέχεια (αν δεν έχουν προκύψει λάθη κατά τη μεταγλώττιση) συνδέουμε τα αρχεία μεταξύ τους σε ένα εκτελέσιμο αρχείο (π.χ. με όνομα runprog) με την εντολή:

  cl -o runprog file1.obj file2.obj ...
  

Δήλωση και χρήση καθολικών μεταβλητών

• Οι καθολικές μεταβλητές που ορίζονται σε ένα αρχείο μπορούν να χρησιμοποιηθούν σε οποιοδήποτε άλλο.
• Για να μπορέσουν όμως να χρησιμοποιηθούν πρέπει να δηλωθούν με την εντολή extern.
• Η δήλωση μιας μεταβλητής με extern στο αρχείο που θέλουμε να τη χρησιμοποιήσουμε πρέπει να είναι ακριβώς ίδια με αυτή που έχει οριστεί στο αρχείο ορισμού.
  Παράδειγμα:
  /*
   * Definition file:
   */
  double a[10];
  int i;
  
  void
  fun(void)
  {
          i = 3;
  }
  
  /*
   * Other file
   */
  extern double a[10];
  extern int i;
  
  void
  fun2(void)
  {
          printf("%d\n", i);
          i++;
  }
  

Δήλωση και χρήση συναρτήσεων

• Οι καθολικές συναρτήσεις που ορίζονται σε ένα αρχείο μπορούν να χρησιμοποιηθούν σε οποιοδήποτε άλλο.
• Για να μπορέσουν να χρησιμοποιηθούν πρέπει να δηλωθούν με την εντολή extern.
• Η δήλωση μιας συνάρτησης με extern στο αρχείο που θέλουμε να τη χρησιμοποιήσουμε πρέπει να είναι ακριβώς ίδια με αυτή που έχει οριστεί στο αρχείο ορισμού.
  Παράδειγμα:
  /*
   * Definition file:
   */
  int
  fun(int a, double b[3], char *cp)
  {
          ...
  }
  
  /*
   * Other file
   */
  extern int fun(int a, double b[3], char *cp);
  
  void
  fun2(void)
  {
          char c;
          double q[3];
  
          fun(1, q, &c);
  }
  

Χρήση αρχείων επικεφαλίδων

• Για το συντονισμό των δηλώσεων ανάμεσα σε πολλά αρχεία είναι βολικό αυτές να συγκεντρώνονται σε ένα αρχείο επικεφαλίδων (header file).
• Έχει επικρατήσει το αρχείο αυτό να έχει το επίθεμα .h
• Για να συμπεριλάβουμε το αρχείο αυτό μέσα σε ένα αρχείο που περιέχει το πρόγραμμά μας χρησιμοποιούμε την εντολή:
  #include "myheader.h"
  
• Παράδειγμα:
  /*
   * Header file (myheader.h)
   */
  extern void clear_screen(void);
  extern int total;
  
  /*
   * Code file
   */
  #include "myheader.h"
  
  main()
  {
          clear_screen();
          printf("%d\n", total);
  }
  
• Τα αρχεία επικεφαλίδων δε μεταγλωττίζονται ξεχωριστά, αλλά περιλαμβάνονται λεκτικά μέσα στα αρχεία που τα χρησιμοποιούν.
• Σε μεγαλύτερα έργα δημιουργείται ένα αρχείο επικεφαλίδων για κάθε λειτουργία ή ακόμα και ένα αρχείο επικεφαλίδων για κάθε αρχείο κώδικα.

Περιορισμός της εμβέλειας

• Έχουμε τη δυνατότητα να ορίσουμε μια καθολική μεταβλητή, ή μια συνάρτηση σε ένα αρχείο με τέτοιο τρόπο έτσι ώστε αυτή να μην είναι ορατή έξω από το αρχείο αυτό.
• Ο ορισμός τέτοιων μεταβλητών και συναρτήσεων γίνεται με τον προσδιορισμό static.
• Παράδειγμα:
  static int hidden_global_var;
  
  static void
  hidden_global_function(int i)
  {
          hidden_global_var = 1;
  }
  
• Για να αποφεύγεται η ρύπανση του χώρου των ονομάτων (namespace polution) καλό είναι μεταβλητές και συναρτήσεις που δε θα χρησιμοποιηθούν έξω από ένα αρχείο να ορίζονται ως static.
• Ακόμα καλύτερα είναι οι καθολικές μεταβλητές να ορίζονται πάντα ως static και η πρόσβαση σε αυτές να γίνεται μέσω συναρτήσεων.
  Παράδειγμα:
  static int speed;
  
  int
  get_speed(void)
  {
          return (speed);
  }
  
  void
  set_speed(int s)
  {
          speed = s;
  }
  

Αφηρημένοι τύποι

• Η δυνατότητα χωρισμού ενός προγράμματος σε ανεξάρτητες λειτουργικές μονάδες επιτρέπει τον ορισμό αφηρημένων οντοτήτων στις οποίες η πρόσβαση γίνεται μόνο μέσω συναρτήσεων και με συγκεκριμένο τρόπο.
• Η χρήση των οντοτήτων αυτών γίνεται μόνο μέσω των συναρτήσεων και των τύπων που ορίζονται σε αντίστοιχο αρχείο επικεφαλίδων, ενώ η υλοποίηση γίνεται σε ξεχωριστό αρχείο C. Ο τρόπος αυτός προγραμματισμού ξεχωρίζει την υλοποίηση από τους μηχανισμούς πρόσβασης επιτρέποντάς μας να αλλάξουμε την υλοποίηση χωρίς να επηρεαστεί το υπόλοιπο πρόγραμμα.
• Το παρακάτω παράδειγμα ορίζει έναν μετρητή ο οποίος μπορεί μόνο να αυξάνεται:
  /*
   * Header file
   */
  extern int get_counter(void);
  extern void inc_counter(void);
  
  /*
   * C file
   */
  static int counter;
  
  int
  get_counter(void)
  {
          return (counter);
  }
  
  void
  inc_counter(void)
  {
          counter++;
  }
  
• Το παραπάνω παράδειγμα δημιουργεί έναν μόνο μετρητή. Με τη χρήση δεικτών και δυναμικής μνήμης μπορούμε να ορίσουμε ένα εργοστάσιο που να δημιουργεί απεριόριστο αριθμό από μετρητές. Ο αφηρημένος τύπος του μετρητή παριστάνεται ως ένας δείκτης σε ακέραιο:
  /*
   * Header file
   */
  typedef int *counter;
  
  extern counter new_counter(void);
  extern int get_counter(counter c);
  extern void inc_counter(counter c);
  
  /*
   * C file
   */
  
  /*
   * Return a new counter object
   */
  counter
  new_counter(void)
  {
          counter c;
  
          c = (counter)malloc(sizeof(int));
          *c = 0;
          return (c);
  }
  
  int
  get_counter(counter c)
  {
          return (*c);
  }
  
  void
  inc_counter(counter c)
  {
          (*c)++;
  }
  
• Με τη χρήση των παραπάνω αρχείων μπορούμε να προγραμματίσουμε με δύο λ.χ. μετρητές:
  #include <stdio.h>
  #include "counter.h"
  
  main()
  {
          counter c1, c2;
  
          c1 = new_counter();
          c2 = new_counter();
          inc_counter(c1);
          inc_counter(c1);
          inc_counter(c2);
          printf("%d %d\n", get_counter(c1), get_counter(c2));
  }
  
• Το παραπάνω παράδειγμα επιτρέπει σε κάποιον να διαβάσει στο αρχείο των επικεφαλίδων ότι ο αφηρημένος τύπος είναι ένας δείκτης σε ακέραιο και να τον μεταβάλει με λάθος τρόπο (πχ *c = 12;). Μπορούμε να διασφαλίσουμε τον αφηρημένο τύπο από τέτοιου είδους προσβάσεις ορίζοντας μια δομή στο αρχείο υλοποίησης και μόνο έναν δείκτη στη δομή αυτή στο αρχείο επικεφαλίδων (η γραφή structptr->member είναι συντομογραφία της (*structptr).member):
  /*
   * Header file
   */
  typedef struct s_counter *counter;
  
  extern counter new_counter(void);
  extern int get_counter(counter c);
  extern void inc_counter(counter c);
  
  /*
   * C file
   */
  
  struct s_counter {
          int value;
  };
  
  /*
   * Return a new counter object
   */
  counter
  new_counter(void)
  {
          counter c;
  
          c = (counter)malloc(sizeof(struct s_counter));
          c->value = 0;
          return (c);
  }
  
  int
  get_counter(counter c)
  {
          return (c->value);
  }
  
  void
  inc_counter(counter c)
  {
          c->value++;
  }
  
• Είναι αξιοσημείωτο ότι η παραπάνω (διαφορετική) υλοποίηση συνεχίζει να είναι συμβατή με το πρόγραμμα το οποίο χρησιμοποιεί τους δύο δείκτες.

Ασκήσεις

Υλοποίηση σε τμήματα - έλεγχος

1. Να γράψετε μια συνάρτηση void hangman(int n) η οποία θα σχεδιάζει στην οθόνη μια κρεμάλα με έναν κρεμασμένο άνθρωπο όπως τον παρακάτω:

   ++----
   |    O
   |   /|\
   |   / \
   
   

   (Επιτρέπεται να βελτιώσετε το παραπάνω σχέδιο).

   Ανάλογα με την τιμή του n (0-6) θα εμφανίζεται και αντίστοιχος αριθμός από τα μέλη του ανθρώπου.

   n = 0
   
   ++----
   |
   |
   |
   
   n = 1
   ++----
   |    O
   |
   |
   
      ...
   
   n = 6
   ++----
   |    O
   |   /|\
   |   / \
   
   

   Προσπαθήστε η συνάρτησή σας να μην περιέχει επαναλαμβανόμενο κώδικα.
2. Ολοκληρώστε το πρόγραμμά σας προσθέτοντας τη συνάρτηση main με εντολές κατάλληλες για να ελέγξετε τη σωστή λειτουργία της συνάρτησης hangman.
3. Γράψτε (σε ξεχωριστό αρχείο C) πρόγραμμα το οποίο υλοποιεί το παιγνίδι "κρεμάλα" μεταξύ δύο παικτών. Συγκεκριμένα το πρόγραμμα διαβάζει από ένα χρήστη μια λέξη μέχρι 20 χαρακτήρες. Στη συνέχεια επαναλαμβάνει τα παρακάτω:
   • καθαρίζει την οθόνη (τυπώνοντας 24 \n),
   • ζωγραφίζει μια (αρχικά) άδεια κρεμάλα χρησιμοποιώντας τη συνάρτηση που έχετε ορίσει,
   • τυπώνει τόσα αστεράκια (αρχικά) όσα και τα γράμματα της λέξης που έχει δώσει ο πρώτος χρήστης,
   • ζητάει από έναν δεύτερο χρήστη να μαντέψει ένα γράμμα,
   • αν το γράμμα είναι σωστό τότε το γράμμα εμφανίζεται στις αντίστοιχες θέσεις στα αστεράκια που τυπώνονται, αλλιώς αυξάνεται κατά ένα ο αριθμός των τμημάτων του σώματος που εμφανίζονται στην κρεμάλα.
   Όταν ο δεύτερος παίκτης "κρεμαστεί" ή μαντέψει τη λέξη εμφανίζεται αντίστοιχο μήνυμα.
   Σημείωση: για να διαβάσετε τη λέξη μπορείτε να διαβάζετε χαρακτήρες μέχρι να συναντήσετε \n.
   Παράδειγμα:

   Enter word: hello
   
   ++----
   |
   |
   |
   
   The word is: *****
   Enter letter guess: a
   Sorry...
   
   
   
   
   ++----
   |    O
   |
   |
   
   The word is: *****
   Enter letter guess: e
   Bravo!
   
   
   
   
   ++----
   |    O
   |
   |
   
   The word is: *e***
   Enter letter guess: t
   Sorry...
   
   
   
   
   
   ++----
   |    O
   |    |
   |
   
   The word is: *e***
   Enter letter guess: l
   Bravo!
   
   
   
   
   ++----
   |    O
   |    |
   |
   The word is: *ell*
   Enter letter guess: t
   Sorry...
   
   
   
   ++----
   |    O
   |   /|
   |
   The word is: *ell*
   Enter letter guess:
   ...
   

Βιβλιογραφία

• Brian W. Kernighan, Dennis M. Ritchie Η γλώσσα προγραμματισμού C. σ. 102-106, 117-122 Δεύτερη έκδοση. Κλειδάριθμος, 1988.

• Luca Cardelli and Peter Wegner. On understanding types, data abstraction, and polymorphism. ACM Computing Surveys, 17(4):471–522, December 1985.
• Guilio Iannello. Programming abstract data types, iterator and generic modules in c. Software: Practice & Experience, 20(3):243–260, March 1990.
• Bjarne Stroustrup. Data abstraction in C. Bell System Technical Journal, 63(8):1701–1732, October 1984.

• Περιεχόμενα

 Τελευταία αλλαγή: Τρίτη, 19 Σεπτεμβρίου 2006 6:26 μμ
 Εκτός αν αναφέρεται κάτι διαφορετικό, όλο το πρωτότυπο υλικό της σελίδας αυτής του οποίου δημιουργός είναι ο Διομήδης Σπινέλλης παρέχεται σύμφωνα με τους όρους της άδειας «Creative Commons Attribution-Share Alike 3.0 Greece License».