Τα πάντα για την C

[migf1]

Ε ναι, είναι από τους βασικούς λόγους ύπαρξης των συναρτήσεων η τιμή επιστροφή τους. Οπότε, για τις επόμενες ασκήσεις ας ξεκινήσουμε με συναρτήσεις

[migf1]

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

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

Ας πάρουμε ένα πολύ απλό παράδειγμα συνάρτησης, που δέχεται 2 ορίσματα κι επιστρέφει το άθροισμά τους. Ας την ονομάσουμε sum2f κι ας ορίσουμε τα ορίσματα να είναι float.

Το πρότυπο λοιπόν της συνάρτησης είναι το:

Κώδικας: Επιλογή όλων


float sum2f( float, float);


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

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

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

Π.χ.

Κώδικας: Επιλογή όλων

float sum2f( float /*x*/, float /*y*/);

ΣΗΜΑΝΤΙΚΟ: Τα πρότυπα ΔΕΝ είναι οι ορισμοί των συναρτήσεων, στους ορισμούς τους (εκεί δηλαδή που γράφουμε και τον κώδικα της συνάρτησης) πρέπει ΥΠΟΧΡΕΩΤΙΚΑ να βάζουμε και τα ονόματα των ορισμάτων.

Όταν μια συνάρτηση δεν έχει ορίσματα, τότε γράφουμε void μέσα στην παρένθεση των ορισμάτων (και στο πρότυπο και στον ορισμό της).

π.χ.

Κώδικας: Επιλογή όλων

float test( void );

Όταν μια συνάρτησή δεν επιστρέφει τίποτα, τότε πάλι χρησιμοποιούμε το void ως τύπο για την τιμή επιστροφής της.

π.χ.

Κώδικας: Επιλογή όλων

void test( void );

void σημαίνει: κενό.

Ας ορίσουμε τώρα την συνάρτησή μας, να επιστρέφει το άθροισμα των 2 ορισμάτων της:

Κώδικας: Επιλογή όλων


float sum2f(float x, float y)
{
return x+y;
}


Η τιμή που θέλουμε να επιστρέφει η συνάρτησή μας μπαίνει με το keyword: return, ακολουθούμενο από την τιμή επιστροφής (ή την έκφραση που την υπολογίζει) η οποία προφανώς πρέπει να συμβαδίζει ως τύπος με τον τύπο επιστροφής που έχουμε δηλώσει πριν από το όνομα της συνάρτησης (αν όχι, ο compiler θα σας βγάλει error ή warning).

Τι τα θέλουμε τα πρότυπα;

Κανονικά στη C δεν μπορούμε να χρησιμοποιήσουμε μια συνάρτηση πριν την ορίσουμε. Οπότε κανονικά η main() που χρησιμοποιεί αν όχι όλες τότε τις περισσότερες από τις συναρτήσεις μας πρέπει να ορίζεται τελευταία. Όπως επίσης αν μια συνάρτηση foo1 χρησιμοποιεί μέσα της μια άλλη συνάρτηση foo2, τότε η foo2 πρέπει να οριστεί πριν από την foo1.

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

Οπότε ο κώδικας ενός προγράμματος που ζητάει 2 float και τυπώνει το άθροισμά τους μπορεί να γραφτεί με (τουλάχιστον) 2 τρόπους:

Τρόπος 1 (χωρίς χρήση προτύπων):

Κώδικας: Επιλογή όλων


#include <stdio.h>
// ------------------------------------------------------
float sum2f( float x, float y)
{
return x+y;
}
// ------------------------------------------------------
int main( void )
{
char inbuf[256]="";
float x, y;

printf("Enter two float numbers: ");
fgets(inbuf, 256, stdin);
sscanf(inbuf, "%f %f", &x, &y);
printf("Their sum is: %f\n", sum2f(x,y) );

return 0;
}


Τρόπος 2 (με χρήση προτύπων):

Κώδικας: Επιλογή όλων


#include <stdio.h>

// function prototypes
float sum2f(float /*x/, float /*y*/);

