ΕΙΣΑΓΩΓΗ ΣΤΗΝ ΓΛΩΣΣΑ ΠΡΟΓΡΑΜΜΑΤΙΣΜΟΥ...

ΕΙΣΑΓΩΓΗ ΣΤΗΝ ΓΛΩΣΣΑ ΠΡΟΓΡΑΜΜΑΤΙΣΜΟΥ C

Ταξιάρχης ΔιαμαντόπουλοςΙανουάριος 2013

Τι είναι ένα πρόγραμμα;

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

Πώς λαμβάνει τις οδηγίες αυτές ο υπολογιστής;

Κανονικά, επειδή ο υπολογιστής είναι ένα μηχάνημα –δεν έχει δηλαδή έμφυτη ευφυΐα- για να μπορούμε να συνεννοηθούμε μαζί του θα έπρεπε να του μιλούσαμε απ’ευθείας στην ‘γλώσσα’ του. Η γλώσσα αυτή ονομάζεται γλώσσα μηχανής και όλες οι ‘λέξεις’ της αποτελούνται από δύο και μόνο σύμβολα: το 0 και το 1. Αυτό συμβαίνει γιατί ο υπολογιστής αποτελείται από δισεκατομμύρια κυκλώματα μέσα από τα οποία είτε περνάει (1), είτε δεν περνάει ρεύμα (0). Έτσι για παράδειγμα εάν θέλαμε να του λέγαμε ‘πρόσθεσε’, θα έπρεπε να δίναμε την εντολή:

10000110

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

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

Τι είναι μία γλώσσα προγραμματισμού;

Το σύνολο αυτών των ειδικών συμβόλων και φράσεων-εντολών -οι οποίες πλησιάζουν αρκετά την δική μας γλώσσα- ονομάζεται γλώσσα προγραμματισμού. Σήμερα συναντούμε αρκετές τέτοιες γλώσσες προγραμματισμού, κάθε μία από τις οποίες εξειδικεύεται στην επίλυση συγκεκριμένων προβλημάτων. Τέτοιες γλώσσες είναι η BASIC, η FORTRAN, η PASCAL, η C αλλά και άλλες νεότερης γενιάς όπως η JAVA, η C++, η Visual Basic κ.α.

Πώς ο υπολογιστής καταλαβαίνει μία γλώσσα προγραμματισμού;

Όλες οι παραπάνω γλώσσες για να γίνουν τελικά οδηγίες για τον υπολογιστή, πρέπει οπωσδήποτε να μεταφραστούν στην γλώσσα που αυτός καταλαβαίνει, δηλαδή στην γλώσσα μηχανής. Αυτό γίνεται με την βοήθεια ενός ειδικού προγράμματος που είναι επιφορτισμένο με αυτήν και μόνο την δουλειά: να μεταφέρει δηλαδή εντολή προς εντολή και σύμβολο προς σύμβολο ό,τι εμείς γράψαμε με τη συγκεκριμένη γλώσσα προγραμματισμού στη γλώσσα μηχανής, σε σειρές τελικά από 0 και 1. Το πρόγραμμα αυτό ονομάζεται μεταγλωττιστής (compiler) ή σε άλλα περιβάλλοντα διερμηνέας (interpreter). Η γλώσσα προγραμματισμού C χρησιμοποιεί ένα τέτοιο πρόγραμμα - μεταγλωττιστή (compiler).

Εισαγωγή στη author: γλώσσα προγραμματισμού C Ταξιάρχης Διαμαντόπουλος

2

Ποια είναι τα βήματα προγραμματισμού στην γλώσσα C ; Στην γλώσσα προγραμματισμού C:

1. Γράφουμε αρχικά τις εντολές που θέλουμε να απαρτίσουν το πρόγραμμά μας με βάση τους κανόνες σύνταξης, τις εντολές και τα ειδικά σύμβολα που η γλώσσα C διαθέτει. Αυτό συνήθως γίνεται με την βοήθεια ενός επεξεργαστή κειμένου (text editor) ή ακόμη καλύτερα μέσω ενός ειδικού περιβάλλοντος ανάπτυξης κώδικα (SDK, Software Development Kit). Όταν ολοκληρώσουμε το πρόγραμμα το αποθηκεύουμε στο σκληρό δίσκο με την μορφή: οποιοδήποτε_όνομα.c . Το αρχείο αυτό -η κατάληξη του οποίου πρέπει να είναι πάντα σε .c1- αποτελεί τον πηγαίο κώδικα (source code), όπως συνηθίζουμε να λέμε, η μορφή δηλαδή εκείνη του προγράμματος που πλησιάζει στην δική μας γλώσσα παρά στη γλώσσα μηχανής.

2. Στη συνέχεια δίνουμε την εντολή μεταγλώττισης (compile), η οποία βρίσκεται συνήθως σε ένα από τα menu του περιβάλλοντος ανάπτυξης, προκειμένου ο πηγαίος κώδικας να μεταφραστεί σε γλώσσα μηχανής. Το πρόγραμμα-μεταγλωττιστής πριν κάνει την μετάφραση, ελέγχει εάν υπάρχουν καθόλου πιθανά συντακτικά λάθη που κάναμε γράφοντας τον πηγαίο κώδικα. Εάν αυτό συμβαίνει -πράγμα διόλου απίθανο, ειδικά για τα πρώτα μας προγράμματα- μας τα υποδεικνύει, χωρίς να προχωρήσει στη μεταγλώττιση. Σε αυτήν την περίπτωση επιστρέφουμε στον πηγαίο μας κώδικα και διορθώνουμε τα λάθη μας, φροντίζοντας να αποθηκεύσουμε πάλι το πρόγραμμα με την διορθωμένη του μορφή. Όταν τελικά ο μεταγλωττιστής δεν εντοπίσει λάθη, προχωράει στη μεταγλώττιση του πηγαίου σε γλώσσα μηχανής. Το αρχείο το οποίο περιέχει το μεταγλωττισμένο πρόγραμμά μας ονομάζεται αντικείμενο πρόγραμμα (object code). Έχει το ίδιο όνομα με το πηγαίο και ξεχωρίζει απ’αυτό μόνο στην κατάληξή του: οποιοδήποτε_όνομα.obj. Σε κάποια άλλα περιβάλλοντα το ενδιάμεσο αυτό αρχείο μπορεί να μην εμφανίζεται και ο μεταγλωττιστής να παράγει απευθείας το .exe αρχείο, όπως αυτό αναλύεται στο βήμα 3.

