5.2 Οι παράμετροι (Parameters) συνάρτησης στη γλώσσα C++

Οι παράμετροι (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. Ας δούμε τι κάνει ο κάθε τμήματα του κώδικα:

1. Η συνάρτηση sum ορίζεται ως μία συνάρτηση τύπου int με δύο παραμέτρους x και y. Εκτελεί την πράξη x + y και επιστρέφει το αποτέλεσμα.
2. Η κύρια συνάρτηση 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.