// ------------------------------------------------------
int main( void )
{
char inbuf[256]="";
float x, y;

printf("Enter two float numbers: ");
fgets(inbuf, 256, stdin);
sscanf(inbuf, "%f %f", &x, &y);
printf("Their sum is: %f\n", sum2f(x,y) );

return 0;
}
// ------------------------------------------------------
float sum2f( float x, float y)
{
return x+y;
}


ΥΓ. Είμαι ακόμα στη δουλειά (από το πρωί) και ήρθε η ώρα να πάω κι εγώ σπιτάκι μου σιγά-σιγά. Μάλλον θα ξαναμπώ αργότερα, αλλιώς αύριο. Γράψτε τυχόν απορίες σας μέχρι τώρα για τα παραπάνω (ή αν έχετε ακόμα απορίες από την είσοδο με το inbuf) και συνεχίζουμε.

[Star_Light]

οκ migf!!! Θα αραξουμε και εμεις με την ησυχια μας να τα κοιταξουμε και θα σου πουμε. Χαλαρα!! Καλη ξεκουραση.

[stamatiou]

οκ migf!!! Θα αραξουμε και εμεις με την ησυχια μας να τα κοιταξουμε και θα σου πουμε. Χαλαρα!! Καλη ξεκουραση.

+1

[Star_Light]

Εχω τις πρωτες μου 2 αποριες πανω στις συναρτήσεις!

Καταρχην αυτο που λες με το προτυπο και τον ορισμο τον καταλαβαινω... ειναι οπως στα μαθηματικα
πχ η

Κώδικας: Επιλογή όλων

y=f(x1,x2,x3)

έχει τα ορισματα της ... και την τιμη που θα επιστρεψει.. το y δηλαδη.

ενω ο ορισμός της θα ήταν

Κώδικας: Επιλογή όλων

y=f(x1,x2,x3)=x1^2 + x2*x3 + 2*x2 ......

τι "δουλεια" κανει δηλαδη η συναρτηση που έχεις ορισει.

και μετα εχω μια βασικη απορια.... εδω κυριως

Κώδικας: Επιλογή όλων

printf("Enter two float numbers: ");
fgets(inbuf, 256, stdin);
sscanf(inbuf, "%f %f", &x, &y);


αφου στο stdio.h μεσα την fgets την έχει σαν προτυπο ετσι =>

Κώδικας: Επιλογή όλων

extern char *fgets (char *__restrict__s , int n , FILE * __restrict__ stream)

πως εσυ της περνας float τιμη???? δοκιμασα και στον κωδικα με τους δεικτες στην αλλη ενοτητα (Ασυγχρονα μαθηματα - προγραμματα / ασκησεις σε C)
να το φτιαξω με την sscanf αντι για scanf και την fgets και μου πεταξε warning ο μεταγλωτιστης λεγοντας μου οτι παω να δωσω int ενω περιμενει παραμετρους char αυτη η συναρτηση......

[migf1]

Ευχαριστώ παιδιά

Ας γράψω λίγη ακόμα ψιλο-θεωρία για να κάνουμε και καμιά άσκηση

Κάτι που ξέχασα στο προηγούμενο ποστ είναι πως όταν η συνάρτησή μας δεν επιστρέφει τίποτα, τότε εκτός από το void που βάζουμε μπροστά από το όνομά της, βάζουμε κι ένα σκέτο: return; στο κυρίως σώμα της, πριν την τερματίσουμε.

Για παράδειγμα, ο κώδικας μια συνάρτησης που απλά τυπώνει μια γραμμή και δεν περιμένει ορίσματα και δεν επιστρέφει τίποτα, είναι κάπως έτσι:

Κώδικας: Επιλογή όλων


void put_line( void )
{
puts("------------------------------------------------------");
return;
}


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

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

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

Κώδικας: Επιλογή όλων


float prod2f(float x, float y)
{
return x*y;
}


Οπότε όταν θέλουμε το άθροισμα καλούμε την sum2f και όταν θέλουμε το γινόμενο καλούμε την prod2f.

Ωστόσο πολύ συχνά χρειαζόμαστε μια συνάρτηση να μας επιστρέφει περισσότερα του ενός "πράγματος", κι από τη στιγμή που εξ' ορισμού οι συναρτήσεις επιστρέφουν μονάχα ένα "πράγμα" φαίνεται σαν να έχουμε πρόβλημα.

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