3. Το τελικό αρχείο που πρέπει να φτιάξουμε προκειμένου το πρόγραμμά μας να εκτελεστεί απ΄τον υπολογιστή είναι το οποιοδήποτε_όνομα.exe (η κατάληξη exe σημαίνει executable, δηλαδή εκτελέσιμο). Αυτό γίνεται με την εντολή make exe που επίσης δίνεται από τα menu του περιβάλλοντος ανάπτυξης κώδικα. Τόσο το αρχείο οποιοδήποτε_όνομα.obj όσο και το αρχείο οποιοδήποτε_όνομα.exe περιέχουν το πρόγραμμά μας σε μορφή γλώσσας μηχανής (σε 0 και 1). Ποια είναι τότε η διαφορά τους; Εάν παρατηρήσουμε προσεκτικότερα θα δούμε ότι το .exe αρχείο έχει μεγαλύτερο μέγεθος από το .obj. Τι παραπάνω προστέθηκε στο εκτελέσιμο αρχείο; Η απάντηση βρίσκεται στο ότι όταν εμείς γράφουμε ένα πηγαίο κώδικα, πολλές από τις λειτουργίες που περιγράφουμε σε αυτόν δεν περιλαμβάνονται με την πλήρη τους μορφή. Αυτές οι λειτουργίες αφορούν εντολές που χρησιμοποιούμε πολύ συχνά σε ένα πρόγραμμα -πχ. εντολές εισόδου-εξόδου, μαθηματικές συναρτήσεις, εντολές γραφικών κλπ.- και οι οποίες ακριβώς επειδή χρησιμοποιούνται πολύ συχνά από όλους τους προγραμματιστές, δεν χρειάζεται να γράφουμε την πλήρη τους ανάπτυξη στον πηγαίο κώδικα. Η πλήρης τους ανάπτυξη βρίσκεται μέσα σε ειδικές βιβλιοθήκες της C και είναι αυτές που προστίθενται κατά την τελική φάση της μεταγλώττισης, όταν δηλαδή δημιουργούμε τον εκτελέσιμο κώδικα, έτσι ώστε ο κώδικας να εκτελεστεί σωστά από τον υπολογιστή.

1 Σε άλλες περιπτώσεις, εάν το περιβάλλον ανάπτυξης αφορά τη γλώσσα C++, ενδέχεται η κατάληξη του πηγαίου κώδικα να εμφανίζεται και ως .cpp.


3

Το οποιοδήποτε_όνομα.exe αρχείο, περιέχει λοιπόν σε γλώσσα μηχανής το πρόγραμμα που γράψαμε εμείς συν όλες τις απαραίτητες επεξηγήσεις εντολών που χρησιμοποιήσαμε σε αυτό.

(σημείωση: το εκτελέσιμο αρχείο μπορεί να το συναντήσουμε και χωρίς την κατάληξη exe, δηλαδή με το όνομά του και μόνο: οποιοδήποτε_όνομα)

4. Το πρόγραμμά μας είναι έτοιμο. Μπορεί να μεταφερθεί και να εκτελεστεί σε οποιοδήποτε άλλο μηχάνημα τρέχει το ίδιο λειτουργικό σύστημα. Οποιεσδήποτε αλλαγές θέλουμε να κάνουμε σε αυτό πρέπει να ακολουθήσουμε ξανά τα βήματα 1-3.

παράδειγμα αρχείων που χρησιμοποιεί η C:

το αρχείο Prg3.c είναι ο πηγαίος κώδικαςτο αρχείο Prg3.obj η μεταγλώττισή του σε γλώσσα μηχανής (object code)το αρχείο Prg3.exe το εκτελέσιμο αρχείο (ή εφαρμογή)(παρατηρήστε τη διαφορά μεγέθους μεταξύ obj και exe αρχείου)το αρχείο Prg3.bak είναι εφεδρικό αντίγραφο (backup) του πηγαίου μας κώδικα


4

Η δομή ενός προγράμματος στην γλώσσα C

Ένα πρόγραμμα σε C έχει συνήθως αυτή τη μορφή:

main( ){εντολή 1;εντολή 2;/* αυτό δεν είναι εντολή, αλλά ένα σχόλιο */εντολή 3;….εντολή Ν;

}

Οι εντολές γράφονται με τη σειρά που θα εκτελεστούν, τερματίζουν με το ελληνικό ερωτηματικό (;) και εμπεριέχονται μέσα σε δύο αγκύλες ξεκινώντας απ΄την ανοικτή και καταλήγοντας στην κλειστή αγκύλη. Οι δύο αυτές αγκύλες στην ουσία σηματοδοτούν την αρχή και το τέλος της κύριας ενότητας ενός προγράμματος σε C, η οποία δηλώνεται πριν από τις αγκύλες με το όνομα main( ).

Ένα πρόγραμμα σε C μπορεί να αποτελείται από πολλές τέτοιες ενότητες κάθε μία από τις οποίες έχει το δικό της όνομα και τη δική της ξεχωριστή λειτουργία. Έτσι αντί να γράφαμε όλες τις εντολές του προγράμματός μας μέσα σε μία κεντρική ενότητα μπορούμε να δημιουργήσουμε ξεχωριστές ενότητες, κάθε μία από τις οποίες περιέχει τις εντολές εκείνες που αντιστοιχούν στην συγκεκριμένη ενότητα. Οι ενότητες αυτές στη γλώσσα C ονομάζονται functions, και το πρόγραμμά μας τις εκτελεί με τη σειρά που καλούνται από την κεντρική function, δηλαδή την main( ).Παράδειγμα αντί να γράφαμε:

main( ){/* οι παρακάτω εντολές διαβάζουν κάποια δεδομένα*/εντολή 1;εντολή 2;εντολή 3;/* οι παρακάτω εντολές υπολογίζουν μία αριθμητική τιμή*/εντολή 4;εντολή 5;/*οι παρακάτω εντολή εμφανίζει το αποτέλεσμα στην οθόνη*/εντολή 6;

}

μπορούμε να γράψουμε:

main( ){input_data( );calculate( );output_results( );

}


5

input_data( ){εντολή 1;εντολή 2;

εντολή 3;}

calculate( ){εντολή 4;εντολή 5;

}

output_results( ){εντολή 6;

}

Το πρόγραμμα τώρα εκτελεί με τη σειρά τις function input_data( ), calculate( ) και output_results( ), με τη σειρά δηλαδή που δηλώθηκαν για να κληθούν μέσα από την main( ).

