Σχεδιασμός και υλοποίηση λογισμικού

Γενεαλογία

Απόγονοι

Το πρώτο μου πρόγραμμα

• Το όνομά μας
• Περισσότερα στοιχεία με πολλαπλά printf:
          printf("hello, world\n");
          printf("so long\n");
  
  

Στοιχεία του προγράμματος

• Τα κενά, όπως ο χαρακτήρας ' ' και η αλλαγή της γραμμής. Αυτά γενικά δεν επηρεάζουν καθόλου τη συμπεριφορά του προγράμματος. Για παράδειγμα μπορούσαμε να γράψουμε το πρόγραμμα ως εξής:
  #include <stdio.h>
  main(){printf("hello, world\n");}
  
  Χρησιμοποιούμε κενά (spaces) για να κάνουμε το πρόγραμμα πιο εύληπτο.
• Οι εντολές του προεπεξεργαστή. Αυτές είναι όλες οι γραμμές που αρχίζουν με το χαρακτήρα #. Για την ώρα απλώς τις γράφουμε στην αρχή του προγράμματος για να μπορέσουμε να εκτελέσουμε ορισμένες βασικές λειτουργίες, όπως το να τυπώσουμε τα αποτελέσματά μας.
• Τα ονόματα των συναρτήσεων (functions) και των μεταβλητών. Αυτά αρχίζουν με έναν λατινικό αλφαβητικό χαρακτήρα (a-z) και μπορούν να ακολουθούνται από άλλους ή/και ψηφία.
• Οι δηλώσεις των συναρτήσεων. Αυτές γράφονται ως το όνομα τη συνάρτησης ακολουθούμενο από παρενθέσεις και το περιεχόμενο της συνάρτησης μέσα σε άγκιστρα ({ }). Η συνάρτηση main έχει ειδικό νόημα. Ορίζει το σημείο από το οποία θα αρχίσει να εκτελείται το πρόγραμμα.
• Το περιεχόμενο των συναρτήσεων. Αυτό αποτελείται από εντολές. Κάθε εντολή τερματίζεται με μια λατινική άνω τελεία (semicolon) (; - ελληνικό ερωτηματικό).
• Οι εντολές μέσα στη συνάρτηση εκτελούνται με τη σειρά από πάνω προς τα κάτω εκτός να έχουμε ορίσει κάτι διαφορετικό.
• Οι κλήσεις άλλων συναρτήσεων. Αυτές αποτελούν ένα βασικό είδος εντολής. Η κλήση μιας συνάρτησης αποτελείται από το όνομα της συνάρτησης ακολουθούμενο από το όρισμα (argument) της συνάρτησης μέσα σε παρενθέσεις. Αν η συνάρτηση δέχεται πολλαπλές παραμέτρους, τότε αυτές χωρίζονται με κόμματα.

Ορισμός απλών συναρτήσεων

• Στο πρόγραμμα που εξετάσαμε εμφανίζονται δύο συναρτήσεις:
  1. η συνάρτηση main την οποία ορίσαμε εμείς και
  2. η συνάρτηση printf την καλέσαμε.
• Σε ένα πρόγραμμα είναι δυνατός ο ορισμός (definition) και η κλήση (call) και άλλων συναρτήσεων. Το παρακάτω πρόγραμμα τυπώνει και αυτό "hello, world" στην οθόνη.
  #include <stdio.h>
  
  hello()
  {
          printf("hello, world\n");
  }
  
  main()
  {
          hello();
  }
  
• Με τον τρόπο αυτό μπορούμε να ομαδοποιήσουμε τα τμήματα του προγράμματός μας και να χρησιμοποιήσουμε ορισμένα τμήματα πολλές φορές.
• Όταν καλείται μια συνάρτηση, αυτή εκτελείται βήμα προς βήμα μέχρι να τελειώσουν οι εντολές που την απαρτίζουν. Τότε η εκτέλεση του προγράμματος επιστρέφει (returns) στην επόμενη εντολή από αυτή που κάλεσε τη συνάρτηση.

Ασκήσεις

Εξοικείωση με το μεταγλωττιστή και τη διαδικασία προγραμματισμού

1. Να πληκτρολογήσετε, μεταγλωττίσετε και να εκτελέσετε ένα πρόγραμμα σε C που να τυπώνει "I am learning C"
2. Πειραματιστείτε αλλάζοντας διάφορα στοιχεία του προγράμματος. (Το πιθανότερο είναι οι περισσότερες αλλαγές σας να καταλήγουν σε λάθη.)
3. Φτιάξτε ένα πρόγραμμα το οποίο να τυπώνει με * ένα τετράγωνο στην οθόνη σαν το παρακάτω:

   ***************
   *             *
   *             *
   *             *
   *             *
   *             *
   *             *
   ***************
   

   Για να επαναλαμβανόμενα στοιχεία του τετραγώνου να ορίσετε δύο συναρτήσεις οι οποίες να τα τυπώνουν και να τις καλέσετε όσες φορές και με τη σειρά που χρειάζεται.

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

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

• Brian W. Kernighan and Dennis M. Ritchie. The C Programming Language, pages 5-7. Prentice-Hall, second edition, 1988.

Γενική βιβλιογραφία

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

• American National Standard for Information Systems --- programming language --- C: ANSI X3.159-1989. Published by the American National Standards Institute, 1430 Broadway, New York, New York 10018, December 1989. (Also ISO/IEC 9899:1990).

• Samuel P. Harbison and Guy L. Steele Jr. C: A Reference Manual. Prentice-Hall, third edition, 1991.

• Mark R. Horton. Portable C Software. Prentice Hall, 1990.

• Stephen C. Johnson and Brian W. Kernighan. The programming language b. Computer Science Technical Report 8, Bell Laboratories, Murray Hill, NJ, USA, January 1977.

• Brian W. Kernighan and P. J. Plauger. The Elements of Programming Style. McGraw-Hill, second edition, 1978.

• Brian W. Kernighan and Dennis M. Ritchie. The C Programming Language. Prentice-Hall, first edition, 1978.

• Brian W. Kernighan. Why Pascal is not my favorite programming language. Technical Report 100, Bell Laboratories, Murray Hill, New Jersey 07974, July 1981.

• Andrew Koenig. C Traps and Pitfalls. Addison-Wesley, 1988.

• Don Libes. Obfuscated C and Other Mysteries. John Wiley and Sons, 1993.

• P. J. Plauger. The Standard C Library. Prentice Hall, 1992.

• Henry Rabinowitz and Chaim Schaap. Portable C. Prentice Hall, 1990.

• D. M. Ritchie, S. C. Johnson, M. E. Lesk, and B. W. Kernighan. The C programming language. Bell System Technical Journal, 57(6), July-August, Year=.

• Dennis M. Ritchie. The development of the C language. ACM SIGPLAN Notices, 28(3):201-208, March 1993. Preprints of the History of Programming Languages Conference (HOPL-II).

• L. Rosler. The evolution of c --- past and future. Bell System Technical Journal, 63(8), October 1984.

• Robert Sedgewick. Algorithms in C. Addison-Wesley, 1990.

• The Accredited Standard Committee X3, Information Processing Systems, Technical Committee for Programming Language C (X3J11). Rationale for the ANSI C Programming Language. Silicon Press, 25 Beverly Road, Summit, NJ 07901, USA, 1990.

Υπολογισμοί με μεταβλητές, είσοδος και έξοδος

Σταθερές

• Η συμβολοσειρά (string) "hello, world" την οποία είδαμε στο προηγούμενο μάθημα είναι μια σταθερά (constant) της γλώσσας C.
• Οι σταθερές αυτές χρησιμοποιούνται συχνά για να παραστήσουν μηνύματα προς το χρήστη (π.χ. "Παρακαλώ βάλτε την κάρτα σας στην υποδοχή") ή και μεταξύ υπολογιστών (π.χ. "RCPT TO: dspin@aegean.gr").
• Ένα άλλο είδος σταθερών είναι αυτές που παριστάνουν αριθμητικές τιμές (π.χ. 42 ή 3.1415927).
• Στη C ξεχωρίζουμε της ακέραιες (integer) σταθερές (π.χ. 42, 123456, -3) και τις σταθερές που παριστάνουν αριθμούς κινητής υποδιαστολής (floating point numbers) (π.χ. 3.1415827, -2.0, 6.023e-23).

Εκτύπωση τιμών

• Για να τυπώσουμε ακέραιες τιμές προσθέτουμε στη συμβολοσειρά του printf τον κωδικό μορφής (format code) %d στο σημείο που θέλουμε να εμφανιστεί η κάθε τιμή και ακολουθούμε τη συμβολοσειρά με τις αντίστοιχες τιμές. Παράδειγμα:
          printf("Τα γραπτά βαθμολογούνται με βαθμούς από το %d μέχρι το %d.\n",0, 10);
  
  ).
• Αντίστοιχα για να τυπώσουμε τιμές κινητής υποδιαστολής χρησιμοποιούμε τον κωδικό μορφής %g. Παράδειγμα:
          printf("Ο αριθμός %g είναι μια προσέγγιση του π.", 3.1415927)
  

Απλές πράξεις

• Για τον υπολογισμό μιας τιμής, πρώτα εκτελούνται οι πράξεις ανάμεσα στους τελεστές * / % και μετά οι πράξεις ανάμεσα στους τελεστές + -.
• Η παραπάνω σειρά μπορεί να μεταβληθεί με τη χρήση παρενθέσεων.

Παραδείγματα

• printf("ένα συν ένα = %d\n", 1 + 1);
• printf("Το εμβαδό του δωματίου είναι %d τετραγωνικά μέτρα.\n", 3 * 5);
• printf("%g βαθμοί Celsius = %g βαθμοί Fahrenheit.\n", 36.7, 32 + 9.0 / 5.0 * 36.7);
• printf("%d\n", 1 + 2 * 3); /* Τυπώνει 7 */
• printf("%d\n", (1 + 2) * 3); /* Τυπώνει 9 */

Μεταβλητές

• Οι αριθμητικές τιμές μπορούν να αποθηκευτούν σε μεταβλητές (variables)
• Οι μεταβλητές που χρησιμοποιούμε για να αποθηκεύμουμε τιμές κατά το διάστημα που υπολογίζεται μια συνάρτηση ορίζονται στην αρχή της αντίστοιχης συνάρτησης μετά το σύμβολο "{".
• Ο ορισμός τους γίνεται γράφοντας τον τύπο της μεταβλητής (int για ακέραιες τιμές, double για τιμές κινητής υποδιαστολής) ακολουθούμενο από το όνομα της μεταβλητής. Στο τέλος του ορισμού γράφουμε το χαρακτήρα ";".
• Μπορούμε να ορίσουμε πολλές μεταβλητές ίδιου τύπου χωρίζοντάς τις με ",". Παράδειγμα:
  main()
  {
          int faces;
          double x, y;
  
  }
  
• Για να δώσουμε μια τιμή σε μια μεταβλητή χρησιμοποιούμε τη σύνταξη:

  	μεταβλητή = τιμή;
  

  για παράδειγμα:
          faces = 2 * 8 + 12;
  
• Στη συνέχεια μπορούμε να χρησιμοποιούμε την τιμή της μεταβλητής όπως και οποιοδήποτε άλλη σταθερά. Παράδειγμα:
  #include <stdio.h>
  
  main()
  {
          int faces;
          double len;
  
          len = 12.5;
          faces = 6;
          printf("Επιφάνεια = %g\n", len * len * faces);
  }
  

Είσοδος στοιχείων

• Μπορούμε να κάνουμε το πρόγραμμά μας να σταματήσει την εκτέλεσή του για να διαβάσει από το χρήστη κάποιες τιμές. Για παράδειγμα το πρόγραμμα ελέγχου μια μηχανής αυτόματης ανάληψης χρημάτων σταματά την εκτέλεσή του όταν τυπώνει την ερώτηση "Δώστε το ποσό που θέλετε να αναλάβετε" και περιμένει από το χρήστη να γράψει την αντίστοιχη τιμή.
• Η συνάρτηση της C scanf σταματά την εκτέλεση ενός προγράμματος περιμένοντας ο χρήστης του να πληκτρολογήσει κάποιες τιμές και στη συνέχεια αναθέτει τις τιμές αυτές στις μεταβλητές που έχουμε ορίσει.
• Για να διαβάσουμε από το χρήστη μια ακέραια τιμή καλούμε τη συνάρτηση scanf με πρώτο όρισμα μια συμβολοσειρά με τον κωδικό μορφής %d και ακολουθούμε τη συμβολοσειρά με την αντίστοιχη μεταβλητή με το χαρακτήρα & πριν από το όνομά της. Παράδειγμα:
  scanf("%d", &grade);
  
• Αντίστοιχα για να διαβάσουμε τιμές κινητής υποδιαστολής χρησιμοποιούμε τον κωδικό μορφής %lg. Παράδειγμα:
  main()
  {
          double temperature;
          scanf("%lg", &temperature);
          printf("The temperature is %g\n", temperature);
  }
  
• Παρατήρηση: αφού ο χρήστης γράψει την τιμή πρέπει να πατήσει το πλήκτρο ENTER για να συνεχίσει το πρόγραμμα τη λειτουργία του.

Ασκήσεις

Είσοδος έξοδος και υπολογισμοί

1. Να γράψετε ένα πρόγραμμα που θα διαβάζει από το χρήστη την ταχύτητα ενός αντικειμένου σε km/h και την τυπώνει σε m/s. Παράδειγμα της εκτέλεσης του πρόγραμματος:

   Speed (km/h)=120
   A speed of 120 km/h is 33.333 m/s
   

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

• Brian W. Kernighan, Dennis M. Ritchie Η γλώσσα προγραμματισμού C. σ. 23-28, 218-222 (τμήματα) Δεύτερη έκδοση. Κλειδάριθμος, 1988.

• Brian W. Kernighan and Dennis M. Ritchie. The C Programming Language, pages 8-12, 157-169 (parts). Prentice-Hall, second edition, 1988.

Τελεστές σύγκρισης, λογικής και επαναλήψεις

Τελεστές σύγκρισης

• Για τον υπολογισμό μιας τιμής, πρώτα εκτελούνται οι πράξεις ανάμεσα στους τελεστές * / %, μετά οι πράξεις ανάμεσα στους τελεστές + -, μετά ανάμεσα στους τελεστές < > <= >= και μετά ανάμεσα στους τελεστές == και !=.
• Η παραπάνω σειρά μπορεί να μεταβληθεί με τη χρήση παρενθέσεων.
• Το αποτέλεσμα της κάθε σύγκρισης είναι 1 (αληθές (true)) αν το αποτέλεσμα της σύγκρισης είναι αληθές και 0 (ψευδές (false)) αν το αποτέλεσμα της σύγκρισης είναι ψευδές.

Παραδείγματα

• printf("%d\n", 1 + 1 == 2); /* Τυπώνει 1 */
• printf("%d\n", 1 > 2); /* Τυπώνει 0 */
• printf("%d\n", 5 != 5); /* Τυπώνει 0 */
• printf("%d\n", 1 <= 5); /* Τυπώνει 1 */
• printf("%d\n", 1 <= 1); /* Τυπώνει 1 */
• printf("%d\n", 1 <= 0); /* Τυπώνει 0 */

Βρόχοι με την εντολή while

• Μπορούμε να επαναλάβουμε την εκτέλεση ορισμένων εντολών με τη δομή ελέγχου (control structure) while.
• Αυτή χρησιμοποιείται ως εξής:

  	while (συνθήκη)
  		εντολή;
  

• Τις περισσότερες φορές θέλουμε να εκτελέσουμε πάνω από μια εντολή πολλαπλές φορές οπότε περικλείουμε όλες τις αντίστοιχες εντολές μέσα σε αγκύλες "{" και "}":

  	while (συνθήκη) {
  		εντολή1;
  		εντολή2;
  		εντολή3;
  	}
  

• Η εντολή που ακολουθεί το while εκτελείται όσο η συνθήκη είναι αληθής, δηλαδή έχει τιμή διάφορη του 0. Παράδειγμα (τυπώνει τους αριθμούς από το 0 μέχρι το 9):
  #include <stdio.h>
  
  main()
  {
          int i;
  
          i = 0;
          while (i < 10) {
                  printf("%d\n", i);
                  i = i + 1;
          }
  }
  
