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

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

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

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

		εντολές;
		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');
        }
}

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

Η τιμή μιας μεταβλητής που έχει οριστεί μέσα σε ένα τμήμα χάνεται όταν ο έλεγχος του προγράμματος βγει από το τμήμα αυτό.

Γενικά, καλό είναι οι μεταβλητές να ορίζονται κοντά στο τμήμα που χρησιμοποιούνται. Σε μικρές συναρτήσεις αυτό είναι εφικτό με τον ορισμό τους στην αρχή της συνάρτησης. Όταν όμως μια μεταβλητή έχει ρόλο μόνο μέσα σε ένα περιορισμένο τμήμα, τότε καλό είναι να οριστεί μέσα στο τμήμα.

Ασκήσεις

Σχεδιασμός

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

#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.