Αυτή η δομή προγραμματισμού είναι σαφώς πιο ευέλικτη και πιο οικονομική αφού δεν χρειάζεται να γράφουμε πολλές φορές την ίδια ομάδα εντολών. Αρκεί μόνο να τις γράψουμε μία φορά και να τις καλέσουμε όσες φορές χρειαστεί ξανά, καλώντας το όνομα της function. Η συγκεκριμένη μορφή προγραμματισμού ονομάζεται δομημένος προγραμματισμός.

Το πρώτο πρόγραμμα - η εντολή εξόδου printf( )

main( ){

printf(“Γεια και χαρά”);

}

To πρόγραμμα αυτό αποτελείται από μία μόνο εντολή: την printf( ).

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

Τα τρία Ε: Είσοδος, Επεξεργασία, Έξοδος

Κάθε πρόγραμμα που θέλουμε να γράψουμε με την C -αλλά και σε οποιαδήποτε άλλη γλώσσα δομημένου προγραμματισμού- πρέπει πρώτα να αναλυθεί σε τρία βήματα:

1. Ποια είναι τα δεδομένα μου (Είσοδος)2. Ποια η επεξεργασία που πρέπει να γίνει σε αυτά (Επεξεργασία)3. Τι θα συμβεί με το αποτέλεσμα της επεξεργασίας τους (Έξοδος)


6

Έστω για παράδειγμα πως έχουμε ένα πρόβλημα υπολογισμού. Θέλουμε το πρόγραμμά μας κάθε φορά να μας υπολογίζει το μέγεθος ενός αρχείου εικόνας σε byte. O τύπος υπολογισμού είναι:

μέγεθος αρχείου = οριζόντια ανάλυση x κάθετη ανάλυση (σε pixel) x bytes κωδικοποίησης

Προσεγγίζοντας το πρόβλημα με βάση τα τρία αυτά βήματα έχουμε την παρακάτω ανάλυση:

1. Είσοδος:Σαν είσοδο έχουμε κάθε φορά τρία δεδομένα:

α. την οριζόντια ανάλυση (σε pixel)β. την κάθετη ανάλυση (σε pixel)γ. τα bytes κωδικοποίησης

Για κάθε ένα από τα δεδομένα αυτά αντιστοιχούμε μία μεταβλητή:α. hpixβ. vpixγ. bytes

2. Επεξεργασία:Η επεξεργασία που γίνεται στα δεδομένα μας είναι η εξής:

hpix x vpix x bytes

3. Έξοδος:Η έξοδος που λαμβάνουμε από την επεξεργασία είναι μία αριθμητική τιμή. Και σε αυτήν πρέπει να αντιστοιχίσουμε μία μεταβλητή. Ας την ονομάσουμε size.

To πρόβλημά μας σχηματικά αναλύεται ως εξής:


7

Η έννοια της μεταβλητής

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

Η μεταβλητή μπορεί λοιπόν να ειδωθεί σαν μία κενή θέση στη μνήμη του υπολογιστή, η οποία λαμβάνει και μία διαφορετική τιμή κάθε φορά που εκτελείται το πρόγραμμα μας.

Δήλωση μεταβλητών

Πριν λοιπόν ξεκινήσουμε οποιαδήποτε εντολή στo πρόγραμμά μας, πρέπει πρώτα να δηλώσουμε τις μεταβλητές που θα χρησιμοποιήσουμε, έτσι ώστε αφενός να κρατηθεί θέση γι’αυτές στη μνήμη του υπολογιστή, αφετέρου να ξέρει ο υπολογιστής πού θα τις αναζητήσει όταν τις χρησιμοποιεί στην επεξεργασία. Στο συγκεκριμένο


8

παράδειγμα αυτό γίνεται ακριβώς μετά από την ανοικτή αγκύλη της function main( ), δηλαδή στην πρώτη γραμμή του προγράμματός μας:

main( ){

int hpix, vpix, bytes, size;

Eίδη μεταβλητών

Πριν συνεχίσουμε πρέπει να πούμε ότι υπάρχουν διαφορετικά είδη μεταβλητών που χρησιμοποιούνται από την C. Πρέπει λοιπόν πρώτα απ’όλα να δηλώσουμε τον σωστό τύπο. Ο τύπος δηλώνεται στην ίδια γραμμή μαζί με τα ονόματα των μεταβλητών που αντιστοιχούν σε αυτόν και ακριβώς πριν από αυτές. Στο παράδειγμα βλέπουμε ότι ο τύπος μεταβλητής που χρησιμοποιούμε είναι ο int (δηλαδή integer, ακέραιος).

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

Μία μεταβλητή μπορεί να δέχεται τρεις διαφορετικούς τύπους δεδομένων:

- χαρακτήρες (τύπου char)- ακέραιους αριθμούς (τύπου int)- πραγματικούς αριθμούς (τύπου float ή double)

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

τύπος μεταβλητής μέγεθος σε bytes περιεχόμενο

char 1 ASCII χαρακτήραςint 2 προσημασμένος ακέραιος (-32767 έως 32767)unsigned int 2 θετικός ακέραιος (0 έως 65535)long int 4 προσημασμένος μεγάλος ακέραιος (-2147483647 έως 2147483647)

unsigned long int 4 θετικός μεγάλος ακέραιος (0 έως 4294967295)float 4 δεκαδικός με προσέγγιση 6 δεκαδικών ψηφίωνdouble 8 δεκαδικός με προσέγγιση 10 δεκαδικών ψηφίωνlong double 16 δεκαδικός με προσέγγιση 10 δεκαδικών ψηφίων

Προσέχουμε το εύρος τιμών των παραπάνω τύπων να συμπίπτει με το μέγεθος των μεταβλητών που χρησιμοποιούμε.

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

main( ){

unsigned int hpix, vpix, bytes;


9

unsigned long int size;

H μνήμη τώρα θα δείχνει ως εξής:

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

Πώς μία μεταβλητή λαμβάνει τιμές - η εντολή scanf( )

Aφού δηλώσαμε τις μεταβλητές που θα χρησιμοποιήσουμε, πριν προχωρήσουμε στην επεξεργασία τους πρέπει πρώτα να λάβουν κάποιες τιμές. Αυτό γίνεται με την εντολή scanf( ). Ας δούμε για παράδειγμα πώς η μεταβλητή η οποία αντιστοιχεί στη συχνότητα δειγματοληψίας (η sr), λαμβάνει μία τιμή:

printf(“\n Δώστε την συχνότητα δειγματοληψίας: ”);


10

scanf(“ %lf”, &sr);

Ο τύπος δεδομένων που η εντολή scanf( ) θα διαβάσει δηλώνεται αμέσως μετά το σύμβολο % (εδώ lf, δηλαδή τύπου double). Έξω από τα διπλά εισαγωγικά και μετά το κόμα ακολουθεί η μεταβλητή η οποία θα λάβει την τιμή. Γενικά η scanf( ) δηλώνεται ως εξής:

scanf(“%Σ1 %Σ2 …% ΣN”, &μεταβλητή1, &μεταβλητή2, …, &μεταβλητήN); όπου Σ1, Σ2, …, ΣΝ οι τύποι των μεταβλητών μεταβλητή1, μεταβλητή2, …, μεταβλητήN αντίστοιχα. Τα σύμβολα που διαβάζουν συγκεκριμένους τύπους μεταβλητών είναι τα εξής:

%c διαβάζει έναν χαρακτήρα%d διαβάζει έναν ακέραιο αριθμό%f διαβάζει έναν float αριθμό%lf διαβάζει έναν double αριθμό

Πριν από την scanf( ) προηγείται σχεδόν πάντα μία printf( ) η οποία μας προτρέπει να εισάγουμε την τιμή που η scanf( ) ακολούθως θα διαβάσει. Αυτό γίνεται για να γνωρίζουμε κατά την εκτέλεση του προγράμματος πότε θα εισάγουμε μία συγκεκριμένη τιμή. Πρέπει επίσης να γνωρίζουμε πως η scanf( ) είναι μία εντολή που ‘παγώνει’ την εκτέλεση του προγράμματος ώσπου εμείς να εισάγουμε απ’το πληκτρολόγιο την (ή τις) τιμή (τιμές), για τις οποίες είναι προγραμματισμένη να δεχθεί. Η συνέχεια στο πρόγραμμα δίνεται αφού πατήσουμε το πλήκτρο enter.

Τελικά η εισαγωγή δεδομένων στο πρόγραμμά μας γράφεται ως εξής:

printf(“\n Δώστε την ανάλυση της εικόνας σε οριζόντια pixel: ”);scanf(“%ld”, &hpix);printf(“\n Δώστε την ανάλυση της εικόνας σε κάθετα pixel: ”);scanf(“%d”, &vpix);printf(“\n Δώστε τo πλήθος των byte κωδικοποίησης: ”);scanf(“%d”, &bytes);

To σύμβολο \n (new line) στην printf( ) δηλώνει αλλαγή γραμμής κατά την εμφάνιση του μηνύματος στην οθόνη.

Συνοπτικά θα μπορούσαμε να γράφαμε τον ίδιο κώδικα με την χρήση μιας μόνο scanf( ):

printf(“\n Δώστε με τη εξής σειρά: ”);printf(“\n α) την ανάλυση της εικόνας σε οριζόντια pixel:, ”);printf(“\n β) την ανάλυση της εικόνας σε κάθετα pixel:, ”);printf(“\n γ) τo πλήθος των byte κωδικοποίησης: ”);scanf(“%ld %d %d”, &hpix, &vpix, &bytes);

Eπεξεργασία - Το σύμβολο =


11

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

size = hpix x vpix x bytes;

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

i = i +1;

H εντολή αυτή δηλώνει πως η μεταβλητή i θα λάβει την τιμή που είχε έως εκείνη την στιγμή αυξημένη κατά μία μονάδα.


12

Οι τελεστές πράξεων

Η C χρησιμοποιεί συγκεκριμένα σύμβολα για τις αριθμητικές πράξεις. Αυτά είναι:

- αφαίρεση+ πρόσθεση* πολλαπλασιασμός/ διαίρεση (μεταξύ ακέραιων :το ακέραιο μέρος)% διαίρεση (μεταξύ ακέραιων: το δεκαδικό μέρος)-- μείωση κατά μία μονάδα++ αύξηση κατά μία μονάδα

Προτεραιότητα πράξεων

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

1 + 2 * 3

θα δώσει αποτέλεσμα 7, αφού ο πολλαπλασιασμός προηγείται σαν πράξη της πρόσθεσης.

Εάν θέλαμε να γίνει πρώτα η πρόσθεση, θα έπρεπε να χρησιμοποιούσαμε την παρένθεση. Έτσι η έκφραση:

(1 + 2) * 3

θα δώσει αποτέλεσμα 9.

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

12 / 6 * 2

θα δώσει αποτέλεσμα 4, ή 1;

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

12 / (6 * 2)


13

Έξοδος - Η εντολή printf( )

Όπως έχουμε δει η εντολή printf( ) εμφανίζει στην οθόνη ό,τι περιέχεται ανάμεσα στα διπλά εισαγωγικά. Μπορεί όμως πέρα από αυτό να μας εμφανίσει και το περιεχόμενο μιας μεταβλητής. Στο σημείο που θέλουμε να εμφανιστεί η τιμή της μεταβλητής χρησιμοποιούμε το σύμβολο % ακολουθούμενο από τον τύπο της μεταβλητής, ενώ μετά τα διπλά εισαγωγικά δηλώνουμε το όνομα της μεταβλητής. Για παράδειγμα στο πρόγραμμά μας για να εμφανίζαμε το αποτέλεσμα της επεξεργασίας θα δηλώναμε:

printf(“\nΤο μέγεθος του αρχείου εικόνας είναι: %f”, size);

Πρόγραμμα: ο υπολογισμός μεγέθους ενός αρχείου εικόνας

Το πρόγραμμά μας ολοκληρωμένο έχει ως εξής:

main(){

/* δήλωση μεταβλητών */int vpix, hpix, bytes, size;

/* εισαγωγή τιμών */printf(“\n Δώστε με τη εξής σειρά: ”);printf(“\n α) την ανάλυση της εικόνας σε οριζόντια pixel:, ”);printf(“\n β) την ανάλυση της εικόνας σε κάθετα pixel:, ”);printf(“\n γ) τo πλήθος των byte κωδικοποίησης: ”);scanf(“%ld %d %d”, &hpix, &vpix, &bytes);

/* επεξεργασία */size = hpix x vpix x bytes;

/*έξοδος αποτελέσματος*/printf(“ \nΤο μέγεθος του αρχείου εικόνας είναι: %f”, size);

}


14

Περισσότερα για το σύμβολο καταχώρησης ( = )