• Αν η συνθήκη δεν είναι αληθής όταν εκτελεστεί το while για πρώτη φορά τότε η εντολή που περιέχεται σε αυτό δε θα εκτελεστεί.
• Η δομή ελέγχου while μπορεί να χρησιμοποιηθεί οπουδήποτε θα μπορούσε και οποιαδήποτε άλλη εντολή (π.χ. η printf) δηλαδή ακόμα και μέσα σε μια άλλη while. Το παρακάτω παράδειγμα τυπώνει στην οθόνη ένα τριγωνικό σχήμα:
  #include <stdio.h>
  
  main()
  {
          int row, stars;
  
          row = 0;
          while (row < 10) {
                  stars = row;
                  while (stars > 0) {
                          printf("*");
                          stars = stars - 1;
                  }
                  row = row + 1;
                  printf("\n");
          }
  }
  
  όπως αυτό:

  
  *
  **
  ***
  ****
  *****
  ******
  *******
  ********
  *********
  

Βρόχοι με την εντολή do while

• Ορισμένες φορές θέλουμε να ελέγχουμε τη συνθήκη στο τέλος του βρόχου, δηλαδή η εντολή να εκτελεστεί τουλάχιστον μια φορά. Στις περιπτώσεις αυτές χρησιμοποιούμε τη δομή ελέγχου do while
• Αυτή χρησιμοποιείται ως εξής:

  	
  	do
  		εντολή;
  	while (συνθήκη);
  

• Τις περισσότερες φορές θέλουμε να εκτελέσουμε πάνω από μια εντολή πολλαπλές φορές οπότε περικλείουμε όλες τις αντίστοιχες εντολές μέσα σε αγκύλες "{" και "}":

  	do {
  		εντολή1;
  		εντολή2;
  		εντολή3;
  	} while (συνθήκη);
  

• Η εντολή που ακολουθεί το do εκτελείται μια φορά και συνεχίζει να εκτελείται όσο η συνθήκη είναι αληθής, δηλαδή έχει τιμή διάφορη του 0.
• Σημαντικό ρόλο έχει αυτή η δομή ελέγχου όταν διαβάζουμε στοιχεία από το χρήστη και θέλουμε να ελέγξουμε την είσοδο για λάθη. Παράδειγμα (εισάγει έναν αριθμό μικρότερο του 10):
  #include <stdio.h>
  
  main()
  {
          int number;
  
          do {
                  printf("Enter a number less than 10: ");
                  scanf("%d", &number);
          } while (number >= 10);
          printf("You entered %d\n", number);
  }
  
  όπως φαίνεται από το παρακάτω παράδειγμα:

  Enter a number less than 10: 34
  Enter a number less than 10: 50
  Enter a number less than 10: 2
  You entered 2
  

• Αν η συνθήκη δεν είναι αληθής όταν εκτελεστεί το do για πρώτη φορά τότε η εντολή που περιέχεται σε αυτό θα εκτελεστεί τουλάχιστον μια φορά.
• Η δομή ελέγχου do μπορεί να χρησιμοποιηθεί οπουδήποτε θα μπορούσε και οποιαδήποτε άλλη εντολή (π.χ. η printf) δηλαδή ακόμα και μέσα σε μια άλλη do ή while.

Λογικοί τελεστές

• Τα αποτελέσματα χρήσης των τελεστών παριστάνονται από τους παρακάτω πίνακες τιμών:

  A	B	A && B	A || B
  0	0	0	0
  0	1	0	1
  1	0	0	1
  1	1	1	1

  A	!A
  0	1
  1	0

• Η προτεραιότητα υπολογισμού των τελεστών ορίζεται τώρα ως εξής:

  ()
  ! + -
  * / %
  + -
  < <= > >=
  == !=
  &&
  ||
  

Παράδειγμα

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

• Brian W. Kernighan, Dennis M. Ritchie Η γλώσσα προγραμματισμού C. σ. 26, 67-69, 305-306 (τμήματα) Δεύτερη έκδοση. Κλειδάριθμος, 1988.

• Brian W. Kernighan and Dennis M. Ritchie. The C Programming Language, pages 10, 41-42, 223-224 (parts). Prentice-Hall, second edition, 1988.

Ασκήσεις

Βρόχοι

1. Να γράψετε ένα πρόγραμμα που να τυπώνει τον πίνακα της προπαίδειας όπως στο παρακάτω παράδειγμα:

      1    2    3    4    5    6    7    8    9   10 
      2    4    6    8   10   12   14   16   18   20 
      3    6    9   12   15   18   21   24   27   30 
      4    8   12   16   20   24   28   32   36   40 
      5   10   15   20   25   30   35   40   45   50 
      6   12   18   24   30   36   42   48   54   60 
      7   14   21   28   35   42   49   56   63   70 
      8   16   24   32   40   48   56   64   72   80 
      9   18   27   36   45   54   63   72   81   90 
     10   20   30   40   50   60   70   80   90  100 
   

   Για να μπορέσουν οι αριθμοί να εμφανιστούν σε στήλες μπορείτε να χρησιμοποιήσετε στην printf τον κωδικό εξόδου %4d (εμφάνιση του αριθμού σε χώρο 4 χαρακτήρων) αντί του κωδικού %d.

Προγραμματισμός με χαρακτήρες, αποφάσεις

Η εντολή if-else

• Μπορούμε να εκτελέσουμε ορισμένες εντολές υπό συνθήκη με τη δομή ελέγχου if.
• Αυτή χρησιμοποιείται ως εξής:

  	if (συνθήκη)
  		εντολή;
  

• Όπως και με τις εντολές while και do όταν θέλουμε να εκτελέσουμε πάνω από μια εντολή υπό συνθήκη περικλείουμε όλες τις αντίστοιχες εντολές μέσα σε αγκύλες "{" και "}":

  	if (συνθήκη) {
  		εντολή1;
  		εντολή2;
  		εντολή3;
  	}
  

• Οι εντολή που ακολουθεί το if εκτελείται αν η συνθήκη είναι αληθής, δηλαδή έχει τιμή διάφορη του 0. Παράδειγμα (υπολογίζει και τυπώνει την απόλυτη τιμή των αριθμών που διαβάζει μέχρι να συναντήσει το 0):
  #include <stdio.h>
  
  main()
  {
          int num;
  
          do {
                  scanf("%d", &num);
                  if (num < 0)
                          num = -num;
                  printf("%d\n", num);
          } while (num != 0);
  }
  
• Η δομή ελέγχου if μπορεί να ακολουθηθεί και από τη δομή else για να προσδιορίσουμε εντολές που θα εκτελεστούν αν η συνθήκη δεν ισχύει. Παράδειγμα:
          if (grade >= 5)
                  printf("Περνάει\n");
          else
                  printf("Απορρίπτεται\n");
  
• Χρειάζεται προσοχή όταν η else ακολουθεί δύο συνεχόμενες if. Στην περίπτωση αυτή, η else συσχετίζεται με την κοντινότερη if. Για να εκφράσουμε διαφορετική συσχέτιση πρέπει να χρησιμοποιήσουμε αγκύλες { }. Παράδειγμα (τυπώνει μόνο όταν η μεταβλητή printed είναι ψευδής):
          if (exam >= 5) {
                  if (!printed)
                          printf("Περνάει\n");
          } else
                  if (!printed)
                          printf("Απορρίπτεται\n");
          printed = 1;
  
  Το παρακάτω παράδειγμα (χωρίς αγκύλες) δεν εκτελείται σύμφωνα με τον τρόπο που είναι στοιχισμένο
          if (exam >= 5)
                  if (!printed)
                          printf("Περνάει\n");
          else
                  if (!printed)
                          printf("Απορρίπτεται\n");
          printed = 1;
  
  αλλά ως εξής (δεν τυπώνει ποτέ "Απορρίπτεται"):
          if (exam >= 5)
                  if (!printed)
                          printf("Περνάει\n");
                  else
                          if (!printed)
                                  printf("Απορρίπτεται\n");
          printed = 1;
  
• Μπορούμε να συνδυάσουμε συνεχόμενα else if για πολλαπλούς ελέγχους. Παράδειγμα:
          if (grade >= 9)
                  printf("'Αριστα!\n");
          else if (grade >= 7)
                  printf("Λίαν καλώς\n");
          else if (grade >= 5)
                  printf("Καλώς\n");
          else
                  printf("Κακώς\n");
  

Τελεστές μοναδιαίας αύξησης και μείωσης, αποτέλεσμα ανάθεσης

• Ο τελεστής ++ στη χρήση ++var αυξάνει την τιμή της μεταβλητής var κατά ένα. Η τιμή της μεταβλητής var που χρησιμοποιείται στην παράσταση είναι αυτή που προκύπτει μετά την αύξηση. Παράδειγμα (τυπώνει 5, 5):
          i = 4;
          printf("%d,", ++i)
          printf("%d\n", i)
  
• Ο τελεστής ++ στη χρήση var++ επίσης αυξάνει την τιμή της μεταβλητής var κατά ένα. Η τιμή της μεταβλητής var που χρησιμοποιείται στην παράσταση είναι αυτή που ήταν πριν την αύξηση. Παράδειγμα (τυπώνει 4, 5):
          i = 4;
          printf("%d,", i++)
          printf("%d\n", i)
  
• Τα αντίστοιχα ισχύουν και για τον τελεστή -- που μειώνει την τιμή μιας μεταβλητής κατά 1.
• Η παράσταση "var = value" έχει ως τιμή την τιμή της μεταβλητής. Παράδειγμα (τυπώνει 2, 2):
          i = 4;
          printf("%d,", i = 2)
          printf("%d\n", i)
  
• Με τον τρόπο αυτό μπορούμε με συντομία να αναθέσουμε την ίδια τιμή σε πολλές μεταβλητές (οι μεταβλητές i και j γίνονται 0):
          i = j = 0;
  

Ο τύπος του χαρακτήρα

• Μπορούμε να ορίσουμε μεταβλητές τύπου χαρακτήρα με τον τύπο char:
  main()
  {
          char c;
  }
  
• Οι μεταβλητές αυτές μπορούν να αποθηκεύσουν έναν ακριβώς χαρακτήρα.
• Οι σταθερές τύπου χαρακτήρα γράφονται με τη χρήση των μονών εισαγωγικών:
  main()
  {
          char c;
  
          c = 'A';
  }
  
• Οι ακολουθίες διαφυγής (escape sequence) που έχουμε μάθει για τις αλφαριθμητικές σταθερές ισχύουν και για τις σταθερές τύπου χαρακτήρα.

Είσοδος και έξοδος χαρακτήρων

• Μπορούμε να διαβάσουμε και να γράψουμε χαρακτήρες με τη χρήση του κωδικού %c στις εντολές scanf και printf.
• Πιο βολική όμως είναι η χρήση των συναρτήσεων getchar() και putchar().
• Η συνάρτηση getchar() διαβάζει έναν χαρακτήρα και επιστρέφει την τιμή του ή την ακέραια ειδική τιμή EOF αν δεν υπάρχουν άλλοι χαρακτήρες για να διαβαστούν.
• Στο λειτουργικό σύστημα MS-DOS δηλώνουμε πως δεν υπάρχουν άλλοι χαρακτήρες να διαβαστούν από το πληκτρολόγιο με το συνδυασμό πλήκτρων CTRL-Z.
• Η συνάρτηση putchar(c) τυπώνει το χαρακτήρα c στην οθόνη.
• Στα λειτουργικά συστήματα MS-DOS, Windows NT και Unix μπορούμε να ζητήσουμε η είσοδος ενός προγράμματος να προέρχεται από ένα αρχείο με την ακολουθία:

  program <file
  

  Αντίστοιχα μπορούμε να ζητήσουμε η έξοδος ενός προγράμματος να οδηγηθεί σε ένα αρχείο με την ακολουθία:

  program >file
  

  Με τον τρόπο αυτό οι συναρτήσεις putchar() και getchar() αποκτούν ιδιαίτερη χρησιμότητα, διότι μας δίνουν τη δυνατότητα να δημιουργούμε και να εξετάζουμε αρχεία.
• Το παρακάτω πρόγραμμα αντιγράφει την είσοδό του στην έξοδο:
  #include <stdio.h>
  
  main()
  {       
          int c;
  
          while ((c = getchar()) != EOF)
                  putchar(c);
  }
  
  (Το αποτέλεσμα της εντολής ανάθεσης είναι η τιμή της μεταβλητής και με τον τρόπο αυτό η ανάθεση γίνεται μαζί με τον έλεγχο.)

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

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

• Brian W. Kernighan and Dennis M. Ritchie. The C Programming Language, pages 15-21, 55-58. Prentice-Hall, second edition, 1988.

Ασκήσεις

If, char

1. Να γράψετε ένα πρόγραμμα που να διαβάζει χαρακτήρες από την είσοδό του μέχρι να τερματιστεί το αρχείο εισόδου. Στο τέλος να τυπώνει τον αριθμό των χαρακτήρων, γραμμών, ψηφίων (0-9), πεζών χαρακτήρων (a-z) και κεφαλαίων χαρακτήρων (A-Z) που διάβασε. (Οι χαρακτήρες στο σύστημα που χρησιμοποιούμε είναι ταξινομημένοι αλφαβητικά. Η παράσταση c >= 'a' && c <= 'z' είναι αληθής για πεζούς χαρακτήρες στη μεταβλητή c.)
2. Εκτελέστε το πρόγραμμά σας με είσοδο τον εαυτό του.

Πρόσθετες δομές ελέγχου: switch for break continue

Η εντολή for

• Μπορούμε να συμπυκνώσουμε τον έλεγχο ενός βρόχου με την εντολή for.
• Αυτή χρησιμοποιείται ως εξής:

  	for (αρχική παράσταση; παράσταση συνθήκης; τελική παράσταση)
  		εντολή;
  

• Ο βρόχος που ορίζει η for εκτελείται ως εξής:
  1. Υπολογίζεται η αρχική παράσταση.
  2. Υπολογίζεται η παράσταση συνθήκης και αν είναι αληθής τότε εκτελείται η εντολή.
  3. Υπολογίζεται η τελική παράσταση.
  4. Ο βρόχος συνεχίζει από το βήμα 2.
• Παράδειγμα (τυπώνει τους αριθμούς 0-9):
  #include <stdio.h>
  
  main()
  {
          int i;
  
          for (i = 0; i < 10; i++)
                  printf("%d\n", i);
  }
  
• Η εντολή for είναι ισοδύναμη με την παρακάτω while:

  	αρχική παράσταση;
  	while (παράσταση συνθήκης) {
  		εντολή;
  		τελική παράσταση;
  	}
  

• Οποιαδήποτε από τις τρεις παραστάσεις μπορεί να παραληφθεί.
• Αν παραληφθούν και οι τρεις παραστάσεις τότε ο βρόχος εκτελείται για πάντα (ατέρμονος βρόχος (infinite loop)).
• Χρησιμοποιούμε τη for όταν οι τρεις παραστάσεις είναι σχετικές μεταξύ τους.

Η εντολή break

• Η εντολή break μας επιτρέπει να εγκαταλείψουμε μια δομή ελέγχου βρόχου (for, while, do) από οποιοδήποτε σημείο της και άσχετα με τη συνθήκη ελέγχου.
• Παράδειγμα (μετατρέπει βαθμούς Kelvin σε Celsius μέχρι να συναντήσει μια αρνητική θερμοκρασία):
  #include <stdio.h>
  
  main()
  {
          double kelvin;
  
          for (;;) {
                  scanf("%lg", &kelvin);
                  if (kelvin < 0)
                          break;
                  printf("%g\n", kelvin + 273.16);
          }
  }
  
• Μόλις εκτελεστεί η εντολή break ο έλεγχος του προγράμματος περνάει στο τέλος του εσώτερου βρόχου που την περιέχει.

Η εντολή switch