Ας δούμε πρώτα τον κώδικα μιας τέτοιας συνάρτησης (ας την ονομάσουμε calc):

Κώδικας: Επιλογή όλων


void calc( float x, float y, float *sum, float *prod)
{
*sum = x+y;
*prod = x*y;

return;
}


Οκ, πέσανε λίγο μαζεμένα αρκετά πράγματα στον παραπάνω κώδικα!

Καταρχήν παρατηρούμε πως η συνάρτηση πλέον δεν έχει δικιά της τιμή επιστροφής, είναι void, δεν επιστρέφει τίποτα... για αυτό και βάλαμε ένα σκέτο: return; στο τέλος της.

Έπειτα βλέπουμε πως εκτός από τα ορίσματα x και y περιμένει άλλα δυο, τα sum και prod, μέσα στα οποία αποθηκεύει τους δυο υπολογισμούς (ένα για το άθροισμα των x, y κι ένα για το γινόμενό τους).

Σε αντίθεση με τα x και y οι τιμές των οποίων μας είναι αδιάφορες μετά τον τερματισμό της συνάρτησης, οι τιμές των sum και prod μας ενδιαφέρει να παραμείνουν ενεργές μετά το τέλος της συνάρτησης, για να μπορέσουμε να τις χρησιμοποιήσουμε (π.χ. μέσα σε κάποιο printf της main, μετά την κλήση της συνάρτησης).

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

Δείτε το στην πράξη με τον παρακάτω κώδικα:

Κώδικας: Επιλογή όλων


#include <stdio.h>
// ------------------------------------------------------
void calc( float x, float y, float *sum, float *prod)
{
*sum = x+y;
*prod = x*y;

return;
}
// ------------------------------------------------------
int main( void )
{
char inbuf[256]="";
float x, y, sum, prod;

printf("Enter two float numbers: ");
fgets(inbuf, 256, stdin);
sscanf(inbuf, "%f %f", &x, &y);

calc(x, y, &sum, &prod);

printf("Their sum is: %f\n", sum );
printf("Their product is: %f\n", prod );

return 0;
}


Τις μεταβλητές x και y τις περάσαμε κανονικά στην συνάρτηση (δεν μας ενδιαφέρουν οι τιμές τους μετά το τέλος της συνάρτησης) αλλά τις μεταβλητές sum και prod τις περνάμε ως διευθύνσεις, επειδή τις τιμές τους θέλουμε να τις χρησιμοποιήσουμε και μετά τη συνάρτηση (στα 2 printf).

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

[migf1]

[snip]

Πολύ ωραίος και σωστός ο παραλληλισμός με τα μαθηματικά! Ακριβώς έτσι είναι!

Για την fgets όμως, που είδες βρε συ να περνάμε float;

[Star_Light]

απολυτα κατανοητα απο μενα τουλαχιστον. Εκτος απο τις 2 (1 επι της ουσιας) απορια που ανεφερα πιο πανω.

Πολυ καλο αυτο που λες με την τιμη επιστροφης... να την αφησουμε δηλαδη void... τροπος σκεψης!!! Για αυτο λενε πως ο προγραμματισμος τελικα ειναι τροπος σκέψης.

[Star_Light]

Πολύ ωραίος και σωστός ο παραλληλισμός με τα μαθηματικά! Ακριβώς έτσι είναι!

Για την fgets όμως, που είδες βρε συ να περνάμε float;

Nαι οκ! Σωστα... απλα κανε πως δεν το διαβασες ποτε αυτο

[Star_Light]

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

Δηλαδη εδω εννοεις πως οπως με την sscanf που μπερδευτηκα εγω για το τι ακριβως ειναι αυτο το int που επεστρεφε και που ακριβως αναφεροταν ετσι μπορει να την "πατησεις" και με άλλες συναρτήσεις? Γιατι συνηθως κοιταμε τα ονοματα των μεταβλητων και των συναρτησεων για να υποθεσουμε τι παιζει πανω κατω... και οι αλλοι προγραμματιστες το κωδικοποιουν ετσι ωστε να τηρει την αρχη του να ειναι ευανάγνωστο ????