Στο προηγούμενο παράδειγμα είδαμε ένα πρόγραμμα που χρησιμοποιεί τρεις μεταβλητές για να υπολογίσει μία αριθμητική τιμή και να την αποθηκεύσει τελικά σε μία τέταρτη μεταβλητή. Τι συμβαίνει όμως στην περίπτωση που χρειάζεται να επεξεργαστούμε πολλά δεδομένα; Φανταστείτε για παράδειγμα την περίπτωση που μας ζητηθεί ο μέσος όρος κάποιων τιμών που αφορούν π.χ. την βαθμολογία ενός τμήματος. Ο τύπος υπολογισμού (ΕΠΕΞΕΡΓΑΣΙΑ) είναι ο ακόλουθος:

Μ.Ο. = βαθμός1 + βαθμός2 + βαθμός3 + … + βαθμόςΝ Ν

,όπου Ν το πλήθος των βαθμών.

Εάν υποτεθεί ότι έχουμε 100 διαφορετικούς βαθμούς, τότε θα χρειαζόμασταν 100 διαφορετικές μεταβλητές; Η απάντηση είναι προς το παρόν όχι, αρκεί να μην μας ζητηθεί κάτι παραπάνω πέρα από τον μέσο όρο (ή μία οποιαδήποτε άλλη γενικά ακολουθιακή διαδικασία).

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

y = 1; /* το y λαμβάνει την τιμή 1 */x = 34; /* το x λαμβάνει την τιμή 34 */x = x + 3 - y; /* το x λαμβάνει την τιμή 34 + 3 - 1*/

τότε η μεταβλητή x έχει τελικά καταχωρημένη την τιμή 36

Η λύση λοιπόν του προβλήματός μας βρίσκεται αρκεί να δηλώσουμε μία μεταβλητή στην οποία θα καταχωρούμε έναν - έναν όλους τους βαθμούς αθροιστικά και στο τέλος θα κάνουμε την διαίρεση με το πλήθος των αριθμών (το 100), παράδειγμα:

float sum; /* δηλώνουμε την μεταβλητή αθροιστή */float x; /* και την μεταβλητή - βοηθό της για να μαζεύει τους βαθμούς που θα

/* πληκτρολογούμε εμείς κάθε φορά */

sum = 0; /* τις μηδενίζουμε προκειμένου να σιγουρευτούμε πως δεν προϋπάρχουν */x = 0; /* ήδη κάποιες άλλες τιμές σε αυτές τις θέσεις της μνήμης */

printf(“Δώσε τον πρώτο βαθμό\n”); /* ζητάμε τον πρώτο βαθμό */scanf(“%f”, &x); /* η x λαμβάνει τον πρώτο βαθμό */sum = sum + x; /* καταχώρισε την πρώτη τιμή στη μεταβλητή sum */

/*μαζί με ό,τι προϋπήρχε στην sum (το 0) */

printf(“Δώσε τον δεύτερο βαθμό\n”); /* ζητάμε τον δεύτερο βαθμό */scanf(“%f”, &x); /* η x τώρα λαμβάνει τον δεύτερο βαθμό */sum = sum + x; /* καταχώρισε την δεύτερη τιμή στη μεταβλητή sum, */

/* μαζί με ό,τι προϋπήρχε (ο βαθμός1)*/


15

printf(“Δώσε τον τρίτο βαθμό\n”); /* ζητάμε τον τρίτο βαθμό */scanf(“%f”, &x); /* η x τώρα λαμβάνει τον τρίτο βαθμό */sum = sum + x; /* καταχώρισε την τρίτη τιμή στη μεταβλητή sum, */

/* μαζί με ό,τι προϋπήρχε (ο βαθμός1 + ο βαθμός2)*/

printf(“Δώσε τον τέταρτο βαθμό\n”); /* ζητάμε τον τέταρτο βαθμό */scanf(“%f”, &x); /* η x τώρα λαμβάνει τον τέταρτο βαθμό */sum = sum + x; /* καταχώρισε την τέταρτη τιμή στη μεταβλητή sum, */

/* μαζί με ό,τι προϋπήρχε (ο βαθμός1 + ο βαθμός2 + ο βαθμός3)*/

κλπ.

…μάλιστα. Άλλες 96 τέτοιες τριάδες εντολών και … τελειώσαμε

Επαναληπτικές διαδικασίες - Η εντολή for

Και όμως υπάρχει λύση στην ατελείωτη πληκτρολόγηση (και δεν εννοούμε βέβαια την κλασσική …copy-paste). Όταν μία διαδικασία επαναλαμβάνεται στο πρόγραμμά μας, υπάρχει μία ειδική εντολή στην οποία αρκεί να δηλώσουμε πόσες φορές θα επαναληφθούν οι εντολές που αποτελούν την διαδικασία αυτή. Η εντολή αυτή είναι η for και συντάσσεται ως εξής:

for(i = 0; i < loop_times; i ++){ /* η ανοικτή αγκύλη σηματοδοτεί την έναρξη*/

ακολουθούν οι εντολές που θέλουμε να επαναλαμβάνονται

(πάντα μέσα στις δύο αγκύλες)

} /* και η κλειστή την λήξη μίας περιόδου επανάληψης*/

όπου : i, ο μετρητής της επανάληψης loop_times, o αριθμός επαναλήψεων και τα τρία πεδία εντός της παρένθεσης, τα οποία προσδιορίζουν τα εξής:

i = 0 : το πρώτο πεδίο δηλώνει την αρχική τιμή με την οποία θα ξεκινήσει να μετράει ο αθροιστής. Η τιμή αυτή λαμβάνεται μία και μοναδική φορά απ’τον μετρητή, όταν δηλαδή ξεκινήσει για πρώτη φορά η επανάληψη. Στη συνέχεια ο μετρητής θα μεταβάλει τις τιμές του ανάλογα με το τρίτο πεδίο ή κάποια άλλη εντολή -πιθανώς- η οποία βρίσκεται εντός των αγκύλων επανάληψης (μέσα δηλαδή στον βρόγχο ή loop). Το i μπορεί να λαμβάνει οποιαδήποτε αρχική τιμή (πχ. i = 1 ή i = -2 ή i = 1000), ανάλογα πως αυτό βολεύει στην χρήση του.

i < loop _ times : το δεύτερο πεδίο δηλώνει τη συνθήκη επανάληψης. Όταν αυτή παύσει να ισχύει σταματούν και οι επαναλήψεις. Εδώ δηλώνεται σαν συνθήκη ανισότητας, δηλαδή όσο η μεταβλητή i είναι μικρότερη από μία τιμή οι επαναλήψεις θα συνεχίζονται. Όταν το i λάβει την τιμή loop_times το πρόγραμμα σταματάει τις επαναλήψεις και συνεχίζει εκτελώντας τις εντολές που ακολουθούν


16

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