• Η εντολή switch μας επιτρέπει να κατευθύνουμε τη ροή του προγράμματος προς μια συγκεκριμένη σταθερή τιμή ανάλογα με την τιμή μιας παράστασης.
• Συντάσσεται ως εξής:

  	switch (παράσταση) {
  	case σταθερή1:
  		εντολή1;
  		εντολή1α;
  		εντολή1β;
  		...
  		break;
  	case σταθερή2:
  		εντολή2;
  		...
  		break;
  	...
  	default:
  		εντολή ν;
  		break;
  	}
  

• Ανάλογα με το με ποια σταθερή ισούται η τιμή της παράστασης εκτελείται η αντίστοιχη εντολή.
• Αν καμία από τις σταθερές δεν ταυτίζεται με την τιμή της παράστασης τότε εκτελείται η εντολή που ακολουθεί την default (αν υπάρχει), αλλιώς δεν εκτελείται καμία εντολή.
• Παράδειγμα (τυπώνει την είσοδο μετατρέποντας χαρακτήρες που παριστάνονται με ακολουθίες διαφυγής στις αντίστοιχες ακολουθίες):
  #include <stdio.h>
  
  main()
  {
          int c;
  
          while ((c = getchar()) != EOF)
                  switch (c) {
                  case '\n':
                          printf("\\n");
                          break;
                  case '\a':
                          printf("\\a");
                          break;
                  case '\t':
                          printf("\\t");
                          break;
                  default:
                          putchar(c);
                  }
  }
  
  Με είσοδο τον εαυτό του παράγει το παρακάτω αποτέλεσμα:

  #include <stdio.h>\n\nmain()\n{\n\tint c;\n\n\twhile
  ((c = getchar()) != EOF)\n\t\tswitch (c) {\n\t\tcase
  '\n':\n\t\t\tprintf("\\n");\n\t\t\tbreak;\n\t\tcase
  '\a':\n\t\t\tprintf("\\a");\n\t\t\tbreak;\n\t\tcase
  '\t':\n\t\t\tprintf("\\t");\n\t\t\tbreak;\n\t\tdefault:
  \n\t\t\tputchar(c);\n\t\t}\n}\n
  

• Το break δηλώνει ότι ο έλεγχος του προγράμματος μετά την εντολή συνεχίζει στο τέλος της switch. Σε αντίθετη περίπτωση ο έλεγχος του προγράμματος συνεχίζει στην επόμενη case. Η ιδιότητα αυτή μας επιτρέπει να δηλώσουμε πολλαπλές τιμές.
• Το παρακάτω παράδειγμα μετατρέπει όλα τα πεζά φωνήεντα σε a και σύμφωνα σε z
  #include <stdio.h>
  
  main()
  {
          int c;
  
          while ((c = getchar()) != EOF)
                  switch (c) {
                  case 'a': case 'e': case 'i': case 'o':
                  case 'u': case 'y':
                          putchar('a');
                          break;
                  case 'b': case 'c': case 'd': case 'f':
                  case 'g': case 'h': case 'j': case 'k':
                  case 'l': case 'm': case 'n': case 'p':
                  case 'q': case 'r': case 's': case 't':
                  case 'v': case 'w': case 'x': case 'z':
                          putchar('z');
                          break;
                  default:
                          putchar(c);
                  }
  }
  
  Με είσοδο τον εαυτό του παράγει το παρακάτω αποτέλεσμα:

  #azzzaza <zzzaa.z>
  
  zaaz()
  {
  	azz z;
  
  	zzaza ((z = zazzzaz()) != EOF)
  		zzazzz (z) {
  		zaza 'a': zaza 'a': zaza 'a': zaza 'a':
  		zaza 'a': zaza 'a':
  			zazzzaz('a');
  			zzaaz;
  		zaza 'z': zaza 'z': zaza 'z': zaza 'z':
  		zaza 'z': zaza 'z': zaza 'z': zaza 'z':
  		zaza 'z': zaza 'z': zaza 'z': zaza 'z':
  		zaza 'z': zaza 'z': zaza 'z': zaza 'z':
  		zaza 'z': zaza 'z': zaza 'z': zaza 'z':
  			zazzzaz('z');
  			zzaaz;
  		zazaazz:
  			zazzzaz(z);
  		}
  }
  

Η εντολή continue

• Η εντολή continue μας επιτρέπει να συνεχίσουμε την εκτέλεση μιας δομής ελέγχου βρόχου (for, while, do) από το σημείο ελέγχου της συνθήκης.
• Είναι κυρίως χρήσιμη όταν θέλουμε να κάνουμε έναν έλεγχο στην κορυφή του βρόχου για κάποια ειδική περίπτωση.
• Το παρακάτω παράδειγμα μετατρέπει κάθε πέμπτο πεζό φωνήεν σε a και σύμφωνο σε z:
  #include <stdio.h>
  
  main()
  {
          int c, i;
  
          i = 0;
          while ((c = getchar()) != EOF) {
                  if (i++ % 5 != 0) {
                          putchar(c);
                          continue;
                  }
                  switch (c) {
                  case 'a': case 'e': case 'i': case 'o':
                  case 'u': case 'y':
                          putchar('a');
                          break;
                  case 'b': case 'c': case 'd': case 'f':
                  case 'g': case 'h': case 'j': case 'k':
                  case 'l': case 'm': case 'n': case 'p':
                  case 'q': case 'r': case 's': case 't':
                  case 'v': case 'w': case 'x': case 'z':
                          putchar('z');
                          break;
                  default:
                          putchar(c);
                  }
          }
  }
  

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

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

• Brian W. Kernighan and Dennis M. Ritchie. The C Programming Language, pages 55-64. Prentice-Hall, second edition, 1988.

Ασκήσεις

switch, for

1. Να γράψετε ένα πρόγραμμα που να διαβάζει χαρακτήρες από την είσοδό του μέχρι να συναντήσει την τελεία. Οι χαρακτήρες που διαβάζει να εκτυπώνονται σύμφωνα με το διεθνές φωνητικό αλφάβητο: Alpha Bravo Charlie Delta Echo Foxtrot Golf Hotel India Juliet Kilo Lima Mike November Oscar Papa Quebec Romeo Sierra Tango Uniform Victor Whiskey Xray Yankee Zulu. Τα ψηφία 1-9 να εκτυπώνονται με επαναλαμβανόμενα αστέρια (*) αντίστοιχα με το ψηφίο. Χαρακτήρες για τους οποίους δεν υπάρχει αντιστοιχία να εκτυπώνονται ως έχουν. Παράδειγμα:
   Είσοδος:

   Hello 2 you!.
   

   Αποτέλεσμα:

   Hotel Echo Lima Lima Oscar ** Yankee Oscar Uniform!
   

Ορισμός συναρτήσεων

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

• Μπορούμε να ορίσουμε δικές μας συναρτήσεις με τον εξής τρόπο:

  	τύπος αποτελέσματος
  	όνομα συνάρτησης(δηλώσεις παραμέτρων)
  	{
  		δηλώσεις τοπικών μεταβλητών;
  
  		εντολές;
  		return (τιμή);
  	}
  

• Οι παράμετροι της συνάρτησης είναι μια σειρά από τύπους και ονόματα μεταβλητών χωρισμένα με κόμμα.
• Όταν καλείται μια συνάρτηση οι μεταβλητές που ορίστηκαν ως παράμετροι παίρνουν τις τιμές που δόθηκαν στο όρισμα κατά την κλήση.
• Η εντολή return μπορεί να εμφανιστεί σε οποιοδήποτε σημείο της συνάρτησης. Στο σημείο εκείνο σταματά η εκτέλεση της συνάρτηση και ο έλεγχος ροής (control flow) του προγράμματος συνεχίζει από το σημείο που κλήθηκε η συνάρτηση. Η τιμή που ακολουθεί την return είναι η τιμή που επιστρέφει η συνάρτηση.
• Παράδειγμα:
  /*
   * Return x squared
   */
  double
  sqr(double x)
  {
          return (x * x);
  }
  
• Αν η συνάρτηση δεν επιστρέφει κάποια τιμή, τότε ορίζουμε τον τύπο της ως void.
• Αν η συνάρτηση δε δέχεται παραμέτρους τότε γράφουμε στην αντίστοιχη θέση τη λέξη void.
• Παράδειγμα:
  void
  print_hello(void)
  {
          printf("Hello, world\n");
  }
  
• Οι συναρτήσεις μπορούν να οριστούν με οποιαδήποτε σειρά μέσα στο πρόγραμμα. Αν όμως μια συνάρτηση χρησιμοποιηθεί πριν τον ορισμό (definition), τότε πρέπει να προηγηθεί μια δήλωση (declaration) της συνάρτησης. Η δήλωση γίνεται με τη μορφή πρωτοτύπου (prototype) το οποίο έχει την ίδια μορφή με τον ορισμό του ονόματος και των παραμέτρων, αλλά αντί να ακολουθείται από το τμήμα με τις εντολής ακολουθείται μόνο από ένα ";". Παράδειγμα (τυπώνει 25):
  /* Declaration */
  double sqr(double x);
  
  main()
  {
          printf("%g\n", sqr(5))
  }
  
  /* Definition */
  double
  sqr(double x)
  {
          return (x * x);
  }
  

Παράμετροι τιμής

• Οι μεταβλητές που αποτελούν το όρισμα της συνάρτησης αποκτούν την τιμή που θα δώσουμε όταν καλέσουμε τη συνάρτηση.
• Οποιαδήποτε μετατροπή στην τιμή των μεταβλητών αυτών δεν επηρεάζει την τιμή κάποιας μεταβλητής που δόθηκε ως παράμετρος κατά την κλήση της συνάρτησης.
• Παράδειγμα (τυπώνει 10, 20, 10):
  void
  print_n2n(int n)
  {
          printf("%d ", n);
          n = n * 2;
          printf("%d ", n);
  }
  
  main()
  {
          int i = 10;
          print_n2n(i);
          printf("%d\n", i);
  }
  
• Έτσι μπορούμε να χρησιμοποιούμε τις μεταβλητές του ορίσματος σαν κανονικές μεταβλητές χωρίς να χρειάζεται (ούτε και να επιτρέπεται) να τις ορίσουμε μέσα στο σώμα της συνάρτησης.
• Ο τρόπος αυτός κλήσης ονομάζεται κλήση κατ' αξία (call by value).

Καθολικές μεταβλητές

• Οι μεταβλητές που ορίζονται μέσα στο σώμα συναρτήσεων είναι ορατές μόνο από τις αντίστοιχες εντολές μέσα στη συνάρτηση.
• Μπορούμε να ορίσουμε καθολικές (global) μεταβλητές που να είναι ορατές από όλες τις συναρτήσεις αν ο ορισμός γίνει έξω από κάθε συνάρτηση.
• Κατά τον ορισμό μεταβλητών μπορούμε να τους δώσουμε και μια αρχική τιμή με τη χρήση του =. Η τιμή για τις καθολικές μεταβλητές πρέπει να είναι μια σταθερή, για όλες τις άλλες μπορεί να είναι οποιαδήποτε έκφραση. Παράδειγμα (τυπώνει 0 2):
  int k = 0;
  
  void
  increment_k(void)
  {
          k++;
  }
  
  void
  print_k(void)
  {
          printf("%d\n", k);
  }
  
  main()
  {
          print_k();
          increment_k();
          increment_k();
          print_k();
  }
  

Μεταβλητές static

• Οι μεταβλητές που ορίζονται μέσα στις συναρτήσεις χάνουν την τιμή τους όταν ο έλεγχος του προγράμματος βγει έξω από το σώμα της συνάρτησης.
• Μπορούμε να ορίσουμε μια μεταβλητή της οποίας η τιμή διατηρείται από τη μια κλήση στην άλλη αν γράψουμε τη χαρακτηριστικό αποθήκευσης (storage specifier) static πριν από το όνομα της μεταβλητής. Παράδειγμα (τυπώνει 0 1 2):
  void
  counter(void)
  {
          static int i = 0;
  
          printf("%d\n", i++);
  }
  
  main()
  {
          counter();
          counter();
          counter();
  }
  
• Σε αντίθεση με τις μεταβλητές που ορίζονται χωρίς τη λέξη static οι οποίες καταλαμβάνουν χώρο στη μνήμη όσο εκτελείται η συνάρτηση μέσα στην οποία έχουν οριστεί (και όλες οι συναρτήσεις που καλούνται από αυτή), οι μεταβλητές με τρόπο φύλαξης static καταλαμβάνουν χώρο καθ' όλη τη διάρκεια εκτέλεσης του προγράμματος.

Μεταβλητές τοπικές σε μπλοκ

• Τέλος, μπορούμε να ορίσουμε μεταβλητές οι οποίες να είναι ορατές μόνο μέσα σε ένα τμήμα οριζόμενο από αγκύλες. Στην περίπτωση αυτή οι μεταβλητές πρέπει να οριστούν στην αρχή του τμήματος πριν από οποιεσδήποτε εντολές. Παράδειγμα (τυπώνει τον πίνακα πολλαπλασιασμού):
  main()
  {
          int i;
  
          for (i = 1; i < 10; i++) {
                  int j;
  
                  for (j = 1; j < 10; j++)
                          printf("%3d ", i * j);
                  putchar('\n');
          }
  }
  
• Αν υπάρχουν άλλες μεταβλητές ορισμένες έξω από το τμήμα με το ίδιο όνομα, τότε όσο ο έλεγχος του προγράμματος βρίσκεται μέσα στο τμήμα, η μεταβλητή που χρησιμοποιείται είναι αυτή που έχει οριστεί στο τμήμα.
• Η τιμή μιας μεταβλητής που έχει οριστεί μέσα σε ένα τμήμα χάνεται όταν ο έλεγχος του προγράμματος βγει από το τμήμα αυτό.
• Γενικά, καλό είναι οι μεταβλητές να ορίζονται κοντά στο τμήμα που χρησιμοποιούνται. Σε μικρές συναρτήσεις αυτό είναι εφικτό με τον ορισμό τους στην αρχή της συνάρτησης. Όταν όμως μια μεταβλητή έχει ρόλο μόνο μέσα σε ένα περιορισμένο τμήμα, τότε καλό είναι να οριστεί μέσα στο τμήμα.

Ασκήσεις

Σχεδιασμός

1. Σκεφτείτε την υλοποίηση ενός προγράμματος που θα στοιχίζει σωστά άλλα προγράμματα.
   Παράδειγμα εισόδου:

   #include <stdio.h>
   main(){ int i; for (i=0
   ;
   i<10;i++)printf("i =   %d\n", i);}
   

   Παράδειγμα εξόδου:

   #include <stdio.h>
   main()
   {
   	int i;
   	for (i = 0; i < 10; i++)
   		printf("i =   %d\n", i);
   }
   

   Το πρόγραμμα αυτό θα συζητηθεί στο επόμενο μάθημα.

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

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

• Brian W. Kernighan and Dennis M. Ritchie. The C Programming Language, pages 24-25, 83. Prentice-Hall, second edition, 1988.

Παράδειγμα: μορφοποίηση προγραμμάτων

Ο κύκλος ζωής του λογισμικού

• Ανεπίσημες προδιαγραφές
• Επίσημες προδιαγραφές
• Αρχιτεκτονική σχεδίαση
• Λεπτομερής σχεδίαση
• Κωδικοποίηση
• Συνένωση
• Έλεγχος και δοκιμαστική λειτουργία
• Λειτουργία και συντήρηση

Ανεπίσημες προδιαγραφές

Επίσημες προδιαγραφές

#include <stdio.h>

/*
 * Play the bahm boom game:
 * - print ascending numbers;
 * - bahm's at 9 multiples;
 * - boom's at 7 multiples;
 */
