Οι παράμετροι (parameters) σε μια συνάρτηση στη γλώσσα C++ είναι μεταβλητές που χρησιμοποιούνται για την παραλαβή και επεξεργασία δεδομένων μέσα στη συνάρτηση. Οι παράμετροι ορίζονται κατά τη δήλωση της συνάρτησης και προσδιορίζουν τον τύπο και το όνομα των δεδομένων που αναμένεται να περαστούν στη συνάρτηση κατά την κλήση της.
Σύνταξη:
return_type function_name(parameter1, parameter2, parameter3, ..., parameterN) { // κώδικας }
Η συνάρτηση function_name()
έχει παραμέτρους parameter1
, parameter2
, parameter3
, …, parameterN
. Ο κώδικας της συνάρτησης μπορεί να χρησιμοποιήσει αυτούς τους παραμέτρους ως μεταβλητές. Οι τύποι των παραμέτρων δηλώνονται επίσης στη δήλωση της συνάρτησης.
Για παράδειγμα, η παρακάτω συνάρτηση multiplyNumbers
έχει δύο παραμέτρους τύπου int
, με ονόματα a
και b
:
int multiplyNumbers(int a, int b) { int result = a * b; return result; }
Οι παράμετροι a
και b
λειτουργούν ως τοπικές μεταβλητές μέσα στη συνάρτηση και μπορούν να χρησιμοποιηθούν για τις πράξεις και τις επεξεργασίες που απαιτούνται. Κατά την κλήση της συνάρτησης, τιμές περνιούνται στις παραμέτρους και αυτές οι τιμές αντιστοιχίζονται στις μεταβλητές a
και b
για την εκτέλεση των υπολογισμών.
Η χρήση παραμέτρων στις συναρτήσεις μας επιτρέπει να περνούμε δεδομένα σε μια συνάρτηση, να τα επεξεργαζόμαστε και να επιστρέφουμε αποτελέσματα, καθιστώντας τον κώδικα μας ευέλικτο και επαναχρησιμοποιήσιμο.
Το παρακάτω παράδειγμα έχει μια συνάρτηση που παίρνει μια συμβολοσειρά με όνομα fname
ως παράμετρο. Όταν καλείται η συνάρτηση, περνάμε ένα όνομα, το οποίο χρησιμοποιείται μέσα στη συνάρτηση για να εκτυπωθεί το πλήρες όνομα:
#include <iostream> #include <string> void printName(std::string fname) { std::cout << "Your name is " << fname << std::endl; } int main() { printName("John Doe"); // Κλήση της συνάρτησης printName με όρισμα "John Doe" return 0; }
Ο παραπάνω κώδικας στη γλώσσα C++ περιλαμβάνει τη δήλωση μιας συνάρτησης με όνομα printName
, η οποία δέχεται ένα παράμετρο τύπου std::string
με όνομα fname
. Η συνάρτηση αυτή εκτυπώνει στην οθόνη το μήνυμα “Your name is ” ακολουθούμενο από την τιμή της παραμέτρου fname
.
Στη συνέχεια, η συνάρτηση main
καλεί τη συνάρτηση printName
και περνά ως όρισμα τη σταθερή συμβολοσειρά “John Doe”. Κατά την εκτέλεση του προγράμματος, η συνάρτηση printName
θα εκτελεστεί και θα εμφανίσει στην οθόνη το μήνυμα “Your name is John Doe”.
Τέλος, η main
συνάρτηση επιστρέφει την τιμή 0, υποδηλώνοντας ότι το πρόγραμμα ολοκληρώθηκε επιτυχώς.
Στη γλώσσα C++, μπορείτε να ορίσετε μια προκαθορισμένη τιμή για μια παράμετρο χρησιμοποιώντας τον χαρακτήρα ισοδυναμίας (=) κατά τη δήλωση της συνάρτησης. Αυτή η προκαθορισμένη τιμή θα χρησιμοποιηθεί όταν δεν δοθεί κάποια τιμή για την παράμετρο κατά την κλήση της συνάρτησης.
Για παράδειγμα:
void printName(std::string fname = "Unknown") { std::cout << "Your name is " << fname << std::endl; }
Στον παραπάνω κώδικα, η παράμετρος fname
της συνάρτησης printName
έχει μια προκαθορισμένη τιμή της συμβολοσειράς “Unknown”. Αν καλεστεί η συνάρτηση χωρίς να δοθεί τιμή για την παράμετρο fname
, η προκαθορισμένη τιμή θα χρησιμοποιηθεί και θα εκτυπωθεί το μήνυμα “Your name is Unknown”.
Ωστόσο, αν περαστεί μια τιμή για την παράμετρο fname
κατά την κλήση της συνάρτησης, αυτή η τιμή θα υπερισχύσει της προκαθορισμένης τιμής. Για παράδειγμα:
printName("John Doe"); // θα εκτυπωθεί: Your name is John Doe printName(); // θα εκτυπωθεί: Your name is Unknown
Στη δεύτερη κλήση της συνάρτησης, όπου δεν δίνεται τιμή για την παράμετρο fname
, χρησιμοποιείται η προκαθορισμένη τιμή “Unknown”.
[adinserter block=”2″]
Εάν καλέσουμε τη συνάρτηση χωρίς όρισμα, χρησιμοποιείται η προκαθορισμένη τιμή (“Ελλάδα”):
#include <iostream> #include <string> // Ορισμός της συνάρτησης printCountry με προαιρετική παράμετρο void printCountry(std::string country = "Greece") { std::cout << "You are from " << country << std::endl; } int main() { printCountry("France"); // Κλήση της συνάρτησης printCountry με όρισμα "France" printCountry("USA"); // Κλήση της συνάρτησης printCountry με όρισμα "USA" printCountry(); // Κλήση της συνάρτησης printCountry χωρίς όρισμα (χρησιμοποιείται η προκαθορισμένη τιμή "Greece") printCountry("Spain"); // Κλήση της συνάρτησης printCountry με όρισμα "Spain" return 0; }
Ο παραπάνω κώδικας ορίζει μια συνάρτηση με όνομα printCountry
, η οποία εκτυπώνει μια χώρα. Η συνάρτηση έχει μια παράμετρο country
, η οποία έχει προκαθορισμένη τιμή “Greece”. Μέσα στη συνάρτηση, εμφανίζεται το μήνυμα “You are from ” ακολουθούμενο από την τιμή της παραμέτρου country
.
Στη συνάρτηση main
, καλούνται οι επαναλαμβανόμενες κλήσεις της printCountry
. Κατά την εκτέλεση, προσδιορίζεται η χώρα ως όρισμα για τη συνάρτηση printCountry
, και το μήνυμα “You are from ” ακολουθούμενο από την τιμή της χώρας εμφανίζεται στην έξοδο.
Η συνάρτηση εκτυπώνει:
You are from France You are from USA You are from Greece You are from Spain
Έτσι, ο κώδικας εκτυπώνει την χώρα για κάθε κλήση της printCountry
, με την προκαθορισμένη τιμή να χρησιμοποιείται όταν δεν παρέχεται όρισμα στη συνάρτηση.
Στη γλώσσα C++, το κλειδί void
, που χρησιμοποιήθηκε στα προηγούμενα παραδείγματα, υποδηλώνει ότι μια συνάρτηση δεν επιστρέφει κάποια τιμή. Αν επιθυμείτε να επιστρέψει μια τιμή, μπορείτε να χρησιμοποιήσετε έναν συγκεκριμένο τύπο δεδομένων (όπως int
, string
κ.λπ.) αντί για το void
, και να χρησιμοποιήσετε τη λέξη-κλειδί return
μέσα στη συνάρτηση για να επιστρέψετε την επιθυμητή τιμή:
int add(int a, int b) { int result = a + b; return result; }
Στο παραπάνω παράδειγμα, η συνάρτηση add
δέχεται δύο ακέραιες παραμέτρους a
και b
, και επιστρέφει το άθροισμά τους. Η εντολή return
χρησιμοποιείται για να επιστραφεί η τιμή του result
από τη συνάρτηση.
Έτσι, μπορείτε να ορίσετε συναρτήσεις που επιστρέφουν τιμές στη C++ χρησιμοποιώντας την κατάλληλη δήλωση του τύπου δεδομένων και το return
για την επιστροφή της τιμής στο σημείο κλήσης της συνάρτησης.
#include <iostream> // Ορισμός της συνάρτησης square που υπολογίζει το τετράγωνο ενός αριθμού int square(int x) { return x * x; } int main() { std::cout << square(5) << std::endl; // Εκτύπωση του τετραγώνου του αριθμού 5 return 0; }
Ο κώδικας αυτός περιλαμβάνει τη συνάρτηση square
, η οποία υπολογίζει το τετράγωνο ενός αριθμού. Μέσω της εντολής std::cout << square(5) << std::endl;
, εκτυπώνουμε στην οθόνη το τετράγωνο του αριθμού 5. Η εντολή std::endl
χρησιμοποιείται για να προκαλέσει έναν αλλαγή γραμμής μετά την εκτύπωση του αποτελέσματος. Τέλος, η συνάρτηση main
επιστρέφει την τιμή 0, υποδηλώνοντας ότι το πρόγραμμα ολοκληρώθηκε επιτυχώς.
Παράδειγμα επιστροφή άθροισματος δύο παραμέτρων μέσω μιας συνάρτησης:
#include <iostream> int sum(int x, int y) { return x + y; } int main() { std::cout << sum(5, 7) << std::endl; // Καλείται η συνάρτηση sum και εκτυπώνεται το αποτέλεσμα return 0; }
Ο παραπάνω κώδικας υλοποιεί μια απλή συνάρτηση sum
στη γλώσσα C++, η οποία δέχεται δύο ακέραιες παραμέτρους x
και y
, και επιστρέφει το άθροισμά τους.
Στην main
συνάρτηση, γίνεται η κλήση της sum
με τις τιμές 5 και 7 και το αποτέλεσμα εκτυπώνεται στην οθόνη μέσω της εντολής std::cout << sum(5, 7) << std::endl;
.
Συνολικά, ο κώδικας εκτελεί μια απλή πράξη πρόσθεσης και εμφανίζει το αποτέλεσμα στην οθόνη. Στο παράδειγμα αυτό, το αποτέλεσμα που θα εμφανιστεί είναι 12, καθώς η πρόσθεση των αριθμών 5 και 7 είναι 12.
[adinserter block=”3″]
Μπορείτε επίσης να αποθηκεύσετε το αποτέλεσμα σε μια μεταβλητή:
#include <iostream> // Ορισμός της συνάρτησης sum int sum(int x, int y) { return x + y; // Επιστρέφει το άθροισμα των παραμέτρων x και y } int main() { int result = sum(5, 7); // Κλήση της συνάρτησης sum με ορίσματα 5 και 7 std::cout << result << std::endl; // Εκτύπωση του αποτελέσματος στην οθόνη return 0; // Ο λειτουργικός κώδικας 0 υποδηλώνει επιτυχή ολοκλήρωση του προγράμματος }
Ο παραπάνω κώδικας περιέχει μία συνάρτηση sum
και την κύρια συνάρτηση main
. Ας δούμε τι κάνει ο κάθε τμήματα του κώδικα:
- Η συνάρτηση
sum
ορίζεται ως μία συνάρτηση τύπουint
με δύο παραμέτρουςx
καιy
. Εκτελεί την πράξηx + y
και επιστρέφει το αποτέλεσμα. - Η κύρια συνάρτηση
main
είναι η εκκίνηση του προγράμματος. Περιλαμβάνει τις παρακάτω ενέργειες:
- Δημιουργείται μια μεταβλητή
result
τύπουint
. - Καλείται η συνάρτηση
sum
με ορίσματα5
και7
, και το αποτέλεσμα αποθηκεύεται στη μεταβλητήresult
. - Χρησιμοποιώντας το αντικείμενο
std::cout
, τυπώνεται η τιμή της μεταβλητήςresult
στην οθόνη. - Η συνάρτηση
main
επιστρέφει την τιμή0
, υποδηλώνοντας ότι το πρόγραμμα ολοκληρώθηκε επιτυχώς.
Έτσι, ο κώδικας αυτός καλεί τη συνάρτηση sum
με τις παραμέτρους 5
και 7
, υπολογίζει το άθροισμα των δύο αριθμών και εκτυπώνει το αποτέλεσμα (12
) στην οθόνη.
Στη C++, μπορούμε να χρησιμοποιήσουμε το πέρασμα με αναφορά (pass by reference) για να περάσουμε παραμέτρους σε μια συνάρτηση. Αυτό μας επιτρέπει να αλλάξουμε την τιμή των παραμέτρων μέσα στη συνάρτηση και να διατηρήσουμε αυτές τις αλλαγές έξω από τη συνάρτηση.
Αντίθετα με το πέρασμα με αντιγραφή (pass by value), όπου δημιουργείται μια αντίγραφη της παραμέτρου και εργαζόμαστε με αυτήν την αντίγραφη, με το πέρασμα με αναφορά περνάμε τη διεύθυνση μνήμης της παραμέτρου. Έτσι, μπορούμε να αποκτήσουμε πρόσβαση στην πραγματική μεταβλητή και να τροποποιήσουμε την τιμή της.
Για παράδειγμα, ας υποθέσουμε ότι έχουμε την παρακάτω συνάρτηση:
void increment(int& x) { x++; }
Καλούμε τη συνάρτηση με έναν ακέραιο αριθμό:
int number = 5; increment(number);
Εδώ περνάμε τη μεταβλητή number
με αναφορά στη συνάρτηση increment
. Μέσα στη συνάρτηση, αυξάνουμε την τιμή της μεταβλητής κατά ένα. Όταν επιστρέψουμε στην κύρια συνάρτηση, η τιμή της μεταβλητής number
θα έχει αυξηθεί σε 6.
Έτσι, το πέρασμα με αναφορά μας επιτρέπει να αλλάξουμε τις τιμές των παραμέτρων και να επηρεάσουμε την κύρια συνάρτηση ή τον καλούντα κώδικα.
Παράδειγμα:
#include <iostream> // Συνάρτηση που ανταλλάσσει τις τιμές δύο μεταβλητών void swap(int &x, int &y) { int temp = x; // Αποθήκευση της τιμής της x στην προσωρινή μεταβλητή temp x = y; // Η x παίρνει την τιμή της y y = temp; // Η y παίρνει την τιμή που αποθηκεύτηκε στην temp } int main() { int a = 5; int b = 7; std::cout << "Before swap: a = " << a << ", b = " << b << std::endl; swap(a, b); // Κλήση της συνάρτησης swap για την ανταλλαγή των τιμών των a και b std::cout << "After swap: a = " << a << ", b = " << b << std::endl; return 0; }
Ο παραπάνω κώδικας υλοποιεί μια απλή συνάρτηση swap
που ανταλλάσσει τις τιμές δύο μεταβλητών και τη χρησιμοποιεί στην main
συνάρτηση για να ανταλλάξει τις τιμές δύο μεταβλητών a
και b
.
Αρχικά, δηλώνονται οι δύο μεταβλητές a
και b
με τις αρχικές τους τιμές (5 και 7 αντίστοιχα). Στη συνέχεια, εκτυπώνονται οι αρχικές τιμές των μεταβλητών.
Έπειτα, γίνεται η κλήση της συνάρτησης swap
με παράμετρο τις μεταβλητές a
και b
. Η συνάρτηση ανταλλάσσει τις τιμές των μεταβλητών αντιστρέφοντας τις μεταξύ τους.
Τέλος, εκτυπώνονται οι τελικές τιμές των μεταβλητών μετά την κλήση της swap
. Οι τιμές των μεταβλητών a
και b
έχουν αντιμεταθεί, καθώς από το αρχικό “Before swap: a = 5, b = 7” γίνονται “After swap: a = 7, b = 5”.
Συνολικά, ο κώδικας αυτός δείχνει πώς μπορούμε να χρησιμοποιήσουμε την αναφορά (reference) για να αλλάξουμε τις τιμές των μεταβλητών μέσω συνάρτησης.
Στη γλώσσα C++, μπορούμε επίσης να περάσουμε πίνακες ως παραμέτρους σε μια συνάρτηση. Αυτό μας επιτρέπει να διαχειριστούμε πίνακες μέσα στη συνάρτηση και να τροποποιήσουμε τα στοιχεία τους.
Για να περάσουμε έναν πίνακα ως παράμετρο, χρησιμοποιούμε τον τύπο δείκτη. Δηλαδή, ορίζουμε την παράμετρο τύπου “δείκτης προς τον τύπο των στοιχείων του πίνακα”. Έτσι, η συνάρτηση μπορεί να αναφερθεί στα στοιχεία του πίνακα και να τα τροποποιήσει ανάλογα.
Ένα παράδειγμα κώδικα που περνάει έναν πίνακα ως παράμετρο σε μια συνάρτηση μπορεί να είναι το εξής:
#include <iostream> void modifyArray(int* arr, int size) { for (int i = 0; i < size; i++) { arr[i] *= 2; // Πολλαπλασιάζει κάθε στοιχείο με 2 } } int main() { int numbers[] = {1, 2, 3, 4, 5}; // Κλήση της συνάρτησης modifyArray με τον πίνακα numbers ως παράμετρο modifyArray(numbers, 5); // Εκτύπωση του πίνακα μετά την τροποποίηση for (int i = 0; i < 5; i++) { std::cout << numbers[i] << " "; } std::cout << std::endl; return 0; }
Στο παράδειγμα αυτό, η συνάρτηση modifyArray
παίρνει έναν πίνακα arr
και το μέγεθος size
του πίνακα ως παραμέτρους. Στη συνέχεια, επαναλαμβάνει μέσω του δείκτη arr
και πολλαπλασιάζει κάθε στοιχείο του πίνακα με 2.
Στην main
συνάρτηση, δημιουργείται ένας πίνακας numbers
με αρχικές τιμές. Έπειτα, καλείται η συνάρτηση modifyArray
με παράμετρο τον πίνακα numbers
και το μέγεθος του (5). Τελικά, ο πίνακας numbers
εκτυπώνεται και φαίνεται ότι τα στοιχεία του έχουν τροποποιηθεί, καθώς πολλαπλασιάστηκαν με 2.
Με αυτόν τον τρόπο, μπορούμε να περάσουμε πίνακες ως παραμέτρους σε συναρτήσεις και να τους τροποποιήσουμε αποτελεσματικά μέσα στη συνάρτηση.
Παράδειγμα:
#include <iostream> // Συνάρτηση που εκτυπώνει τα στοιχεία ενός πίνακα void printArray(int arr[], int size) { for (int i = 0; i < size; i++) { std::cout << arr[i] << " "; } } int main() { int myArray[5] = {1, 2, 3, 4, 5}; // Κλήση της συνάρτησης printArray για να εκτυπώσουμε τον πίνακα printArray(myArray, 5); return 0; }
Ο παραπάνω κώδικας περιλαμβάνει τη δήλωση και τον ορισμό μιας συνάρτησης με όνομα printArray
, καθώς και την κύρια συνάρτηση main
.
Η συνάρτηση printArray
δέχεται δύο ορίσματα: έναν πίνακα ακεραίων arr
και το μέγεθος του πίνακα size
. Στο σώμα της συνάρτησης, χρησιμοποιείται ένας βρόχος for
για να εκτυπωθούν τα στοιχεία του πίνακα. Η std::cout
χρησιμοποιείται για να πραγματοποιήσει την εκτύπωση.
Στην κύρια συνάρτηση main
, δημιουργείται ένας πίνακας myArray
με 5 στοιχεία: 1, 2, 3, 4, 5. Στη συνέχεια, καλείται η συνάρτηση printArray
με τον πίνακα myArray
και το μέγεθος 5 για να εκτυπωθούν τα στοιχεία του πίνακα.
Ο κώδικας εκτυπώνει τα στοιχεία του πίνακα στη σειρά: 1 2 3 4 5. Η εκτέλεση του προγράμματος ολοκληρώνεται με την επιστροφή της τιμής 0 από τη συνάρτηση main
.