i = = 100 (το i να ισούται με 100) i >= - 45 (το i να είναι μεγαλύτερο ή ίσο με το - 45) i > 500 | | i < 1000 (το i να είναι μεγαλύτερο του 500 είτε μικρότερο του 1000) i < 1000 && k = = 0 (το i να είναι μικρότερο του 1000 και ταυτόχρονα το k ίσο με 0) x != 0 (μία άλλη μεταβλητή x να είναι διάφορη του μηδενός) a/23*sin(z) <= b (η συγκεκριμένη παράσταση να είναι μικρότερη ή ίση με το b) (c = getchar( ) ) != ‘\n’ (να μην πληκτρολογήσουμε enter)

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

i -- (το i να μειώνεται κάθε φορά κατά μία μονάδα)i += 3 (το i να αυξάνεται κάθε φορά κατά τρεις μονάδες)i -= 8, j ++ (το i να μειώνεται κάθε φορά κατά 8 μονάδες και το j να

αυξάνεται κατά μία)

Το πρόγραμμα υπολογισμού Μ.Ο. εκατό (ή οποιουδήποτε πλήθους) τιμών

Το πρόγραμμα τώρα έχει ως εξής:

/***** υπολογισμός Μ.Ο. 100 πραγματικών αριθμών *****/main( ){float sum = 0;float x = 0;int i = 0;

for(i = 0 ; i < 100 ; i ++){ /* αρχή βρόγχου επανάληψης */printf(“\nΔώσε τον %d ο βαθμό: ”, i +1);scanf(“%f”, &x);sum = sum + x;} /* τέλος βρόγχου επανάληψης */

printf(“\nΟ μέσος όρος των 100 βαθμών είναι: %f”, sum/100);

} /* τέλος της main( ) */

Eάν θέλαμε να υπολογίζουμε τον Μ.Ο. ενός οποιουδήποτε πλήθους τιμών, το πρόγραμμά μας θα αλλάξει ελάχιστα:

1. Θα προσθέσουμε μία ακέραια μεταβλητή η οποία θα δέχεται το πλήθος για το οποίο θα υπολογίζουμε τον Μ.Ο. (πχ. η amount )


17

2. Η σύγκριση επανάληψης στον βρόγχο της for, δεν θα συγκρίνει πλέον τον μετρητή i με την τιμή 100, αλλά με την μεταβλητή amount

3. Η διαίρεση τέλος, εντός την printf( ), δεν θα γίνεται με το 100 αλλά με την amount,

δηλαδή:

/***** υπολογισμός Μ.Ο. μεταβλητού πλήθους πραγματικών αριθμών *****/main( ){float sum = 0;float x = 0;int i = 0;int amount = 0;

printf(“\nΠοιο είναι το πλήθος των βαθμών για τον υπολογισμό του Μ.Ο.; ”);scanf(“%d”, &amount); /* η amount παίρνει τιμή απ΄το πληκτρολόγιο */

for(i = 0 ; i < amount ; i ++){ /* αρχή βρόγχου επανάληψης */printf(“\nΔώσε τον %d ο βαθμό: ”, i +1);scanf(“%f”, x);sum = sum + x;} /* τέλος βρόγχου επανάληψης */

printf(“\nΟ μέσος όρος των %d βαθμών είναι: %f”, amount, sum/amount);


H εντολή if και οι παραλλαγές της

H εντολή if κατευθύνει την ροή του προγράμματος σε συγκεκριμένες ενότητες εντολών, ανάλογα το αποτέλεσμα που λαμβάνει. Δηλαδή:

if(x>y){ a = 1; /* η ενότητα εντολών η οποία εκτελείται μόνο εάν το x > y */

printf(“\nΤο x είναι όντως μεγαλύτερο από το y”);}else{ /* δηλαδή εάν το x<= y */

a = 0; /* η ενότητα εντολών η οποία εκτελείται εάν το x <= y */printf(“\nΤο y είναι όντως μεγαλύτερο (ή ίσο) από το x”);

}…

Εάν θέλουμε το πρόγραμμά μας να κάνει συγκεκριμένες ενέργειες μόνο όταν το x > y και στην περίπτωση που δεν ισχύει κάτι τέτοιο απλώς να συνεχίζει, τότε συντάσσουμε την if χωρίς την else:

if(x>y){ /* η ενότητα εντολών η οποία εκτελείται μόνο εάν το x > y */a = 1; printf(“\nΤο x είναι όντως μεγαλύτερο από το y”);

}


18

… /* το πρόγραμμα συνεχίζει με άλλες εντολές */

Εάν τέλος θέλουμε να κάνουμε συγκεκριμένες ενέργειες και για την περίπτωση της ισότητας ξεχωριστά (x = y), τότε γράφουμε μία ακόμη if:

if(x>y){ /* η ενότητα εντολών η οποία εκτελείται μόνο εάν το x > y */ a = 1;

printf(“\nΤο x είναι όντως μεγαλύτερο από το y”);}else if(x<y){ /* η ενότητα εντολών η οποία εκτελείται εάν το x < y */

a = 0; printf(“\nΤο y είναι όντως μεγαλύτερο από το x”);

}else{ /* η ενότητα εντολών η οποία εκτελείται εάν το x = y */

a = -1;printf(“\nΗ ζωή δεν είναι πάντα άσπρο-μαύρο”);

}…

Ο πιο καλός ο μαθητής

Με τη βοήθεια της if μπορούμε να επανέλθουμε στο προηγούμενο πρόγραμμα M.O. και να βρίσκουμε κάθε φορά και τον μεγαλύτερο βαθμό.

Η λογική που θα ακολουθήσουμε είναι απλή:

1. Θα χρειαστούμε μία επιπλέον μεταβλητή (float), η οποία θα κρατάει τον μεγαλύτερο βαθμό, ας την ονομάσουμε best 2. H best θα πάρει μία πρώτη τιμή, τον πρώτο-πρώτο δηλαδή βαθμό που θα πληκτρολογήσουμε 3. Θα την συγκρίνουμε με τον επόμενο βαθμό. Εάν αυτός είναι μεγαλύτερος τότε η τιμή της θα αλλάξει και στη θέση της θα μπει ο βαθμός αυτός. Διαφορετικά δεν θα αλλάξει τίποτα και συνεχίζουμε με την επόμενη τιμή 4. Θα επαναλάβουμε τη διαδικασία 3 ώσπου να τελειώσουν όλοι οι βαθμοί. Η τελική τιμή που θα έχει η μεταβλητή best θα είναι ο μεγαλύτερος βαθμός.

/***** υπολογισμός Μ.Ο. μεταβλητού πλήθους πραγματικών αριθμών *****//***** και εξαγωγή μέγιστης τιμής ****/main( ){float sum = 0;float x = 0;int i = 0;int amount = 0;float best = 0;

printf(“/nΠοιο είναι το πλήθος των βαθμών για τον υπολογισμό του Μ.Ο.; ”);scanf(“%d”, &amount); /* η amount παίρνει τιμή απ΄το πληκτρολόγιο */


19

printf(“\nΔώσε τον 1-ο βαθμό: ”);scanf(“%f”, &best); /* η best παίρνει σαν πρώτη τιμή τον πρώτο βαθμό */

for(i = 0 ; i < amount-1 ; i ++){ /* η επανάληψη τώρα θα γίνει amount-1 φορές */printf(“\nΔώσε τον %d-ο βαθμό: ”, i +2);scanf(“%f”, &x);sum = sum + x;if(x>best){ /* αρχή της if */

best = x; /* εάν η x > best τότε η best θα λάβει την τιμή του x */} /* τέλος της if */

} /* τέλος βρόγχου επανάληψης */

printf(“\nΟ μέσος όρος των %d βαθμών είναι: %f”, amount, sum/amount);printf( “\nO μέγιστος βαθμός είναι ο %f”, best);} /* τέλος της main( ) */

H εντολή while( )

Έστω τώρα πως θέλουμε να υπολογίσουμε τα ίδια στοιχεία (Μ.Ο. και μέγιστη τιμή) αλλά για περισσότερες από μία ομάδες βαθμολογούμενων (πχ. τέσσερα διαφορετικά τμήματα). Η μία λύση είναι να γράψουμε τον παραπάνω κώδικα τέσσερις φορές. Η άλλη λύση είναι να συμπεριλάβουμε όλο τον παραπάνω κώδικα σε μία for με μετρητή έως τέσσερα. Υπάρχει όμως και απλούστερη λύση: η εντολή while( )

Η while συντάσσεται ως εξής:

while(συνθήκη){…εντολές….

}…

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

Η παύση της συνθήκης προϋποθέτει ότι έχουμε φροντίσει εμείς για κάποιον μετρητή ο οποίος σε κάθε επανάληψή της θα αυξάνεται, πχ.:

k = 0;while(k < 4){ /* η while θα εκτελεστεί τέσσερις φορές */

………k++; /* ο μετρητής σε κάθε πέρασμα αυξάνεται */

}


20

(προσοχή: Σε περίπτωση που δε φροντίσουμε για κάτι τέτοιο το πρόγραμμα πέφτει σε ατέρμονο βρόγχο και δεν τερματίζει ποτέ !)

Εάν στη θέση του 4 βάλουμε κάποια μεταβλητή (πχ. η μεταβλητή με όνομα times, τύπου int) τότε ζητώντας την τιμή της times μπορούμε να έχουμε διαφορετικό αριθμό επαναλήψεων κάθε φορά που τρέχουμε το πρόγραμμά μας:

printf(“\nΔώστε αριθμό επαναλήψεων”);scanf(“%d”, &times);

k = 0;while(k<times){ /* η while θα εκτελεστεί times φορές */

………k++;

}

To πρόγραμμα Μ.Ο.- μέγιστης τιμής για μεταβλητό αριθμό επαναλήψεων

/***** υπολογισμός Μ.Ο. μεταβλητού πλήθους πραγματικών αριθμών *****//***** και εξαγωγή μέγιστης τιμής ****//******* για πολλαπλά τμήματα ******/main( ){float sum = 0;float x = 0;int i = 0;int amount = 0;float best = 0;int times, k;

printf(“\nΓια πόσα τμήματα θα βγει Μ.Ο. και μέγιστος βαθμός;”);scanf(“%d”, &times);

k = 0;while(k < times){ /* αρχή της while */

printf(“/nΠοιο είναι το πλήθος των βαθμών για τον υπολογισμό του Μ.Ο.; ”);scanf(“%d”, &amount);

printf(“\nΔώσε τον 1 ο βαθμό: ”);scanf(“%f”, &best);

for(i = 0 ; i < amount-1 ; i ++){printf(“\nΔώσε τον %d ο βαθμό: ”, i +2);scanf(“%f”, &x);sum = sum + x;if(x>best){


21

best = x;} /* τέλος της if */

} /* τέλος βρόγχου επανάληψης */

printf(“\nΓια το %d o τμήμα:”, k+1);printf(“\nΟ μέσος όρος των %d βαθμών είναι: %f”, amount, sum/amount);printf( “\nO μέγιστος βαθμός είναι ο %f”, best);

k++;} /* τέλος της while */



22

Ήχος και υπολογιστές

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

Ο ήχος που παράγει ο υπολογιστής, όπως για παράδειγμα μία ημιτονοειδής κυματομορφή, είναι οι αριθμητικές τιμές μιας περιόδου της κυματομορφής οι οποίες επαναλαμβάνονται διαρκώς και στέλνονται στην έξοδο της κάρτας ήχου. Για να συμβεί κάτι τέτοιο οι τιμές αυτές πρέπει να βρίσκονται καθ’ όλη τη διάρκεια της αναπαραγωγής του ήχου κάπου αποθηκευμένες στη μνήμη. Το πλήθος αυτών των τιμών απαντάται συνήθως ως δύναμη του δύο, όπως για παράδειγμα 128 τιμές. Χρειαζόμαστε λοιπόν 128 διαφορετικές μεταβλητές προκειμένου να αποθηκεύονται οι τιμές μόνιμα στη μνήμη αλλά και να διαβάζονται κάθε φορά που αναπαράγεται η κυματομορφή. Το να χειριστούμε κάτι τέτοιο με απλές μεταβλητές, είναι προγραμματιστικά επίπονο. Για τον ευκολότερο λοιπόν χειρισμό πολλαπλών μεταβλητών του ίδιου τύπου (πραγματικών αριθμών ή double στη συγκεκριμένη περίπτωση), κάνουμε χρήση των πινάκων.

Πίνακες (Arrays)

Ο πίνακας είναι ένας χώρος στη μνήμη που καταλαμβάνεται από πολλές τιμές του ίδιου τύπου. Δηλώνεται ως εξής:

τύπος _μεταβλητών_πίνακα Όνομα_Πίνακα[μέγεθος], πχ.:

όπου:τύπος _μεταβλητών_πίνακα: ο τύπος δεδομένων των στοιχείων που

περιλαμβάνει ο πίνακας (π.χ. int, float, char)Όνομα_Πίνακα: το όνομά του (ακριβώς όπως ονομάζουμε και μία

οποιαδήποτε άλλη μεταβλητή, π.χ. Α, Χ, Array, b23 κλπ.)μέγεθος: το πλήθος των στοιχείων από το οποίο αποτελείται ο πίνακας

int A[23]; ένας πίνακας με 23 θέσεις ακέραιων αριθμών και όνομα Achar Names[1000]; ένας πίνακας με 1000 θέσεις χαρακτήρων και όνομα

Namesfloat WAV[128]; ένας πίνακας με 128 θέσεις πραγματικών και όνομα WAV

Οι πίνακες κρατούν τα στοιχεία τους με συγκεκριμένη σειρά αρίθμησης ξεκινώντας από το 0 για το πρώτο στοιχείο, 1 για το δεύτερο, 2 για το τρίτο και καταλήγοντας μέγεθος - 1 για το τελευταίο. Έτσι όταν θέλουμε να προσπελάσουμε κάποιο στοιχείο ενός πίνακα δίνουμε τον αριθμό του στοιχείου που αντιστοιχεί σε αυτό πλάι στο όνομά του και μέσα στην παρένθεση. Παράδειγμα:

A[17] = 0; το 18ο στοιχείο του πίνακα Α θα λάβει την τιμή 0


23

printf(“%c”, Names[8]); εμφανίζουμε στην οθόνη το 9ο στοιχείο του ΝamesWAV[0] = sin(0); το 1ο στοιχείο του WAV θα λάβει την τιμή του ημίτονου 0 ακτινίων

Γέμισμα τιμών σε έναν πίνακα

Έστω πως θέλουμε να γεμίσουμε τα στοιχεία ενός πίνακα με κάποιες τιμές. Η διαδικασία αυτή είναι επαναλαμβανόμενη και πραγματοποιείται με μία for:

int i;int A[100]; /* ορισμός πίνακα */

/* γέμισμα πίνακα 100 θέσεων */for(i = 0 ; i < 100 ; i++){

printf(“\nΔώσε τιμή για το %d στοιχείο του πίνακα”, i+1);scanf(“%d”, A[i]);}

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

Α[i], όπου i o δείκτης του αντίστοιχου στοιχείου

Οι παρακάτω λοιπόν γραμμές κώδικα είναι απολύτως σωστές:

Α[i] = Α[i +1] (το στοιχείο Α[i] λαμβάνει την τιμή του επόμενου στοιχείου)Α[i] = Α[i] +1 (τα περιεχόμενα του στοιχείου Α[i] προσαυξάνονται κατά μία

μονάδα) A[28] = A[0]/15 + b (καταχώρισε στο 29ο στοιχείο το αριθμητικό αποτέλεσμα

της παράστασης δεξιά)

Εκτύπωση τιμών ενός πίνακα

Παρόμοια τα περιεχόμενα ενός πίνακα εμφανίζονται ως εξής:

for(i = 0 ; i < 100 ; i++){printf(“\nΤο %d στοιχείο του πίνακα είναι ίσο με: %d”, i+1, A[i]);

}

Παράδειγμα: ένας πίνακας ημιτονοειδούς κυματομορφής

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

Η συνάρτηση η οποία παράγει τιμές ημιτόνου είναι η:

sin(x), όπου x τα ακτίνια του κύκλου (radians)Εισαγωγή στη author: γλώσσα προγραμματισμού C Ταξιάρχης Διαμαντόπουλος

24

και η οποία βρίσκεται ενσωματωμένη στη βιβλιοθήκη μαθηματικών συναρτήσεων της C (math.h). Για να την χρησιμοποιήσουμε στο πρόγραμμά μας πρέπει λοιπόν πριν απ΄ οτιδήποτε άλλο να την συμπεριλάβουμε στο πρόγραμμα. Αυτό γίνεται με την εντολή include, στην αρχή του κώδικά μας πριν την main( ):

#include <math.h>

Στη συνέχεια πρέπει να υπολογίσουμε τα 128 διαφορετικά ακτίνια απ’τα οποία αποτελείται ένας κύκλος (μία δηλαδή πλήρης περίοδος της κυματομορφής).Γνωρίζουμε ότι:

ένας κύκλος = 2π ακτίνια (όπου π = 3.14)

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

Στην πρώτη θέση του πίνακα W[0], θα καταχωρίσουμε την τιμή του sin(0).Στην δεύτερη θέση του πίνακα W[1], θα καταχωρίσουμε την τιμή του sin(2π/128).Στην τρίτη θέση του πίνακα W[2], θα καταχωρίσουμε την τιμή του sin(2π/128*2).…Στην εκατοστή εικοστή όγδοη W[127], την τιμή sin(2π/128*127)

Χρησιμοποιούμε λοιπόν μία επιπλέον μεταβλητή (double step), η οποία είναι το βήμα που κάθε φορά προσαυξάνεται η τρέχουσα τιμή έτσι ώστε να υπολογίζεται το επόμενο ημίτονο. Η step λοιπόν ορίζεται ως εξής:


25

step = two_pi/128;

και για να έχουμε μία καλύτερη αριθμητική προσέγγιση της μεταβλητής two_pi δηλώνουμε:

double two_pi = 8.*atan(1.);

(όπου η μαθηματική συνάρτηση atan(x) υπολογίζει το τόξο εφαπτομένης του x)

γιατί όντως 2π = 8 x (τόξο εφαπτομένης(1))

To πρόγραμμά μας ολοκληρωμένο έχει ως εξής:

#include <math.h>

main( ){double two_pi = 8.*atan(1.); /* υπολογισμός της 2π */double w[128]; /* δήλωση πίνακα 128 double θέσεων */double step, x; int i;

x = 0;step = two_pi / 128; /* υπολογισμός βήματος */

for(i=0; i<128; i++){w[i] = sin(x); /* υπολόγισε το τρέχον ημίτονο */x = x + step; /* και αύξησε την επόμενη τιμή κατά step */

}

for(i=0; i<128; i++){printf(“w[%d] = %f”, i, w[i]);/* εκτύπωση τιμών πίνακα */

}

}


26

ΕΙΣΑΓΩΓΗ ΣΤΗΝ ΓΛΩΣΣΑ ΠΡΟΓΡΑΜΜΑΤΙΣΜΟΥ...

Documents

Transcript of ΕΙΣΑΓΩΓΗ ΣΤΗΝ ΓΛΩΣΣΑ ΠΡΟΓΡΑΜΜΑΤΙΣΜΟΥ...