main()
{
int i;
for (i = 0; i < 100; i++) {
if (i % 9 == 0) {
printf("{BAHM}\n");
if (i % 9 == 0) {
printf("{BAHM}\n");
} else if (i % 7 == 0) {
printf("{BOOM}\n");
} else {
printf("%d\n", i);
}
}
}

#include <stdio.h>

/*
 * Play the bahm boom game:
 * - print ascending numbers;
 * - bahm's at 9 multiples;
 * - boom's at 7 multiples;
 */
main()
{
	int i;
	for (i = 0; i < 100; i++) {
		if (i % 9 == 0) {
			printf("{BAHM}\n");
			if (i % 9 == 0) {
				printf("{BAHM}\n");
			} else if (i % 7 == 0) {
				printf("{BOOM}\n");
			} else {
				printf("%d\n", i);
			}
		}
	}
}

• Υποθέτουμε ότι όλα τα for, if, while, do, else κλπ ακολουθούνται από εντολές μέσα σε { }.
• Μετά από κάθε { η στοίχιση αυξάνει κατά ένα επίπεδο.
• Μετά από κάθε } η στοίχιση μειώνεται κατά ένα επίπεδο.
• Κατά την επεξεργασία σταθερών χαρακτήρων και συμβολοσειρών οι παραπάνω δύο κανόνες δεν ισχύουν.
• Κατά την επεξεργασία σχολίων δεν αλλάζουμε τίποτα.
• Οι γραμμές που αρχίζουν με # δεν αλλάζουν καθόλου.

Αρχιτεκτονική σχεδίαση

• Θέλουμε με κάποιο τρόπο να ξέρουμε τι στοιχείο επεξεργαζόμαστε ( κανονικό πρόγραμμα, συμβολοσειρά, σταθερά χαρακτήρα, σχόλιο, κλπ).
• Αυτό εκφράζεται από την κατάσταση (state) του προγράμματος.
• Η επεξεργασία για κάθε κατάσταση θα γίνεται χωριστά.
• Ορίζουμε τις παρακάτω καταστάσεις:
  • NORMAL,
  • HASH,
  • SLASH,
  • COMMENT,
  • STAR,
  • STRING,
  • BACKSLASH_STRING,
  • CHARACTER,
  • BACKSLASH_CHARACTER,
  • NEWLINE,
  και το αντίστοιχο διάγραμμα μετάπτωσης κατάστασης (state transition diagram)
• Στην αρχή της γραμμής αγνοούμε τα κενά και τυπώνουμε τα δικά μας κενά.
• Οι χαρακτήρες { } αλλάζουν το επίπεδο στοίχισης.
• Η στοίχιση γίνεται από ξεχωριστή συνάρτηση.

Λεπτομερής σχεδίαση

• Σχεδιάζουμε το πλήρες διάγραμμα μετάπτωσης καταστάσεων.
  
  
• Κάθε χαρακτήρας που διαβάζεται στέλνεται στην αντίστοιχη συνάρτηση επεξεργασίας.
• Στην κατάσταση NEWLINE χειριζόμαστε το θέμα της στοίχισης πριν γίνει η μετάπτωση στην κατάσταση NORMAL.
• Στην κατάσταση NORMAL χειριζόμαστε την αλλαγή επιπέδου στοίχισης με τα { και }.

Κωδικοποίηση

Έλεγχος μονάδων

• Κατά τον έλεγχο μονάδων (unit test) ελέγχουμε ξεχωριστά συγκεκριμένα τμήματα του συστήματος για να δούμε ότι τα τμήματα αυτά είναι γραμμένα σωστά.
• Αυτό μπορεί να γίνει γράφοντας ειδικό κώδικα για να ελέγχει κάθε τμήμα. Παράδειγμα:
  ...
  main()
  {
          process('/');
          process('*');
          if (state == COMMENT)
                  printf("Test 1 OK");
          else
                  printf("Test 1 FAIL: Comment enter error");
  
          state = COMMENT;
          process('*');
          process(' ');
          process('/');
          if (state == COMMENT)
                  printf("Test 2 OK");
          else
                  printf("Test 2 FAIL: Comment end error");
  
          state = COMMENT;
          process('*');
          process('/');
          if (state != COMMENT)
                  printf("Test 3 OK");
          else
                  printf("Test 3 FAIL: Comment end error");
  
          printf("Test 4: Bellow you should see:\n[\t\t\t]\n");
          indent_level = 3;
          putchar('[');
          indent();
          printf("]\n");
  }
  

Ασκήσεις

Η γλώσσα HTML

• Η HTML (Hypertext Markup Language) είναι η γλώσσα στην οποία γράφονται οι σελίδες στο World Wide Web. Αποτελείται από κείμενο το οποίο εμφανίζεται στην οθόνη του φυλλομετρητή (browser) και από εντολές που περικλείονται μέσα σε < και >.
• Μερικές εντολές είναι οι παρακάτω:
  • <p> Αλλαγή παραγράφου.
  • <li> Αρχή νέας γραμμής σε λίστα
  • <h1> Αρχή επικεφαλίδας επιπέδου 1
  • <h2> Αρχή επικεφαλίδας επιπέδου 2
• Μπορείτε να δείτε το περιεχόμενο μιας σελίδας σε HTML με την εντολή του φυλλομετρητή View - Source.
• Μπορείτε να φυλάξετε το περιεχόμενο μιας σελίδας στο δίσκο σας σε μορφή HTML με την εντολή του φυλλομετρητή File - Save.

Εμφάνιση HTML

• Γράψτε ένα πρόγραμμα το οποίο τυπώνει στην οθόνη το περιεχόμενο ενός αρχείου HTML με τον παρακάτω τρόπο:
  • Όταν το κείμενο περνάει τη στήλη 60 να αλλάζει γραμμή μετά το πρώτο τέλος λέξης.
  • Οι υπόλοιπες αλλαγές σειράς μέσα στο αρχείο αγνοούνται.
  • Η εντολή <p> να αρχίζει νέα σειρά
  • Η εντολή <li> να αρχίζει νέα σειρά με τους χαρακτήρες "- "
  • Η εντολή <h1> να τυπώνει σε νέα σειρά τον αριθμό της επικεφαλίδας επιπέδου 1 και να τον αυξάνει κατά ένα. Επιπλέον ξαναρχίζει την αρίθμηση των επικεφαλίδων επιπέδου 2 από την αρχή.
  • Η εντολή <h2> να τυπώνει σε νέα σειρά τον αριθμό της επικεφαλίδας επιπέδου 1 ακολουθούμενο από "." και τον αριθμό της επικεφαλίδας επιπέδου 2 τον οποίο και θα αυξάνει κατά ένα.
  • Οι υπόλοιπες εντολές μέσα σε < > θα αγνοούνται.
  • Οι εντολές μπορούν να δίνονται με κεφαλαία ή με μικρά γράμματα. Έτσι για παράδειγμα οι εντολές <l> και <L> θα αντιμετωπίζονται με τον ίδιο τρόπο.
• Δοκιμάστε το πρόγραμμά σας στο περιεχόμενο της σελίδας "παράδειγμα" του κεφαλαίου αυτού των σημειώσεων.
• Σημείωση: Το πρόγραμμα δε χρειάζεται να εξετάζει αν οι εντολές με τις οποίες ενεργεί περιέχουν μόνο τα συγκεκριμένα στοιχεία της εντολής. Αφού συναντήσει την εντολή θα αγνοεί όλα τα υπόλοιπα στοιχεία της μέχρι να συναντήσει >. Έτσι για παράδειγμα οι εντολές <l> και <li> θα αντιμετωπίζονται με τον ίδιο τρόπο.

Παράδειγμα εισόδου

<h1> Κύρια επικεφαλίδα</h1>
<h2> Επικεφαλίδα επιπέδου 2 </h2>
<p>
Κείμενο το οποίο
πρέπει
να εμφανίζεται στοιχισμένο μέχρι τη στήλη 60.
Οι
λέξεις
αυτές
δεν
πρέπει
να
εμφανίζονται
σε ξεχωριστές
γραμμές.
<p>
Εδώ αλλάζουμε γραμμή, αλλά η γραμμή αυτή είναι πάρα πολύ μεγάλη και πρέπει να σπάσει
<h2> Άλλη επικεφαλίδα επιπέδου 2 </h2>
<p>
Λίστα με στοιχεία (ένα σε κάθε γραμμή):
<ul>
<li> Στοιχείο 1 <LI> Στοιχείο 2
<li> Στοιχείο 3
<li> Στοιχείο 4
</ul>

Παράδειγμα εξόδου

1.  Κύρια επικεφαλίδα 
1.1.  Επικεφαλίδα επιπέδου 2  
 Κείμενο το οποίο πρέπει να εμφανίζεται στοιχισμένο μέχρι τη στήλη
60. Οι λέξεις αυτές δεν πρέπει να εμφανίζονται σε ξεχωριστές γραμμές.

 Εδώ αλλάζουμε γραμμή, αλλά η γραμμή αυτή είναι πάρα πολύ μεγάλη
και πρέπει να σπάσει 
1.2.  Άλλη επικεφαλίδα επιπέδου 2  
 Λίστα με στοιχεία (ένα σε κάθε γραμμή):  
-  Στοιχείο 1 
-  Στοιχείο 2 
-  Στοιχείο 3 
-  Στοιχείο 4   

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

• Alfred V. Aho, Ravi Sethi, and Jeffrey D. Ullman. Compilers, Principles, Techniques, and Tools, chapter Lexical Analysis, pages 83-158. Addison-Wesley, 1985.

• Joseph Arceneaux. CUG392 --- GNU indent v1.8. C Users Journal, 12(1):88, January 1994.

• T. Berners-Lee and D. Connolly. RFC 1866: Hypertext Markup Language --- 2.0, November 1995.

• Roel Wieringa. A survey of structured and object-oriented software specification methods and techniques. ACM Computing Surveys, 30(4):459-527, December 1998.

Παράδειγμα HTML

Επικεφαλίδα επιπέδου 2

Κείμενο το οποίο πρέπει να εμφανίζεται στοιχισμένο μέχρι τη στήλη 60. Οι λέξεις αυτές δεν πρέπει να εμφανίζονται σε ξεχωριστές γραμμές.

Εδώ αλλάζουμε γραμμή, αλλά η γραμμή αυτή είναι πάρα πολύ μεγάλη και πρέπει να σπάσει

Άλλη επικεφαλίδα επιπέδου 2

Λίστα με στοιχεία (ένα σε κάθε γραμμή):

• Στοιχείο 1
• Στοιχείο 2
• Στοιχείο 3
• Στοιχείο 4

HTML example (english)

Heading level 2

Text that should appear wrapped at column 60. These words should not be spread on single lines.

A new paragraph begins at this point, but this line is quite long and should be split.

Another heading level 2

Element list (one per line):

• Element 1
• Element 2
• Element 3
• Element 4

Πίνακες

Ορισμός και χρήση πινάκων

• Μπορούμε να ορίσουμε μια ομάδα μεταβλητών ίδιου τύπου στην οποία θα έχουμε πρόσβαση με βάση το όνομά της και έναν δείκτη (index) ως πίνακα (array).
• Ο ορισμός γίνεται ως εξής:

  	τύπος όνομα[αριθμός στοιχείων]
  

  Παράδειγμα:
          int values[10];
  
  ορίζει έναν πίνακα 10 ακεραίων με όνομα values.
• Πρόσβαση στα στοιχεία ενός πίνακα έχουμε με βάση το όνομα του πίνακα και έναν ακέραιο δείκτη. Ο δείκτης πρέπει να λαμβάνει τιμές από το 0 μέχρι τον αριθμό των στοιχείων - 1. Το παρακάτω παράδειγμα διαβάζει 10 ακεραίους και τους τυπώνει με την ανάποδη σειρά:
  #include <stdio.h>
  
  main()
  {
          int values[10];
          int i;
  
          for (i = 0; i < 10; i++)
                  scanf("%d", &values[i]);
          for (i = 9; i > -1; i--)
                  printf("%d\n", values[i]);
  }
  

Πίνακες πολλαπλών διαστάσεων

• Μπορούμε να ορίσουμε πίνακες πολλαπλών διαστάσεων ακολουθώντας τον ορισμό των στοιχείων της μιας διάστασης από τον ορισμό των στοιχείων της επόμενης. Παράδειγμα:
          double matrix[4][3];
  
• Ο παραπάνω ορισμός ορίζει απλώς έναν πίνακα τεσσάρων στοιχείων (γραμμών) κάθε ένα από τα οποία είναι ένας πίνακας τριών στοιχείων (στηλών).
• Η πρόσβαση στα στοιχεία των πινάκων πολλαπλών διαστάσεων γίνεται όπως και στα στοιχεία των πινάκων μιας διάστασης. Παράδειγμα (τυπώνει όλα τα στοιχεία του πίνακα):
          int i, j;
  
          for (i = 0; i < 4; i++) {
                  for (j = 0; j < 3; j++)
                          printf("%g ", matrix[i][j]);
                  putchar('\n');
          }
  

Πίνακες ως ορίσματα

• Για να ορίσουμε ότι μια παράμετρος συνάρτησης είναι πίνακας γράφουμε τον ορισμό του πίνακα στις παραμέτρους της συνάρτησης. Η πρώτη διάσταση του πίνακα μπορεί να παραληφθεί. Παράδειγμα:
  /*
   * Return the sum of a vector v elements.
   * The vector contains n elements.
   */
  double
  vector_sum(double v[], int n)
  {
          int i;
          double sum = 0.0;
  
          for (i = 0; i < n; i++)
                  sum = sum + v[i];
          return (sum);
  }
  
• Για να περάσουμε έναν πίνακα ως όρισμα σε μια συνάρτηση γράφουμε απλώς το όνομά του στις παραμέτρους. Παράδειγμα:
          double v[100];
  
          /* [...] */
          printf("Sum = %g\n", vector_sum(v, 100));
  
• Όταν περνάει ένας πίνακας ως όρισμα σε συνάρτηση δεν περνάει ένα αντίγραφο της τιμής του, όπως όταν περνάει μια απλή μεταβλητή, αλλά μια αναφορά (reference) στον ίδιο τον πίνακα. Αλλαγές στα στοιχεία του πίνακα που γίνονται μέσα στη συνάρτηση αναφέρονται στον πίνακα που πέρασε ως όρισμα. Ο τρόπος αυτός κλήσης λέγεται κλήση κατ' αναφορά (call by reference).
  Παράδειγμα:
  /*
   * Set all n elements of vector v to the value d
   */
  void
  vector_setvalue(double v[], int n, double d)
  {
          int i;
  
          for (i = 0; i < n; i++)
                  v[i] = d;
  }
  
  main()
  {
          double vals[50];
  
          /* Zero vals */
          vector_setvalue(vals, 50, 0.0);
  }
  

Αρχικοποίηση πινάκων

• Μπορούμε να δώσουμε αρχικές τιμές στα στοιχεία ενός πίνακα αν μετά τη δήλωσή του γράψουμε τις τιμές των στοιχείων χωρισμένες με κόμματα μέσα σε άγκιστρα. Παράδειγμα:
          int days[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
  
• Στην περίπτωση προσδιορισμού αρχικών τιμών μπορούμε να μην προσδιορίσουμε το μέγεθος του πίνακα και να αφήσουμε τον μεταγλωττιστή να το υπολογίσει αυτόματα με βάση τον αριθμό τιμών που έχουν χρησιμοποιηθεί. Παράδειγμα:
          int days[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
  
• Αν κάποιες τιμές δεν προσδιοριστούν, τότε αυτές θα είναι μηδέν.
• Μπορούμε να προσδιορίσουμε τιμές για πίνακες πολλών διαστάσεων περικλείοντας τιμές μέσα σε άγκιστρα μέσα σε άλλα άγκιστρα. Παράδειγμα:
          double unit_matrix[3][3] = {
                                          {1.0, 0.0, 0.0},
                                          {0.0, 1.0, 0.0},
                                          {0.0, 0.0, 1.0}
                                  };
  

Πρόσθετοι τύποι και μετατροπή μεταξύ τύπων

• Ο προσδιοριστής τύπου long μας επιτρέπει τον ορισμό ακεραίων τιμών με πεδίο τιμών συχνά μεγαλύτερο από το πεδίο τιμών του τύπου int.
• Ο προσδιοριστής τύπου short μας επιτρέπει τον ορισμό ακεραίων τιμών με πεδίο τιμών συχνά μικρότερο από το πεδίο τιμών του τύπου int.
• Η σχέση των παραπάνω τύπων είναι η εξής:
  • Ο τύπος int είναι αυτός που προσφέρει κατά βάση η αρχιτεκτονική του επεξεργαστή για υπολογισμούς ακεραίων.
  • Ο τύπος long προσφέρει εύρος τιμών μεγαλύτερο ή ίσο με τον τύπο int.
  • Ο τύπος short προσφέρει εύρος τιμών μικρότερο ή ίσο με τον τύπο int.
  • Τύπους short και long χρησιμοποιούμε μόνο σε ειδικές περιπτώσεις όπως σε προγράμματα συστήματος ή σε χρήση έτοιμων συναρτήσεων που απαιτούν τέτοιους τύπους.
• Ο απρόσημος (unsigned) προσδιορισμός τύπου unsigned εφαρμόζεται πριν από τον ορισμό ακεραίων τύπων (char, short, int, long) για να ορίσει ότι η αντίστοιχος τύπος αφορά μόνο θετικές τιμές. Με τον τρόπο αυτό μπορούμε να διπλασιάσουμε το πεδίο τιμών ενός τύπου. Παράδειγμα:
          unsigned int i;
  
• Αντίστοιχα ο προσημασμένος (signed) προσδιορισμός τύπου signed ορίζει ότι ο αντίστοιχος ακέραιος τύπος αφορά θετικές και αρνητικές τιμές.
• Οι τύποι short, int και long είναι πάντα signed. Ο τύπος char μπορεί να είναι signed ή unsigned ανάλογα με την αρχιτεκτονική του υπολογιστή και τον μεταγλωττιστή.
• Με τη χρήση των προσδιορισμών signed και unsigned μπορούμε να ορίσουμε με ακρίβεια το πεδίο τιμών του τύπου char.
• Για να τυπώσουμε τιμές τύπου long χρησιμοποιούμε τον προσδιορισμό της printf %ld ενώ για να τυπώσουμε τιμές τύπου unsigned χρησιμοποιούμε τον προσδιορισμό %u. Οι τιμές τύπου short μετατρέπονται αυτόματα σε int όταν περνούν σε συναρτήσεις.
• Μπορούμε να προσδιορίσουμε τη προσαρμογή (cast) μιας τιμής ενός τύπου σε έναν άλλο τύπο με τη χρήση του μοναδικού τελεστή προσαρμογής που γράφεται ως "(τύπος)" σύμφωνα με την παρακάτω σύνταξη:

  	(τύπος)τιμή
  

  Παράδειγμα (τυπώνει 3):
  main()
  {
          int i;
          double d = 3.1;
  
          i = (int)d;
          printf("%d\n", i);
  }
  

Ασκήσεις

Πίνακες

1. Γράψτε ένα πρόγραμμα το οποίο διαβάζει χαρακτήρες από την είσοδό του μέχρι το τέλος του αρχείου (EOF). Στη συνέχεια τυπώνει ένα ραβδόγραμμα με αστεράκια για κάθε έναν από τους εμφανιζόμενους χαρακτήρες. Επιπλέον για τους χαρακτήρες που εμφανίζονται στην είσοδο του προγράμματος τις μέγιστες και τις ελάχιστες φορές εμφανίζει τον αντίστοιχο χαρακτήρα καθώς και τον αριθμό των φορών που εμφανίστηκε.

   Παράδειγμα εξόδου:

   a ********
   b ****
   e ************
   z *
   Most frequent: e; 12 time(s).
   Least frequent: z; 1 time(s).
   

   Σημείωση: Αν η είσοδος του προγράμματος δεν περιέχει ελληνικούς χαρακτήρες, τότε μπορείτε να φυλάξετε τη συχνότητα του κάθε χαρακτήρα σε έναν πίνακα 128 θέσεων με δείκτη τον ίδιο το χαρακτήρα.

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

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

• Brian W. Kernighan and Dennis M. Ritchie. The C Programming Language, pages 110-112, 9, 37. Prentice-Hall, second edition, 1988.

Οργάνωση δεδομένων: δομές, ενώσεις, απαριθμήσεις, τύποι

Δομή

• Μπορούμε να δηλώσουμε μια δομή (structure) η οποία θα περιέχει στο εσωτερικό της δεδομένα διαφορετικών τύπων ή σημασίας με τον ορισμό struct. Η δήλωση της δομής γίνεται σύμφωνα με την παρακάτω σύνταξη:

  struct ετικέτα δομής {
  	δήλωση μεταβλητής1;
  	δήλωση μεταβλητής2;
  	...
  };
  

  Το παρακάτω παράδειγμα δηλώνει ένα σημείο το οποίο αποτελείται από δύο ακέραιες τιμές x και y:
  struct s_point {
          int x;
          int y;
  };
  
  Αντίστοιχα το παρακάτω παράδειγμα δηλώνει μια δομή που περιέχει τα στοιχεία ενός φοιτητή για ένα μάθημα:
  struct s_student {
          char name[50];
          int grade;
  };
  
• Μετά τη δήλωση της δομής η δεσμευμένη λέξη struct ακολουθούμενη από την ετικέτα δομής (structure tag) αποτελεί νέο τύπο.
• Έχοντας δηλώσει την αντίστοιχη δομή μπορούμε να ορίσουμε μεταβλητές με βάση τη δομή αυτή. Το παρακάτω παράδειγμα ορίζει μια μεταβλητή p τύπου struct s_point.
  struct s_point p;
  
• Πρόσβαση στα στοιχεία μιας μεταβλητής τύπου struct έχουμε με τη σύνταξη μεταβλητή.στοιχείο. Παράδειγμα:
          printf("p=(%d, %d)\n", p.x, p.y);
  
• Μπορούμε να ορίσουμε μεταβλητές με βάση μια δομή συνδυάζοντας τη δήλωση της δομής με τον ορισμό των μεταβλητών. Στην περίπτωση αυτή μπορούμε να παραλείψουμε και το όνομα της ετικέτας. Παράδειγμα:
  struct {
          int x, y;
  } p1, p2;
  
  p1.x = 4;
  p1.y = 5;
  
• Μπορούμε να αντιγράψουμε τα στοιχεία μιας δομής σε μια άλλη ίδια με τη χρήση του =. Παράδειγμα:
  struct {
          int x, y;
  } p1, p2;
  
  p1.x = 4;
  p1.y = 5;
  p2 = p1;
  
• Ακόμα, μπορούμε να περάσουμε δομές σαν παραμέτρους σε συναρτήσεις και να ορίσουμε ότι το αποτέλεσμα μιας συνάρτησης είναι μια δομή. Παράδειγμα (επιστρέφει ένα σημείο ανάμεσα σε δύο άλλα):
  struct s_point {
          int x, y;
  };
  
  struct s_point
  middle(struct s_point a, struct s_point b)
  {
          struct s_point c;
  
          c.x = (a.x + b.x) / 2;
          c.y = (a.y + b.y) / 2;
          return (c);
  }
  
• Μπορούμε να εκχωρήσουμε αρχικές τιμές σε μια ένωση ακολουθώντας τον ορισμό της από = και τις αντίστοιχες τιμές για τα μέλη της μέσα σε άγκιστρα. Παράδειγμα:
  struct s_point origin = {0, 0};
  

Ένωση

• Μπορούμε να δηλώσουμε μια ένωση (union) η οποία θα περιέχει εναλλακτικά στο εσωτερικό της δεδομένα διαφορετικών τύπων ή σημασίας με τον ορισμό union. Η δήλωση της ένωσης γίνεται σύμφωνα με την παρακάτω σύνταξη:

  union ετικέτα ένωσης {
  	δήλωση μεταβλητής1;
  	δήλωση μεταβλητής2;
  	...
  };
  

  Το παρακάτω παράδειγμα δηλώνει μια ένωση η οποία μπορεί να περιέχει έναν ακέραιο ή έναν αριθμό κινητής υποδιαστολής:
  union u_value {
          int i;
          double d;
  };
  
• Έχοντας δηλώσει την αντίστοιχη ένωση μπορούμε να ορίσουμε μεταβλητές με βάση την ένωση αυτή. Το παρακάτω παράδειγμα ορίζει μια μεταβλητή v τύπου union u_value.
  union u_value v;
  
• Πρόσβαση στα στοιχεία μιας μεταβλητής τύπου union έχουμε με τη σύνταξη μεταβλητή.στοιχείο. Παράδειγμα:
          printf("v=%d\n", u.i);
  
• Προσοχή: όταν αποθηκεύσουμε ένα στοιχείο σε μια ένωση οι τιμές των άλλων στοιχείων παύουν να είναι έγκυρες.
• Αρχική τιμή μπορούμε να δώσουμε μόνο στο πρώτο στοιχείο της ένωσης.
• Συχνά, για να ξέρουμε το είδος της τιμής που αποθηκεύει μια ένωση ορίζουμε μια δομή που περιέχει:
  • μια απαρίθμηση (ορισμό και πεδίο) με τους τύπους των τιμών και
  • μια ένωση (ορισμό και πεδίο) με τις τιμές.
  Παράδειγμα:
  struct s_value {
          enum {
                  T_INT,
                  T_DOUBLE,
                  T_CHAR
          } type;                 /* Value type */
          union {
                  int i;
                  double d;
                  char c;
          } v;                    /* Actual value */
  };
  
  /*
   * Read an integer and return a proper struct s_value
   */
  struct s_value
  read_int(void)
  {
          struct s_value a;
  
          a.type = T_INT;
          scanf("%d", &a.v.i);
          return (a);
  }
  
  /*
   * Read a double and return a proper struct s_value
   */
  struct s_value
  read_double(void)
  {
          struct s_value a;
  
          a.type = T_DOUBLE;
          scanf("%lg", &a.v.d);
          return (a);
  }
  
  /*
   * Read a character and return a proper struct s_value
   */
  struct s_value
  read_char(void)
  {
          struct s_value a;
  
          a.type = T_CHAR;
          a.v.c = getchar();
          return (a);
  }
  
  /*
   * Print a struct s_value
   */
  void
  print_value(struct s_value a)
  {
          switch (a.type) {
          case T_INT:
                  printf("%d", a.v.i);
                  break;
          case T_DOUBLE:
                  printf("%lg", a.v.d);
                  break;
          case T_CHAR:
                  putchar(a.v.c);
                  break;
          default:                /* Defensive programming */
                  printf("Bad value type %d\n", a.type);
                  break;
          }
  }
  

Απαρίθμησης

• Μπορούμε να ορίσουμε δικές μας ομάδες σταθερών ακέραιου τύπου με τον ορισμό σταθερών απαρίθμησης (enumeration). Αυτός γίνεται με την παρακάτω σύνταξη:

  enum ετικέτα_απαρίθμησης {
  	όνομα σταθεράς 1,
  	όνομα σταθεράς 2,
  	...
  };
  

  Παράδειγμα:
  enum states {
          COMMENT,
          STRING,
          CODE
  };
  
• Οι σταθερές της περιοχής λαμβάνουν τιμές αρχίζοντας από το 0. Κάθε επόμενη σταθερά έχει τιμή 1 παραπάνω από την προηγούμενη.
• Μπορούμε να ορίσουμε συγκεκριμένη τιμή για μια σταθερά με τη χρήση της σύνταξης: όνομα = ακέραια τιμή.
  Παράδειγμα:
  enum escapes {
          NEWLINE = '\n',
          BELL = '\a',
          TAB = '\t'
  };
  
• Με βάση τον ορισμό μιας απαρίθμησης μπορούμε να ορίσουμε μεταβλητές του τύπου αυτού και να τους αναθέσουμε αντίστοιχες τιμές:
          enum state s;
          enum escapes c;
  
          s = CODE;
          c = NEWLINE;
  
• Οι τιμές της απαρίθμησης καθώς και οι αντίστοιχες μεταβλητές είναι συμβατές με τιμές και μεταβλητές τύπου int.

Ορισμός τύπων με την typedef

• Μπορούμε να ορίσουμε ένα νέο όνομα για κάποιον υπάρχοντα τύπο με τη χρήση της εντολής typedef. Η σύνταξη της typedef είναι είναι ανάλογη με τον ορισμό μιας μεταβλητής:

  typedef τύπος όνομα;
  

  Παράδειγμα:
  typedef int age;
  
  typedef struct {
          int date;               /* 1-31 */
          int month;              /* 1-12 */
          int year;               /* FOUR DIGIT */
  } date;
  
  typedef double vector[3];
  
  typedef double matrix[4][3];
  
• Μετά τον ορισμό αυτό μπορούμε να χρησιμοποιούμε το νέο όνομα οπουδήποτε θα χρησιμοποιούσαμε τον αντίστοιχο τύπο. Παράδειγμα:
  void
  print_date(date d)
  {
          printf("%d/%d/%d", d.date, d.month, d.year);
  }
  
• Μπορούμε να χρησιμοποιήσουμε την typedef για να κάνουμε τα προγράμματά μας πιο κατανοητά και φορητά ανάμεσα σε διαφορετικές αρχιτεκτονικές υπολογιστών.

Ασκήσεις

Δομές

1. Να γραφεί πρόγραμμα σε C το οποίο να υλοποιεί αριθμομηχανή μιγαδικών αριθμών σύμφωνα με τις παρακάτω προδιαγραφές:
   • Το πρόγραμμα διαβάζει από το χρήστη ένα ζεύγος αριθμών Α, B, το σύμβολο μιας από τις τέσσερεις πράξεις Σ, ένα ακόμα ζεύγος αριθμών Γ, Δ, και τυπώνει το αποτέλεσμα (Α + Bi) Σ (Γ + Δi).
   • Όταν το αποτέλεσμα είναι (0 + 0i) το πρόγραμμα να τερματίζει τη λειτουργία του.
   Οι μιγαδικοί αριθμοί να οριστούν με τη χρήση δομών. Καλό είναι κάθε πράξη να υλοποιείται από ξεχωριστή συνάρτηση.

   Παράδειγμα:

   Enter number a:5 3
   Enter operator:+
   Enter number b:1 2
   Result=6 + 5i
   Enter number a:1 1
   Enter operator:*
   Enter number b:1.5 2
   Result=-0.5 + 3.5i
   

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

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

• Brian W. Kernighan and Dennis M. Ritchie. The C Programming Language, pages 127-133, 147. Prentice-Hall, second edition, 1988.

Δείκτες και δυναμικές δομές δεδομένων

Διάταξη των δεδομένων και του κώδικα στη μνήμη

• Στους υπολογιστές αρχιτεκτονικής von Neuman ο κώδικας του προγράμματος αποθηκεύεται μαζί με τα αντίστοιχα δεδομένα στην κεντρική μνήμη του υπολογιστή.
• Η μνήμη είναι συνήθως διατεταγμένη με τρόπο τέτοιο ώστε κάθε στοιχείο της να μπορεί να οριστεί μονοσήμαντα από ένα συγκεκριμένο αριθμό. Ο αριθμός αυτός καλείται διεύθυνση (address) του στοιχείου.
• Όλα τα στοιχεία ενός προγράμματος που καταλαμβάνουν χώρο στη μνήμη (μεταβλητές όλων των τύπων και συναρτήσεις) έχουν μια συγκεκριμένη διεύθυνση.
• Επιπλέον το λειτουργικό σύστημα μας επιτρέπει να ζητήσουμε να διατεθεί στο πρόγραμμά μας, κατά την ώρα της εκτέλεσής του, πρόσθετη μνήμη.
• Ο τύπος που μας επιτρέπει να ορίσουμε μεταβλητές που να περιέχουν διευθύνσεις μνήμης καλείται δείκτης (pointer).

Δήλωση δεικτών

• Ο ορισμός ενός δείκτη γίνεται με τη σύνταξη:

  	τύπος *
  

• Έτσι για παράδειγμα ο τύπος int * ορίζει έναν δείκτη σε ακέραιους.
• Το παρακάτω παράδειγμα δηλώνει μια μεταβλητή iptr που είναι δείκτης σε ακέραιους.
          int *iptr;
  

Ο τελεστής &

• Για να πάρει ένας δείκτης μια τιμή πρέπει να μπορέσουμε να βρούμε τη διεύθυνση της μνήμης ενός στοιχείου. Αυτό το επιτρέπει ο μοναδιαίος τελεστής &.
• Ο τελεστής & εφαρμοζόμενος σε ένα στοιχείο στο οποίο μπορεί να γίνει ανάθεση τιμής (π.χ. μεταβλητή) το μετατρέπει σε ένα δείκτη στο στοιχείο αυτό.
• Το παρακάτω παράδειγμα ορίζει ένα δείκτη σε ακέραιο (iptr) και θέτει την τιμή του στη διεύθυνση της μεταβλητής i.
          int *iptr;
          int i;
  
          iptr = &i;
  

Χρήση δεικτών

• Ο μοναδιαίος τελεστής * εφαρμοζόμενος σε ένα δείκτη μας επιτρέπει να αναθέσουμε μια τιμή αντίστοιχου τύπου στην τιμή που δείχνει ο δείκτης.
• Το παρακάτω παράδειγμα θέτει την τιμή της μεταβλητής i σε 5:
          int *iptr;
          int i;
  
          iptr = &i;
          *iptr = 5;
  

Κλήση κατ' αναφορά

• Με το συνδυασμό των τελεστών & και * μπορούμε να ορίσουμε συναρτήσεις που να αλλάζουν την τιμή μεταβλητών που περνάν σε αυτές ως δείκτες.
• Στο παρακάτω παράδειγμα η συνάρτηση int_swap αλλάζει μεταξύ τους τις τιμές των δύο δεικτών σε ακέραιους που είναι οι παράμετροί της. Το παρακάτω παράδειγμα τυπώνει 2, 1:
  void
  int_swap(int *i1, int *i2)
  {
          int tmp;
  
          tmp = *i1;
          *i1 = *i2;
          *i2 = tmp;
  }
  
  main()
  {
          int a, b;
  
          a = 1;
          b = 2;
          int_swap(&a, &b);
          printf("%d, %d\n", a, b);
  }
  
• Ο τρόπος αυτός κλήσης ονομάζεται κλήση κατ' αναφορά. Σε ορισμένες γλώσσες προγραμματισμού υποστηρίζεται κατευθείαν από τη γλώσσα χωρίς τη χρήση ειδικών τελεστών.

Αριθμητική με δείκτες

• Το όνομα ενός πίνακα είναι ουσιαστικά ένας δείκτης στο πρώτο στοιχείο του.
• Όταν προσθέτουμε ή αφαιρούμε από έναν δείκτη μια σταθερή τιμή, κάνουμε το δείκτη να δείχνει στο προηγούμενο ή στο επόμενο στοιχείο
• Με τον τρόπο αυτό μπορούμε να διασχίσουμε τα στοιχεία ενός πίνακα. Το παρακάτω παράδειγμα μηδενίζει όλα τα στοιχεία του πίνακα α:
          int a[10];
          int *iptr;
  
          for (iptr = a; iptr < &a[10]; iptr++)
                  *iptr = 0;
  
• Στην πραγματικότητα για έναν πίνακα a η έκφραση a[i] είναι συντομογραφία της έκφρασης *(a + i).

Ο τελεστής sizeof

• Ο τελεστής sizeof επιστρέφει το μέγεθος της μεταβλητής ή του τύπου στον οποίο εφαρμόζεται. Το μέγεθος αυτό εκφράζεται σε bytes.
• Παράδειγμα (τυπώνει 1, 2, 4, 4, 40, 1 σε υπολογιστές Pentium):
  main()
  {
          char c;
          short s;
          int i;
          double d;
          int a[10];
  
          printf("%d\n", sizeof(c));
          printf("%d\n", sizeof(s));
          printf("%d\n", sizeof(i));
          printf("%d\n", sizeof(d));
          printf("%d\n", sizeof(a));
          printf("%d\n", sizeof(char));
  }
  
• Με τη χρήση της sizeof μπορούμε να γράψουμε κώδικα ο οποίος να μην εξαρτάται από το μέγεθος ενός πίνακα ή ενός τύπου. Παράδειγμα (μηδενίζει τον πίνακα a):
          int a[10];
          int *iptr;
  
          for (iptr = a; iptr < a + sizeof(a) / sizeof(int); iptr++)
                  *iptr = 0;
  

Δυναμική διάθεση μνήμης

• Η συνάρτηση malloc() μας επιτρέπει να ζητήσουμε έναν ελεύθερο χώρο μνήμης για να χρησιμοποιήσουμε στο πρόγραμμά μας.
• Η malloc έχει ως όρισμα το μέγεθος της μνήμης που απαιτούμε και επιστρέφει ένα δείκτη στην αρχή του αντίστοιχου χώρου. Ο τύπος της τιμής που επιστρέφει δεν είναι αντίστοιχος με τον τύπο που χρειαζόμαστε και γι' αυτό πρέπει να χρησιμοποιήσουμε την αντίστοιχη μετατροπή (π.χ. (double *)malloc...).
• Σε περίπτωση που το σύστημα δεν έχει άλλη διαθέσιμη μνήμη η malloc επιστρέφει τη σταθερά NULL.
  Παράδειγμα:
          char *c;
  
          c = (char *)malloc(1000 * sizeof(char));
          if (c == NULL) {
                  printf("Out of memory!\n");
                  return (1);
          }
  
• Με τη χρήση της malloc μπορούμε να δημιουργήσουμε δυναμικά χώρο για πίνακες τους οποίους δηλώνουμε ως δείκτες.
• Το παρακάτω παράδειγμα ζητάει από το χρήστη να ορίσει το μέγεθος ενός πίνακα και στη συνέχεια να δώσει τα στοιχεία του.
  #include <stdlib.h>
  #include <stdio.h>
  
  main()
  {
          int *int_table;         /* Table of integers */
          int nelem;              /* Number of elements */
          int i;
  
          printf("Enter number of elements:");
          scanf("%d", &nelem);
          int_table = (int *)malloc(nelem * sizeof(int));
          for (i = 0; i < nelem; i++) {
                  printf("Element %d=", i);
                  scanf("%d", &int_table[i]);
          }
  }
  
• Η συνάρτηση free(δείκτης) ελευθερώνει το χώρο που έχει επιστραφεί από τη malloc για ανακύκλωση.
• Η συνάρτηση realloc(δείκτης, νέο μέγεθος) λαμβάνει ως όρισμα ένα δείκτη που έχει επιστραφεί από τη malloc και επιστρέφει έναν δείκτη σε χώρο με το νέο μέγεθος που έχει προσδιοριστεί.
  Παράδειγμα:
          int *iptr;
  
          iptr = (int *)malloc(10 * sizeof(int));
          /* iptr[0] to iptr[9] can now be used */
  
          iptr = (int *)realloc(iptr, 20 * sizeof(int));
          /* 
           * iptr[0] to iptr[9] retain old values
           * iptr[0] to iptr[19] can now be used */
           */
  
          free(iptr);
          /* Do not access iptr[0] to iptr[19] from this point onwards */
  
• Οι malloc, free, realloc, NULL ορίζονται στο αρχείο stdlib.h.

Φροντιστηριακές ασκήσεις

1. Συμπληρώστε τον πίνακα με τις τιμές των μεταβλητών μετά την εκτέλεση κάθε μιας από τις παρακάτω εντολές.
           int a, b, c;
           int *ip1, *ip2, *ip3;
   
           a = 3;
           b = 4;
           ip1 = &a;
           *ip1 = 8;
           ip3 = &c;
           ip2 = ip3;
           b = *ip1;
           *ip2 = *ip1;
   

   	a	b	c	ip1	ip2	ip3
   Αρχή	-	-	-	-	-	-
   a = 3	3	-	-	-	-	-
   b = 4	3	4	-	-	-	-
   ip1 = &a	3	4	-	&a	-	-
   *ip1 = 8
   ip3 = &c
   ip2 = ip3
   b = *ip1
   *ip2 = *ip1

2. Υπολογίστε τους τύπους των εκφράσεων δεξιά και αριστερά από κάθε ανάθεση και γράψτε ποιες από τις παρακάτω γραμμές είναι σωστές και ποιες όχι.
           int a, b, c, *p1, *p2, *p3;
           double da, db, dc, *pd1, *pd2, *pd3;
   
           p1 = &a;
           *p1 = 4;
           p2 = &p1;
           *p2 = *c;
           p3 = a;
           p2 = p3;
           pd1 = p2;
           pd2 = &da;
           dc = *pd3;
           db = *p2;
           &a = 43;
   

Ασκήσεις

Δυναμική χρήση της μνήμης

1. Να σχεδιάσετε και να γράψετε ένα πρόγραμμα το οποίο τυπώνει τους χαρακτήρες που διαβάζει με την ανάποδη σειρά. Δεν πρέπει να υπάρχει περιορισμός από το πρόγραμμα στον αριθμό των χαρακτήρων που να μπορεί να δεχτεί.
2. Το παρακάτω πρόγραμμα προσθέτει διανύσματα ν διαστάσεων:
   /*
    * Add two vectors
    *
    * Diomidis Spinellis, December 1998
    */
   
   #include <stdio.h>
   
   /*
    * Print the contents of vector v consisting of n elements
    */
   void
   vector_print(double v[], int n)
   {
           int i;
   
           putchar('(');
           for (i = 0; i < n; i++) {
                   printf("%g", v[i]);
                   if (i < n - 1)
                           printf(", ");
           }
           putchar(')');
   }
   
   
   /*
    * Input a vector v consisting of n elements
    */
   void
   vector_input(double v[], int n)
   {
           int i;
   
           for (i = 0; i < n; i++) {
                   printf("\tEnter element %d: ", i);
                   scanf("%lg", &v[i]);
           }
   }
   
   
   /*
    * Sum vector a and vector b to vector c
    * All vectors consist of n elements
    */
   void
   vector_add(double a[], double b[], double c[], int n)
   {
           int i;
   
           for (i = 0; i < n; i++)
                   c[i] = a[i] + b[i];
   }
   
   main()
   {
           int nelem;
           double a[10], b[10], c[10];
   
           printf("Enter number of vector elements: ");
           scanf("%d", &nelem);
           if (nelem > sizeof(a) / sizeof(double)) {
                   printf("Vector size too large.  The maximum vector size is %d.\n",
                           sizeof(a) / sizeof(double));
                   return (1);
           }
           printf("Enter vector a\n");
           vector_input(a, nelem);
           printf("Enter vector b\n");
           vector_input(b, nelem);
           vector_add(a, b, c, nelem);
           vector_print(a, nelem);
           putchar('+');
           vector_print(b, nelem);
           putchar('=');
           vector_print(c, nelem);
   }
   
   1. Να το μεταγλωττίσετε και να το δοκιμάσετε στη μορφή που είναι.
   2. Να το αλλάξετε έτσι ώστε να μην έχει περιορισμό ως προς το μέγεθος των διανυσμάτων που μπορεί να δεχτεί.
   3. Να το αλλάξετε έτσι ώστε να μην εμφανίζονται καθόλου σε αυτό οι χαρακτήρες [ και ] (χρησιμοποιήστε δείκτες αντί για πίνακες).

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

• Brian W. Kernighan, Dennis M. Ritchie Η γλώσσα προγραμματισμού C. σ. 135-178 (τμήματα) Δεύτερη έκδοση. Κλειδάριθμος, 1988.

• Brian W. Kernighan and Dennis M. Ritchie. The C Programming Language, pages 93-126 (parts). Prentice-Hall, second edition, 1988.

Προσδιορισμός απαιτήσεων, ανάλυση και σχεδίαση

Απαιτήσεις

• στον προσδιορισμό των απαιτήσεων από το σύστημα και
• στον προσδιορισμό των απαιτήσεων από το λογισμικό.

1. Ορισμός του προβλήματος
2. Αιτιολόγηση του προβλήματος
3. Σκοπός του συστήματος και του έργου
4. Σκοπός του συστήματος και του έργου
5. Περιορισμοί στο σύστημα και στο έργο
6. Λειτουργίες ανά συνιστώσα του προβλήματος
   1. Υλικό
   2. Λογισμικό
   3. Άνθρωποι
7. Χαρακτηριστικά χρηστών
8. Περιβάλλοντα
   1. ανάπτυξης,
   2. λειτουργίας και
   3. συντήρησης
9. Στρατηγική λύσης του προβλήματος
10. Προτεραιότητες στα χαρακτηριστικά του συστήματος
11. Κριτήρια αποδοχής του συστήματος
12. Πηγές πληροφοριών
13. Λεξιλόγιο

1. Εισαγωγή
   1. Σκοπός
   2. Έκταση
   3. Ορισμοί, ακρονυμίες και συντομογραφίες
   4. Αναφορές
   5. Γενική εικόνα
2. Γενική περιγραφή
   1. Προοπτική του προϊόντος
   2. Λειτουργίες
   3. Χαρακτηριστικά των χρηστών
   4. Γενικοί περιορισμοί
   5. Παραδοχές και εξαρτήσεις
3. Ειδικές απαιτήσεις
   1. Λειτουργικές απαιτήσεις
      1. Λειτουργική απαίτηση 1
         1. Εισαγωγή
         2. Είσοδοι
         3. Επεξεργασία
         4. Έξοδοι
      2. Λειτουργική απαίτηση 1
      3. ...
      4. Λειτουργική απαίτηση ν
   2. Απαιτήσεις εξωτερικών διαπροσωπειών
      1. Διαπροσωπείες χρήστη (user interfaces)
      2. Διαπροσωπείες υλικού (hardware interfaces)
      3. Διαπροσωπείες λογισμικού (software interfaces)
      4. Διαπροσωπείες επικοινωνιών (communication interfaces)
   3. Απαιτήσεις επίδοσης
   4. Περιορισμοί σχεδίασης
      1. Συμμόρφωση με τα πρότυπα
      2. Περιορισμοί από το υλικό
   5. Ιδιώματα
      1. Διαθεσιμότητα
      2. Ασφάλεια
      3. Συντηρισιμότητα
      4. Μεταφερσιμότητα
   6. Άλλες απαιτήσεις
      1. Βάση δεδομένων
      2. Τρόποι λειτουργίας
      3. Προσαρμογή στο χώρο εγκατάστασης
4. Παραρτήματα
5. Ευρετήριο

Ανάλυση

1. Ροή δεδομένων (data flow)
2. Μηχανή πεπερασμένων καταστάσεων (finite state machine)
3. επικοινωνούσες ταυτόχρονες διεργασίες (communicating concurrent processes)
4. Μοντέλο οντοτήτων σχέσεων (entity relationship models)
5. Εξομοίωση (simulation)
6. Λειτουργική σύνθεση (functional composition)

• το διάγραμμα ροής δεδομένων (data flow diagram),
• τα δομημένα αγγλικά (structured english),
• το λεξικό δεδομένων (data dictionary) και
• το διάγραμμα οντοτήτων συσχετίσεων (entity relationship diagram)

Διάγραμμα ροής δεδομένων

Έτσι, το επόμενο σχήμα παριστάνει το διάγραμμα ροής δεδομένων για έναν απλό ελεγκτή ορθογραφίας. Το κείμενο αρχικά χωρίζεται σε λέξεις (split words) οι οποίες ταξινομούνται (sort). Στη συνέχεια απαλείφονται οι πολλαπλές εμφανίσεις λέξεων (unique). Το λεξικό του συστήματος ενώνεται με το λεξικό του χρήστη (merge). Τέλος, εμφανίζονται οι λέξεις που υπάρχουν στο κείμενο αλλά όχι στα ενωμένα λεξικά (not common).

Λεξικό δεδομένων

Δομικές μονάδες

Έτσι για παράδειγμα το λειτουργικό σύστημα Windows NT μακροσκοπικά χωρίζεται σε συστήματα επικοινωνίας με το χρήστη, επικοινωνίας με το υλικό, βοηθητικά προγράμματα, κλπ. Το σύστημα επικοινωνίας με το χρήστη χωρίζεται στα υποσυστήματα γραφικών, κειμένου, ήχου, ελεγκτών (controls) κλπ. Μικροσκοπικά, οι σύνθετες δομικές μονάδες του υποσυστήματος ελεγκτών μπορεί να είναι ο ελεγκτής για γραφικό πλήκτρο (button), ελεγκτής πεδίο εισόδου (input box), ελεγκτής για κυλιόμενη μπάρα (scrollbar) κλπ. Τέλος, ο ελεγκτής για την κυλιόμενη μπάρα αποτελείται από απλές δομικές μονάδες (συναρτήσεις) που αντιδρούν στις εντολές του χρήστη.

Μερικά παραδείγματα σύνθετων δομικών μονάδων είναι τα παρακάτω:

• η συνάρτηση,
• η διαδικασία,
• η διεργασία (process),
• ο αφηρημένος τύπος δεδομένων (abstract data type),
• η κλάση (class),

Σχεδίαση

• διαδικασιακή σχεδίαση (procedural design)
• σχεδίαση απόκρυψης δεδομένων (data hiding design)
• σχεδίαση με αφηρημένους τύπους (abstract data type design)
• αντικειμενοστρεφής σχεδίαση (object-oriented design)

Για την αποτύπωση του αρχιτεκτονικού σχεδίου της δομής του προγράμματος χρησιμοποιείται συχνά το διάγραμμα δομής προγράμματος (program structure chart). Στο διάγραμμα αυτό κάθε δομική μονάδα παριστάνεται από έναν κόμβο και κάθε κλήση από μια δομική μονάδα σε άλλη από ένα βέλος. Παράλληλα με τα βέλη της κλήσης παριστάνεται με πρόσθετα βέλη τα οποία περιγράφουν την είσοδο ή το αποτέλεσμα μιας δομικής μονάδας και η ροή των δεδομένων μεταξύ δομικών μονάδων. Το παρακάτω σχήμα αποτελεί το διάγραμμα δομής προγράμματος για έναν απλό υπολογιστή μιγαδικών αριθμών.

Για την αποτύπωση του λεπτομερούς σχεδίου του λογισμικού χρησιμοποιείται ο ψευδοκώδικας (pseudocode) καθώς και τα διαγράμματα ροής (flow charts). Ο ψευδοκώδικας αποτελείται από εντολές ελέγχου της ροής της εκτέλεσης αντίστοιχες με αυτές των γλωσσών προγραμματισμού (if, while, do). Η περιγραφές όμως των συνθηκών και των εντολών δίνονται αδρά, σε φυσική γλώσσα, έτσι ώστε να είναι πιο περιεκτικές και ευνόητες από τις αντίστοιχες εντολές της γλώσσας προγραμματισμού.

Παράδειγμα ψευδοκώδικα ελέγχου κωδικού (PIN) σε μηχάνημα ATM:

do
	Display message asking the user for PIN
	Read user PIN
	if incorrect PIN
		Display error message
while incorrect PIN

Ασκήσεις

1. Επιλέξτε ένα σύνθετο σύστημα λογισμικού της αρεσκείας σας και αποτυπώστε με τους κατάλληλους συμβολισμούς την ανάλυση, το μακροσκοπικό σχέδιο και ένα μικρό αντιπροσωπευτικό τμήμα από το λεπτομερή σχεδιασμό.

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

• Peter Rechenberg. Εισαγωγή στην Πληροφορική. σ. 155-162 Κλειδάριθμος, 1992.

• Εμμανουήλ Σκορδαλάκης. Εισαγωγή στην Τεχνολογία Λογισμικού. Συμμετρία, 1991.

• Εμμ. Α. Γιακουμάκης Τεχνολογία Λογισμικού: Απαιτήσεις Λογισμικού, σχεδίαη λογισμικού Εκδόσεις Α. Σταμούλης, Αθήνα Πειραιάς 1994.

• Εμμ. Α. Γιακουμάκης Τεχνολογία Λογισμικού: Κωδικοποίηση, έλεγχος και συντήρηση λογισμικού Εκδόσεις Α. Σταμούλης, Αθήνα Πειραιάς 1993.

• F. P. Brooks. The Mythical Man Month. Addison-Wesley, 1975.
• Alan M. Davis. 201 Principles of Software Development. McGraw-Hill, 1995.
• Tom DeMarco and Timothy R. Lister. Peopleware: Productive Projects and Teams. Dorset House Publishing, 1987.
• Jr. Frederick P. Brooks. No silver bullet: Essence and accidents of software engineering. IEEE Computer, pages 10–19, April 1987.
• P. J. Plauger. Programming on Purpose: Essays on Software Design. Prentice-Hall, 1993.
• P. J. Plauger. Programming on Purpose II: Essays on Software People. Prentice-Hall, 1993.
• P. J. Plauger. Programming on Purpose III: Essays on Software Technology. Prentice-Hall, 1994.
• Roger S. Pressman. Software Engineering: A Practitioner's Approach. McGraw-Hill, 1987.
• Charles H. Schmauch. ISO 9000 for Software Developers. ASQC Quality Press, Milwaukee, Wisconsin, USA, 1995.
• Ian Sommerville. Software Engineering. Addison-Wesley, third edition, 1989.
• Roel Wieringa. A survey of structured and object-oriented software specification methods and techniques. ACM Computing Surveys, 30(4):459–527, December 1998.
• Edward Yourdon. Death March. Prentice-Hall, 1997.

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

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

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

Συμβολοσειρές

Παράσταση συμβολοσειρών

• Μια συμβολοσειρά (string) (αλφαριθμητική σταθερά κατά την ελληνική απόδοση του βιβλίου The C Programming Language) παριστάνονται στη C ως πίνακας χαρακτήρων με τη σύμβαση ότι το τέλος του ορίζεται από το χαρακτήρα '\0'.
• Η σύμβαση αυτή υποστηρίζεται από το μεταγλωττιστή ο οποίος τερματίζει αυτόματα τη συμβολοσειρά (π.χ. "hello, world") με το χαρακτήρα '\0'.
• Έτσι μπορούμε να ορίσουμε έναν πίνακα που να περιέχει τα στοιχεία μιας συμβολοσειράς με τον παρακάτω ορισμό:
  char msg[] = "Please enter the number";
  
• Ακόμα μπορούμε να θέσουμε έναν δείκτη σε χαρακτήρες να δείχνει σε μια συμβολοσειρά:
  char *msg;
  
  msg = "Please enter the number";
  

Επεξεργασία συμβολοσειρών

• Η επεξεργασία αλφαριθμητικών σταθερών γίνεται με τη χρήση δεικτών. Το παρακάτω παράδειγμα τυπώνει "hello, world" στην οθόνη:
  #include <stdio.h>
  
  void
  print_string(char *s)
  {
          while (*s != '\0') {
                  putchar(*s);
                  s++;
          }
  }
  
  main()
  {
          print_string("hello, world\n");
  }
  
• Στο παραπάνω παράδειγμα μπορούσαμε να παραλείψουμε τη σύγκριση *s != '\0' και να γράψουμε απλά while (*s)
• Ακόμα μπορούσαμε να γράψουμε την print_string με τη χρήση πινάκων:
  void
  print_string(char *s)
  {
          int i;
  
          for (i = 0; s[i] != '\0'; i++)
                  putchar(s[i]);
  }
  
• Όλοι οι παραπάνω τρόποι είναι ισοδύναμοι και σωστοί.

Είσοδος και έξοδος

• Η συνάρτηση fgets(buff, n, stdin) διαβάζει από την είσοδο του προγράμματος (π.χ. το πληκτρολόγιο) μια γραμμή από n-1 το πολύ χαρακτήρες και του τοποθετεί στη θέση buff.
• Αν η fgets συναντήσει το τέλος του αρχείου επιστρέφει NULL, αλλιώς επιστρέφει την τιμή buff.
• Αντίστοιχα, μπορούμε να τυπώσουμε μια συμβολοσειρά str με τη χρήση της συνάρτησης printf("%s", str);.
• Το παρακάτω παράδειγμα διαβάζει μια γραμμή από το πληκτρολόγιο (μέχρι το \n) και την τυπώνει:
  #include <stdio.h>
  main()
  {
          char buff[256];
  
          fgets(buff, sizeof(buff), stdin);
          printf("You entered: %s\n", buff);
  }
  
• Η χρήση της πιο απλής συνάρτησης gets πρέπει να αποφεύγεται διότι οδηγεί σε ανασφαλή προγράμματα.

Συναρτήσεις βιβλιοθήκης

char * strcpy(char * a, const char * b);

Αντιγράφει τη συμβολοσειρά b στη συμβολοσειρά a.

char * strcat(char * a, const char * b);

Προσθέτει τη συμβολοσειρά b στο τέλος της συμβολοσειράς a.

int strcmp(const char * a, const char * b);

Συγκρίνει τις συμβολοσειρές a και b και επιστρέφει 0 αν είναι ίδιες, -1 αν ο πρώτος διαφορετικός χαρακτήρας της a είναι μικρότερος από τον αντίστοιχο της b, και 1 στην αντίθετη περίπτωση.

size_t strlen(const char * a);

Επιστρέφει τον αριθμό των χαρακτήρων της συμβολοσειράς a.

char * strchr(const char * a, int c);

Επιστρέφει ένα δείκτη στην πρώτη εμφάνιση του χαρακτήρα c στη γραμματοσειρά a ή NULL αν δεν εμφανίζεται.

Σύνθετες δομές

• Τυπικά οι συμβολοσειρές φυλάσσονται σε πιο σύνθετες δομές όπως πίνακες, δομές και ενώσεις.
• Στις περιπτώσεις αυτές η μνήμη για τους χαρακτήρες δεσμεύεται με τη χρήση της malloc.
• Το παρακάτω παράδειγμα διαβάζει 5 γραμμές σε έναν πίνακα και τις τυπώνει με ανάποδη σειρά.
• Αρχικά, κάθε συμβολοσειρά διαβάζεται στον προσωρινό ενταμιευτή (buffer) buff.
• Στη συνέχεια η malloc δεσμεύει χώρο από τη δυναμική μνήμη στον οποίο δείχνει η αντίστοιχη σειρά της lines και στην οποία αντιγράφονται τα περιεχόμενα του buff.
  #include <stdio.h>
  #include <string.h>
  
  main()
  {
          int i;
          char buff[1024];
          char *lines[5];
  
          for (i = 0; i < 5; i++) {
                  fgets(buff, sizeof(buff), stdin);
                  lines[i] = (char *)malloc(strlen(buff) + 1);
                  strcpy(lines[i], buff);
          }
          for (i = 4; i >= 0; i--)
                  printf("%s", lines[i]);
  }
  

Ασκήσεις

Συμβολοσειρές

1. Υλοποιήστε τις συναρτήσεις που ορίζονται στο string.h με δικό σας όνομα (π.χ. my_strlen) σε ξεχωριστό αρχείο.
2. Γράψτε ένα πρόγραμμα που να ελέγχει τις συναρτήσεις που υλοποιήσατε.

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

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

• Brian W. Kernighan and Dennis M. Ritchie. The C Programming Language, pages 104-106. Prentice-Hall, second edition, 1988.

Η πρότυπη βιβλιοθήκη

Εισαγωγή

• Το πρότυπο ISO/ANSI της γλώσσας C ορίζει την πρότυπη βιβλιοθήκη ως ένα σύνολο συναρτήσεων που πρέπει να παρέχονται από υλοποιήσεις που είναι βασισμένες σε πλήρη υπολογιστή (hosted implementations).
• Οι επόμενες σελίδες περιγράφουν πολύ αδρά τα περιεχόμενα των βασικών συναρτήσεων κάθε κατηγορίας, έτσι ώστε να δοθεί μια γενική εικόνα του περιεχομένου της βιβλιοθήκης. Λεπτομέρειες για τη χρήση των συναρτήσεων υπάρχουν στη βιβλιογραφία.

Είσοδος και έξοδος

Επικεφαλίδα

Περιλαμβάνει

Βασικές συναρτήσεις

fopen

Επιστρέφει ένα ρεύμα (stream) για την επεξεργασία ενός αρχείου.

fclose

Τερματίζει την επεξεργασία ενός αρχείου.

printf

Τυπώνει φορμαρισμένα στην έξοδο (stdout).

fprintf

Τυπώνει φορμαρισμένα σε αρχείο.

sprintf

Τυπώνει φορμαρισμένα σε συμβολοσειρά.

fscanf

Διαβάζει φορμαρισμένα από αρχείο.

scanf

Διαβάζει φορμαρισμένα από την είσοδο (stdin).

getc

Διαβάζει έναν χαρακτήρα από αρχείο.

getchar

Διαβάζει έναν χαρακτήρα από την είσοδο.

putc

Τυπώνει έναν χαρακτήρα σε αρχείο.

putchar

Τυπώνει έναν χαρακτήρα στην έξοδο.

fread

Διαβάζει στοιχεία από το αρχείο.

fwrite

Τυπώνει στοιχεία στο αρχείο.

fseek

Ορίζει τη θέση στο αρχείο

Παράδειγμα

Χαρακτηρισμός χαρακτήρων

Επικεφαλίδα

Περιλαμβάνει

Βασικές συναρτήσεις

isdigit

Επιστρέφει αληθές αν ο χαρακτήρας είναι ψηφίο

isalpha

Επιστρέφει αληθές αν ο χαρακτήρας είναι αλφαβητικός

isalnum

Επιστρέφει αληθές αν ο χαρακτήρας είναι αλφαβητικός ή ψηφίο

isspace

Επιστρέφει αληθές αν ο χαρακτήρας είναι κάποιο κενό

isupper

Επιστρέφει αληθές αν ο χαρακτήρας είναι κεφαλαίος

islower

Επιστρέφει αληθές αν ο χαρακτήρας είναι πεζός

Παράδειγμα

Μαθηματικά

Επικεφαλίδα

Περιλαμβάνει

Βασικές συναρτήσεις

sin

Ημίτονο

cos

Συνημίτονο

tan

Εφαπτομένη

asin

Τόξο ημίτονου

acos

Τόξο συνημίτονου

atan2

Τόξο εφαπτομένης

sinh

Υπερβολικό ημίτονο

cosh

Υπερβολικό συνημίτονο

log

Φυσικός λογάριθμος

pow

Δύναμη

sqrt

Τετραγωνική ρίζα

ceil

Στρογγυλεύει προς τα άνω

floor

Στρογγυλεύει προς τα κάτω

fmod

Υπόλοιπο διαίρεσης

Παράδειγμα

Βοηθητικές συναρτήσεις

Επικεφαλίδα

Περιλαμβάνει

Βασικές συναρτήσεις

atof

Μετατρέπει συμβολοσειρά σε double

atol

Μετατρέπει συμβολοσειρά σε long

atoi

Μετατρέπει συμβολοσειρά σε int

abs

Επιστρέφει την απόλυτη τιμή ενός int

max

Επιστρέφει το μέγιστο δύο αριθμών

min

Επιστρέφει τον ελάχιστο δύο αριθμών

rand

Επιστρέφει έναν ψευδοτυχαίο αριθμό 0 - RAND_MAX

srand

Καθορίζει τη βάση εκκίνησης της rand

malloc

Δεσμεύει και επιστρέφει δυναμική μνήμη

free

Ελευθερώνει δυναμική μνήμη

realloc

Αλλάζει το μέγεθος ενός τμήματος δυναμικής μνήμης

exit

Τερματίζει το πρόγραμμα

system

Εκτελεί εντολή του λειτουργικού συστήματος

getenv

Επιστρέφει την τιμή μιας μεταβλητής του λειτουργικού συστήματος

qsort

Ταξινομεί έναν πίνακα

bsearch

Δυαδική αναζήτηση σε ταξινομημένο πίνακα

Παράδειγμα

Συμβολοσειρές

Επικεφαλίδα

Περιλαμβάνει

Διάγνωση

Επικεφαλίδα

Περιλαμβάνει

Βασικές συναρτήσεις

assert

Με τη δήλωση assert(x) ο προγραμματιστής δηλώνει στο πρόγραμμα ότι με βάση το σχεδιασμό του περιμένει ότι η χ θα είναι αληθής. Αν η x δεν είναι αληθής το πρόγραμμα διακόπτει την εκτέλεσή του με μήνυμα που πληροφορεί το χειριστή για το σημείο που παρουσιάστηκε το πρόβλημα.

Παράδειγμα

Ώρα και ημερομηνία

Επικεφαλίδα

Περιλαμβάνει

Βασικές συναρτήσεις

time

Επιστρέφει την ώρα (σε δευτερόλεπτα από το 1970)

localtime

Μετατρέπει την ώρα από δευτερόλεπτα σε τοπική ώρα και την αποθηκεύει στη δομή struct tm

asctime

Μετατρέπει την ώρα από τη δομή σε συμβολοσειρά.

difftime

Επιστρέφει τη διαφορά ανάμεσα σε δύο ώρες

Παράδειγμα

Όρια υλοποίησης

Επικεφαλίδα

Περιλαμβάνει

Βασικές τιμές

CHAR_MAX

Ο μέγιστος char

CHAR_MIN

Ο ελάχιστος char

INT_MAX

Ο μέγιστος int

INT_MIN

Ο ελάχιστος int

DBL_MAX

Ο μέγιστος double

DBL_MIN

Ο ελάχιστος double

DBL_DIG

Τα δεκαδικά ψηφία ακρίβειας των double

Παράδειγμα

CHAR_MAX=127
CHAR_MIN=-128
INT_MAX=2147483647
INT_MIN=-2147483648
DBL_MAX=1.79769e+308
DBL_MIN=2.22507e-308
DBL_DIG=15

Ασκήσεις

Πρότυπη βιβλιοθήκη

1. Να βρείτε και να διαβάσετε την τεκμηρίωση για τη συνάρτηση rename. Γράψτε ένα πρόγραμμα που να τη χρησιμοποιεί.

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

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

• Chuck Allison. The Standard C library, part 1. C Users Journal, 13(1):69, January 1995.
• Chuck Allison. The Standard C library, part 2. C Users Journal, 13(2):89, February 1995.
• Chuck Allison. The Standard C library, part 3. C Users Journal, 13(3):59, March 1995.
• American National Standard for Information Systems — programming language — C: ANSI X3.159–1989. Published by the American National Standards Institute, 1430 Broadway, New York, New York 10018, December 1989. (Also ISO/IEC 9899:1990).
• Brian W. Kernighan and Dennis M. Ritchie. The C Programming Language, pages 241–258. Prentice-Hall, second edition, 1988.
• P. J. Plauger. The Standard C Library. Prentice Hall, 1992.

Θέματα εξετάσεων

Εξεταστική περιόδος Φεβρουαρίου 1999

Τμήμα Πληροφοριακών και Επικοινωνιακών Συστημάτων

Σχεδιασμός και Υλοποίηση Λογισμικού Διδάσκων: Διομήδης Σπινέλλης

Εξεταστική περίοδος Φεβρουαρίου 1999

Θέμα 1ο: (2 βαθμοί)

Γράψτε σε C μια συνάρτηση που να δέχεται ως όρισμα τρεις διαφορετικούς δείκτες σε ακεραίους και μεταθέτει κυκλικά δεξιόστροφα τις τιμές τους. Γράψτε ένα πρόγραμμα για τον έλεγχο της λειτουργίας της συνάρτησης αυτής.

Θέμα 2ο: (2 βαθμοί)

Σχεδιάστε το διάγραμμα ροής δεδομένων για μια ταμιακή μηχανή. Να λάβετε υπόψη σας ότι οι μηχανές αυτές διαθέτουν "φορολογική μνήμη" στην οποία αποθηκεύονται τα στοιχεία των συναλλαγών.

Θέμα 3ο: (3 βαθμοί)

Γράψτε σε C ένα πρόγραμμα το οποίο να δέχεται για είσοδο τις συντεταγμένες (x,y) 100 σημείων ως αριθμούς κινητής υποδιαστολής. Στο τέλος, το πρόγραμμα πρέπει να τυπώνει για κάθε ένα από τα σημεία τη θέση του (x, y) καθώς και την απόστασή του από την αρχή των αξόνων (0,0). Οι συντεταγμένες κάθε σημείου πρέπει να φυλάσσονται σε δομή (structure). Η συνάρτηση της C για την τετραγωνική ρίζα (sqrt) ορίζεται στην επικεφαλίδα math.h.

Θέμα 4ο: (3 βαθμοί)

Ο τελικός βαθμός ενός μαθήματος είναι κατά 20\% ο βαθμός των ασκήσεων και κατά 80\% ο βαθμός των εξετάσεων όταν και οι δύο βαθμοί είναι πάνω από τη βάση, αλλιώς είναι ο κατώτερος από τους δύο. Σας ζητείται να υλοποιήσετε μια εφαρμογή η οποία διαβάζει συνέχεια ζεύγη βαθμών ασκήσεων και εξετάσεων και τυπώνει λεκτικά (π.χ. "δέκα") τον ακέραιο τελικό βαθμό. Όταν εισαχθεί το ζεύγος (-1, -1) η εφαρμογή τυπώνει λεκτικά τον ακέραιο μέσο όρο των τελικών βαθμών και τερματίζει τη λειτουργία της. Σχεδιάστε το διάγραμμα δομής και γράψτε σε C το αντίστοιχο πρόγραμμα.

Διάρκεια εξέτασης 2,5 ώρες

Καλή επιτυχία!

Πρόγραμμα για το θέμα 1: αντιστροφή τιμών

#include <stdio.h>

/*
 * Rotate variable values clockwise
 */
void
rotate3(int *a, int *b, int *c)
{
	int tmp;

	tmp = *c;
	*c = *b;
	*b = *a;
	*a = tmp;
}

main()
{
	int v1, v2, v3;

	v1 = 1;
	v2 = 2;
	v3 = 3;
	rotate3(&v1, &v2, &v3);
	printf("Expect 3 1 2: [%d %d %d]\n", v1, v2, v3);
}

Πρόγραμμα για το θέμα 3: απόσταση σημείων

#include <stdio.h>
#include <math.h>


/*
 * Return x squared
 */
double
sqr(double x)
{
	return (x * x);
}

main()
{
	struct s_point {
		double x, y;		/* Coordinates */
	} points[100];
	int i;

	for (i = 0; i < 100; i++)
		scanf("%lg %lg", &points[i].x, &points[i].y);
	for (i = 0; i < 100; i++) {
		printf("x=%lg y=%lg ", points[i].x, points[i].y);
		printf("d=%lg\n", sqrt(sqr(points[i].x) + sqr(points[i].y)));
	}
}

Πρόγραμμα για το θέμα 4: βαθμολογία

#include <stdio.h>

/*
 * Print a number 0-10 as a word
 */
void
print_grade(int g)
{
	switch (g) {
	case 0:
		printf("μηδέν\n");
		break;
	case 1:
		printf("ένα\n");
	/* ... */
	case 10:
		printf("δέκα\n");
		break;
	}
}

main()
{
	int exercise, exam, grade;
	int count, sum;

	count = sum = 0;
	for (;;) {
		scanf("%d %d", &exercise, &exam);
		if (exercise == -1 && exam == -1)
			break;
		if (exercise >= 5 && exam >= 5)
			grade = 0.8 * exercise + 0.2 * grade;
		else if (exercise < exam)
			grade = exercise;
		else
			grade = exam;
		print_grade(grade);
		count++;
		sum = sum + grade;
	}
	printf("M.O. = ");
	print_grade(sum / grade);
}

Εξεταστική περιόδος Σεπτεμβρίου 1999

Θέμα 1ο: (2.5 βαθμοί)

Γράψτε σε C τη συνάρτηση strrev που δέχεται ως όρισμα ένα δείκτη σε χαρακτήρες τερματισμένους με Σ\0Τ (συμβολοσειρά) και αντιστρέφει τη σειρά των χαρακτήρων της συμβολοσειράς. Αν για παράδειγμα η συμβολοσειρά πριν την κλήση τής strrev είναι "live" μετά την κλήση της πρέπει να είναι "evil". Γράψτε ένα απλό πρόγραμμα για τον έλεγχο της λειτουργίας της συνάρτησης αυτής.

struct s_morse {
        char c;			/* Character code */
        char *morse;		/* Morse code */
} morse_table[] = {
        'A', ".-",
        'B', "-...",
        'C', "-.-.", 
       /* [...] complete table follows */
};

Να γράψετε ένα πρόγραμμα σε C που να διαβάζει χαρακτήρες από την είσοδό του μέχρι να τερματιστεί το αρχείο εισόδου. Για κάθε χαρακτήρα να τυπώνει (με τη χρήση του morse_table) τον αντίστοιχο κώδικα Morse.

Πρόγραμμα για το θέμα 4: Morse

#include <stdio.h>

struct s_morse {
	char c;
	char *morse;
} morsetable[] = {
	'A', ".-",
	'B', "-...",
	'C', "-.-.",
};

main()
{
	int i, c;

	while ((c = getchar()) != EOF) {
		for (i = 0; i < sizeof(morsetable) / sizeof(struct s_morse); i++)
			if (c == morsetable[i].c)
				printf("%s\n", morsetable[i].morse);
	}
}

Πρόοδος 1999

Θέμα 1ο: (5 βαθμοί)

Γράψτε σε C ένα πρόγραμμα που διαβάζει από την είσοδό του ακέραιους βαθμούς από το 0 μέχρι το 10. Αφού διαβάσει ένα βαθμό να τυπώνει στην οθόνη του "Περνάει" αν ο βαθμός είναι μεγαλύτερος από 4 ή "Δεν περνάει" αν ο βαθμός είναι μικρότερος από 5. Όταν εισαχθεί ο βαθμός -1, το πρόγραμμα τερματίζει τη λειτουργία του και τυπώνει το μέσο όρο των βαθμών που διάβασε.

Θέμα 2ο: (2 βαθμοί)

Τι θα τυπώσει το παρακάτω πρόγραμμα;

#include <stdio.h>

int
a(int a, int b)
{
	a++;
	return (a * b + 1);
}

main()
{
	int i, f;

	f = 1;
	for (i = 0; i < 4; i++) {
		f = f + a(i, i + 1);
		printf("%d\n", f);
	}
}

Θέμα 3ο: (3 βαθμοί)

Να ορίσετε σε C μια συνάρτηση που να δέχεται ως όρισμα την ταχύτητα ενός αυτοκινήτου σε km/h και την απόστασή του από τον προορισμό του σε km. Η συνάρτηση να επιστρέφει το χρόνο (σε s) που χρειάζεται το αυτοκίνητο για να φτάσει στον προορισμό του με τη συγκεκριμένη ταχύτητα. Όλα τα μεγέθη να οριστούν ως αριθμοί κινητής υποδιαστολής.

Εξεταστική περιόδος Ιανουαρίου 2000

Θέμα 1ο: (2.5 βαθμοί)

Γράψτε σε C τη συνάρτηση farraysum που δέχεται ως όρισμα έναν πίνακα αριθμών κινητής υποδιαστολής και έναν ακέραιο που ορίζει το μέγεθος του πίνακα. Η συνάρτηση επιστρέφει το άθροισμα των στοιχείων του πίνακα. Γράψτε ένα απλό πρόγραμμα για τον έλεγχο της λειτουργίας της συνάρτησης αυτής.

Θέμα 2ο: (2.5 βαθμοί)

Προσδιορίστε, σε όχι περισσότερο από μια σελίδα, τις απαιτήσεις λογισμικού για ένα σύστημα παρακολούθησης δανεισμού βιβλίων από τη βιβλιοθήκη.

Θέμα 3ο: (2 βαθμοί)

Να γράψετε ένα πρόγραμμα σε C που να διαβάζει χαρακτήρες από την είσοδό του μέχρι να τερματιστεί το αρχείο εισόδου. Στο τέλος το πρόγραμμα πρέπει να εμφανίζει ένα μήνυμα αν στο αρχείο εισόδου οι παρενθέσεις και οι αγκύλες που ανοίγουν δεν ταυτίζονται αριθμητικά με αυτές που κλείνουν σύμφωνα με το παρακάτω παράδειγμα:

Λάθος: στο αρχείο εμφανίζονται 5 Σ(Σ και 4 Σ)Τ.

Λάθος: στο αρχείο εμφανίζονται 12 Σ{Σ και 15 Σ}Τ.

Το πρόγραμμα δε χρειάζεται να ελέγχει τη σειρά με την οποία εμφανίζονται τα στοιχεία (π.χ. κλείσιμο πριν από άνοιγμα).

Θέμα 4ο: (3 βαθμοί)

Να γράψετε σε C ένα πρόγραμμα που να διαβάζει από την είσοδό του θετικούς ακέραιους αριθμούς μέχρι να συναντήσει το -1. Στο τέλος το πρόγραμμα να τυπώνει πόσες φορές εμφανίστηκε ο κάθε αριθμός. Ο κάθε αριθμός μαζί με τις φορές που έχει εμφανιστεί να φυλαχτεί σε μια δομή (struct) της C. Το πρόγραμμα πρέπει να μπορεί να χειριστεί θεωρητικά απεριόριστο αριθμό στοιχείων με τη χρήση δυναμικής μνήμης. Παράδειγμα:

Θέμα 1ο: (2.5 βαθμοί)

Γράψτε σε C μια συνάρτηση που να δέχεται ως όρισμα δύο χρονικές στιγμές t1, t2 με t1 < t2 εκφρασμένες ως ώρες, λεπτά, δευτερόλεπτα και να επιστρέφει το χρόνο σε δευτερόλεπτα που μεσολαβεί ανάμεσα στα t1, t2. Γράψτε ένα απλό πρόγραμμα για τον έλεγχο της λειτουργίας της συνάρτησης αυτής. Να ορίσετε και να χρησιμοποιήσετε βοηθητικές συναρτήσεις για να αποφύγετε την επανάληψη κώδικα.

Θέμα 2ο: (2.5 βαθμοί)

Προσδιορίστε, σε όχι περισσότερο από μια σελίδα, τις απαιτήσεις λογισμικού για έναν απλό επεξεργαστή κειμένου.

Θέμα 3ο: (2 βαθμοί)

<html><body><h1>Εισαγωγή</h1> Κείμενο της εισαγωγής</body></html>

Εισαγωγή Κείμενο της εισαγωγής

Θέμα 4ο: (3 βαθμοί)

Να γράψετε σε C ένα πρόγραμμα που να διαβάζει από την είσοδό του α) τον αριθμό των αθλητών που λαμβάνουν μέρος σε ένα άθλημα και β) για κάθε αθλητή το επώνυμό του (μέχρι 20 χαρακτήρες) και την επίδοσή του (ως αριθμό κινητής υποδιαστολής). Στο τέλος το πρόγραμμα να τυπώνει ξανά τους αθλητές και τις επιδόσεις τους εμφανίζοντας τρία αστεράκια πλάι στο όνομα του αθλητή με την καλύτερη (μικρότερη) επίδοση. Τα στοιχεία του κάθε αθλητή να φυλαχτούν σε μια δομή (struct) της C. Το πρόγραμμα πρέπει να μπορεί να χειριστεί θεωρητικά απεριόριστο αριθμό αθλητών με τη χρήση δυναμικής μνήμης. Το όνομα και η επίδοση του αθλητή μπορούν να διαβαστούν με τη συμβολοσειρά της scanf "%s %g".

Διάρκεια εξέτασης 2,5 ώρες

Καλή επιτυχία!

Πληροφορίες για μεταγλωττιστές

Ο μεταγλωττιστής gcc

Προσοχή

Και τώρα τα στοιχεία:

• Αν έχετε υπολογιστή με Windows 95 και άνω μπορείτε να χρησιμοποιήσετε το μεταγλωττιστή που διατίθεται ελεύθερα μαζί με τα εργαλεία Cygwin.
• Τα εργαλεία καθώς και οδηγίες βρίσκονται στη σελίδα The Cygwin Project (http://sources.redhat.com/cygwin/).
• Μια εναλλακτική λύση μπορείτε να βρείτε στη σελίδα djgpp (http://www.delorie.com/djgpp/).
• Τεκμηρίωση για το μεταγλωττιστή μπορείτε να βρείτε εδώ (http://www.redhat.com/support/manuals/gnupro.html).
• Η μεταφορά του μεταγλωττιστή στο PC σας και η εγκατάστασή του εκεί είναι ιδιαίτερα δύσκολη. Μην το δοκιμάσετε αν δεν έχετε κάποια πείρα σε εγκατάσταση προγραμμάτων, γνώσεις του περιβάλλοντος MS-DOS και πολύ χρόνο ελεύθερο.

Αποτελέσματα ασκήσεων

Ασκήσεις 3, 4

Ασκήσεις 3-6

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

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