5.1 Συναρτήσεις (Functions) στη γλώσσα C++

Οι συναρτήσεις στη γλώσσα C++ είναι μια σημαντική έννοια και αποτελούν τμήμα της δομής ενός προγράμματος. Μια συνάρτηση είναι ένα ανεξάρτητο τμήμα κώδικα που εκτελεί μια συγκεκριμένη λειτουργία και μπορεί να κληθεί από άλλα μέρη του προγράμματος.

Για να δημιουργήσουμε μια συνάρτηση στη γλώσσα C++, χρησιμοποιούμε τη δήλωση της συνάρτησης, τον τύπο επιστροφής (αν υπάρχει), το όνομα της συνάρτησης και τις παραμέτρους της. Η συνάρτηση μπορεί να περιέχει κώδικα για την εκτέλεση της συγκεκριμένης λειτουργίας.

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

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

Οι συναρτήσεις μπορούν να χρησιμοποιηθούν για την οργάνωση του κώδικα σε λογικές μονάδες, την επαναχρησιμοποίηση κώδικα, την αφαίρεση πολυπλοκότητας και την υποστήριξη της αντικειμενοστραφούς προγραμματισμού. Επιπλέον, η γλώσσα C++ παρέχει δυνατότητες όπως οι κατασκευαστές (constructors) και οι καταστροφείς (destructors) που σχετίζονται με τις συναρτήσεις και την δυνατότητα παραμετροποίησης των συναρτήσεων με βάση τον τύπο των παραμέτρων (function overloading).

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

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

#include <iostream>

// Δήλωση της συνάρτησης με τον τύπο επιστροφής και τις παραμέτρους της
int add(int a, int b) {
    int result = a + b;
    return result; // Επιστροφή του αποτελέσματος
}

int main() {
    int num1 = 5;
    int num2 = 3;

    // Κλήση της συνάρτησης add() και αποθήκευση του αποτελέσματος σε μια μεταβλητή
    int sum = add(num1, num2);

    std::cout << "The sum is: " << sum << std::endl;

    return 0;
}

Στο παραπάνω παράδειγμα, η συνάρτηση add() δηλώνεται πριν από την main() με τον τύπο επιστροφής int και τις παραμέτρους int a και int b. Ο κώδικας μέσα στη συνάρτηση προσθέτει τους δύο αριθμούς a και b και αποθηκεύει το αποτέλεσμα στη μεταβλητή result, η οποία επιστρέφεται με τη χρήση της εντολής return result;.

Στη συνέχεια, στην main(), δημιουργούνται δύο μεταβλητές num1 και num2 με τιμές 5 και 3 αντίστοιχα. Η συνάρτηση add() καλείται με τις παραμέτρους num1 και num2, και το αποτέλεσμα αποθηκεύεται στη μεταβλητή sum. Τέλος, με τη χρήση του αντικειμένου std::cout, εκτυπώνεται το αποτέλεσμα στην οθόνη.

Όταν το πρόγραμμα εκτελεστεί, θα εμφανιστεί η φράση “The sum is: 8” στην οθόνη, καθώς το αποτέλεσμα της πρόσθεσης 5 + 3 είναι 8.

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

Παρακάτω είναι ένα παράδειγμα μιας συνάρτησης στη C++:

#include <iostream>

// Δήλωση συνάρτησης με την ονομασία addNumbers
int addNumbers(int x, int y) {
  int sum = x + y;
  return sum;
}

int main() {
  int num1 = 5;
  int num2 = 7;

  // Κλήση της συνάρτησης addNumbers και αποθήκευση του αποτελέσματος στη μεταβλητή sum
  int sum = addNumbers(num1, num2);

  // Εκτύπωση του αποτελέσματος στην οθόνη
  std::cout << "The sum of " << num1 << " and " << num2 << " is: " << sum << std::endl;

  return 0;
}

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

Στη συνέχεια, η συνάρτηση main ξεκινάει την εκτέλεσή της. Δηλώνονται δύο μεταβλητές num1 και num2 με αρχικές τιμές 5 και 7 αντίστοιχα. Στη συνέχεια, γίνεται κλήση της συνάρτησης addNumbers με τις μεταβλητές num1 και num2 ως ορίσματα, και το αποτέλεσμα αποθηκεύεται στη μεταβλητή sum.

Τέλος, με τη χρήση της εντολής std::cout, το αποτέλεσμα εκτυπώνεται στην οθόνη με τη μορφή ενός μηνύματος που δείχνει το άθροισμα των αριθμών num1 και num2.

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

είναι “The sum of 5 and 7 is: 12”.

Μπορείτε να δημιουργήσετε τις δικές σας συναρτήσεις στη γλώσσα C++ για να εκτελέσετε συγκεκριμένες ενέργειες. Μια συνάρτηση μπορεί να δέχεται παραμέτρους ως είσοδο στον κώδικα, μπορεί να επιστρέφει μια τιμή ως αποτέλεσμα ή μπορεί ακόμα και να μην επιστρέφει τίποτα (void).

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

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

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

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

Η C++ παρέχει ορισμένες προεπιλεγμένες συναρτήσεις, όπως η main(), η οποία χρησιμοποιείται για να εκτελεί κώδικα. Ωστόσο, μπορείτε επίσης να δημιουργήσετε τις δικές σας συναρτήσεις για να εκτελέσετε συγκεκριμένες ενέργειες.

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

[adinserter block=”2″]

Σύνταξη

return_type function_name(parameters) {
   // κώδικας συνάρτησης
}

Ο όρος “return_type” αναφέρεται στον τύπο δεδομένων που επιστρέφεται από μια συνάρτηση. Αν η συνάρτηση δεν επιστρέφει κάποια τιμή, τότε χρησιμοποιείται ο τύπος δεδομένων “void”. Ο όρος “function_name” αναφέρεται στο όνομα της συνάρτησης, ενώ ο όρος “parameters” αναφέρεται στις παραμέτρους που περνάνε στη συνάρτηση.

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

int addNumbers(int x, int y) {
   int sum = x + y;
   return sum;
}

Στο παραπάνω παράδειγμα, η συνάρτηση ορίζεται ως int, καθώς επιστρέφει έναν ακέραιο αριθμό. Το όνομα της συνάρτησης είναι addNumbers και λαμβάνει δύο παραμέτρους, x και y. Η συνάρτηση προσθέτει τις δύο παραμέτρους μαζί και επιστρέφει το άθροισμα.

Για να καλέσετε τη συνάρτηση, πρέπει απλώς να αναφέρετε το όνομά της και να περάσετε τις απαιτούμενες παραμέτρους. Παρακάτω είναι ένα παράδειγμα που καλεί τη συνάρτηση addNumbers και εμφανίζει το αποτέλεσμα:

#include <iostream>

// Συνάρτηση που προσθέτει δύο αριθμούς
int addNumbers(int x, int y) {
   int sum = x + y;
   return sum;
}

int main() {
   int num1 = 5;
   int num2 = 7;
   int result = addNumbers(num1, num2); // Κλήση της συνάρτησης addNumbers

   // Εκτύπωση του αποτελέσματος
   std::cout << "The sum of " << num1 << " and " << num2 << " is " << result << std::endl;

   return 0;
}

Ο παραπάνω κώδικας συνδυάζει διάφορα στοιχεία για να υπολογίσει και να εκτυπώσει το άθροισμα δύο αριθμών. Ακολουθούν τα βήματα που περιλαμβάνονται:

  1. Ορίζεται η συνάρτηση addNumbers, η οποία δέχεται δύο ακεραίους αριθμούς (x και y) ως παραμέτρους. Η συνάρτηση πραγματοποιεί την πρόσθεση των δύο αριθμών και επιστρέφει το άθροισμα.
  2. Στη συνάρτηση main:
  • Δημιουργούνται δύο μεταβλητές num1 και num2 και τους ανατίθενται οι τιμές 5 και 7 αντίστοιχα.
  • Εκτελείται η κλήση της συνάρτησης addNumbers με τις μεταβλητές num1 και num2 ως ορίσματα. Το αποτέλεσμα αποθηκεύεται στη μεταβλητή result.
  • Εκτυπώνεται το αποτέλεσμα με χρήση της συνάρτησης std::cout. Το αποτέλεσμα περιλαμβάνει το άθροισμα των αριθμών num1 και num2.

Ο κώδικας ουσιαστικά υπολογίζει το άθροισμα των δύο αριθμών 5 και 7 και το εκτυπώνει στην οθόνη. Έτσι, το αποτέλεσμα που θα εμφανιστεί είναι “The sum of 5 and 7 is 12”.

Κλήση μιας συνάρτησης

Για να καλέσετε μια συνάρτηση στη γλώσσα C++, ακολουθήστε τα παρακάτω βήματα. Αρχικά, γράψτε το όνομα της συνάρτησης, ακολουθούμενο από δύο παρενθέσεις (). Μπορείτε να προσθέσετε και παραμέτρους μέσα στις παρενθέσεις, εάν απαιτούνται από τη συνάρτηση. Στη συνέχεια, τοποθετήστε ένα ερωτηματικό (;) στο τέλος της κλήσης της συνάρτησης.

Παράδειγμα:

functionName();

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

functionName(parameter1, parameter2);

Αυτό θα καλέσει τη συνάρτηση functionName με τις παραμέτρους parameter1 και parameter2. Το ερωτηματικό (;) στο τέλος της κλήσης της συνάρτησης είναι προαιρετικό και χρησιμοποιείται για να υποδηλώσει ένα τελεστέο που επιστρέφει τιμή.

Με αυτόν τον τρόπο, μπορείτε να καλέσετε συναρτήσεις στη γλώσσα C++ και να εκτελέσετε τον κώδικα που βρίσκεται μέσα σε αυτές.

Στο παρακάτω παράδειγμα, η συνάρτηση myFunction() χρησιμοποιείται για να εμφανίσει ένα κείμενο όταν καλείται:

#include <iostream>

// Δήλωση συνάρτησης με την ονομασία myFunction
void myFunction() {
   std::cout << "Hello from myFunction!" << std::endl;
}

int main() {
   // Κλήση της συνάρτησης myFunction
   myFunction();
   return 0;
}

Η έξοδος του παραπάνω προγράμματος είναι:

Hello from myFunction!

Στο παραπάνω παράδειγμα, η συνάρτηση myFunction δηλώνεται ως void, καθώς δεν επιστρέφει κάποια τιμή. Το όνομα της συνάρτησης είναι myFunction και δεν λαμβάνει παραμέτρους. Η συνάρτηση απλώς εμφανίζει ένα κείμενο στην οθόνη. Στη συνέχεια, η συνάρτηση καλείται στο main() και εμφανίζει το αποτέλεσμα.

[adinserter block=”3″]

Μια συνάρτηση μπορεί να κληθεί πολλές φορές:

Μια συνάρτηση μπορεί να κληθεί πολλές φορές από διαφορετικά σημεία του κώδικα. Στο παρακάτω παράδειγμα, η συνάρτηση myFunction() καλείται δύο φορές από το main():

#include <iostream>

// Δήλωση συνάρτησης με την ονομασία myFunction
void myFunction() {
   std::cout << "Hello from myFunction!" << std::endl;
}

int main() {
   // Κλήση της συνάρτησης myFunction
   myFunction();

   // Κλήση της συνάρτησης myFunction ξανά
   myFunction();

   return 0;
}

Ο παραπάνω κώδικας στη γλώσσα C περιλαμβάνει μια συνάρτηση με την ονομασία myFunction και τη συνάρτηση main.

Η συνάρτηση myFunction είναι μια απλή συνάρτηση που δεν δέχεται παραμέτρους και δεν επιστρέφει τίποτα (void). Εντός της συνάρτησης, χρησιμοποιείται το αντικείμενο std::cout για να εκτυπωθεί το μήνυμα “Hello from myFunction!” στην οθόνη, ακολουθούμενο από έναν χαρακτήρα νέας γραμμής (std::endl).

Η συνάρτηση main είναι η κύρια συνάρτηση του προγράμματος. Ξεκινάει με την υπογραφή int main() και επιστρέφει έναν ακέραιο αριθμό (int). Εντός της συνάρτησης, καλείται η συνάρτηση myFunction δύο φορές χρησιμοποιώντας τη γραμμή κώδικας myFunction();. Αυτό έχει ως αποτέλεσμα να εκτελεστεί ο κώδικας της myFunction και να εμφανιστεί το μήνυμα “Hello from myFunction!” δύο φορές στην οθόνη. Τέλος, η συνάρτηση main επιστρέφει την τιμή 0 (return 0;), υποδηλώνοντας ότι το πρόγραμμα ολοκληρώθηκε με επιτυχία.

Ο κώδικας αυτός εκτυπώνει το μήνυμα “Hello from myFunction!” δύο φορές στην οθόνη κατά την εκτέλεσή του.

Η έξοδος του παραπάνω προγράμματος είναι:

Hello from myFunction!
Hello from myFunction!

Μια συνάρτηση στη γλώσσα C++ αποτελείται από δύο στοιχεία:

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

Στο παρακάτω παράδειγμα, η συνάρτηση addNumbers() δηλώνεται στην αρχή του κώδικα, ακολουθούμενη από το σώμα της συνάρτησης:

#include <iostream>

// Δήλωση συνάρτησης
int addNumbers(int x, int y);

int main() {
    int num1 = 5;
    int num2 = 7;
    int result = addNumbers(num1, num2);
    std::cout << "The sum of " << num1 << " and " << num2 << " is " << result << std::endl;
    return 0;
}

// Ορισμός συνάρτησης
int addNumbers(int x, int y) {
    int sum = x + y;
    return sum;
}

Ο παραπάνω κώδικας στη γλώσσα C πραγματοποιεί την πρόσθεση δύο ακεραίων αριθμών και εκτυπώνει το αποτέλεσμα.

Συγκεκριμένα, ο κώδικας περιλαμβάνει τη συνάρτηση addNumbers, η οποία δέχεται δύο ακεραίους αριθμούς (x και y) και επιστρέφει το άθροισμά τους. Η συνάρτηση αυτή δηλώνεται προηγουμένως με τη γραμμή int addNumbers(int x, int y); και ορίζεται στη συνέχεια πιο κάτω με τον κώδικα:

int addNumbers(int x, int y) {
   int sum = x + y;
   return sum;
}

Στη συνέχεια, η συνάρτηση addNumbers καλείται από τη συνάρτηση main. Στην main, οι μεταβλητές num1 και num2 αρχικοποιούνται με τις τιμές 5 και 7 αντίστοιχα. Έπειτα, η μεταβλητή result λαμβάνει το αποτέλεσμα της κλήσης της συνάρτησης addNumbers(num1, num2), δηλαδή το άθροισμα των num1 και num2.

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

std::cout << "The sum of " << num1 << " and " << num2 << " is " << result << std::endl;

Η έξοδος του κώδικα θα είναι: “The sum of 5 and 7 is 12”, καθώς το άθροισμα των 5 και 7 είναι 12.

[adinserter block=”4″]

Σημείωση: Εάν μια χρήστης καθορισμένη συνάρτηση, όπως η myFunction(), δηλωθεί μετά τη συνάρτηση main(), θα προκληθεί σφάλμα:

Στο C++, η σειρά της δήλωσης των συναρτήσεων έχει σημασία. Οι συναρτήσεις πρέπει να δηλωθούν (ή να έχουν πρότυπο δήλωση) πριν από την κλήση τους.

Στο παρακάτω παράδειγμα, η συνάρτηση myFunction() δηλώνεται μετά τη συνάρτηση main(), και ως εκ τούτου, θα προκληθεί σφάλμα:

#include <iostream>

int main() {
   myFunction(); // Σφάλμα: η συνάρτηση myFunction δεν έχει δηλωθεί
   return 0;
}

void myFunction() {
   std::cout << "Hello from myFunction!" << std::endl;
}

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

Για να αποφευχθεί το σφάλμα, η δήλωση της συνάρτησης myFunction() πρέπει να προηγείται της συνάρτησης main().

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

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

Στο παρακάτω παράδειγμα, η συνάρτηση addNumbers() δηλώνεται στην αρχή του κώδικα, και ο ορισμός της συνάρτησης ακολουθεί κάτω από τη συνάρτηση main():

#include <iostream>

// Δήλωση συνάρτησης
int addNumbers(int x, int y);

int main() {
   int num1 = 5;
   int num2 = 7;
   int result = addNumbers(num1, num2);
   std::cout << "The sum of " << num1 << " and " << num2 << " is " << result << std::endl;
   return 0;
}

// Ορισμός συνάρτησης
int addNumbers(int x, int y) {
   int sum = x + y;
   return sum;
}

Η δήλωση της συνάρτησης παραμένει η ίδια όπως και πριν. Ακολουθεί η συνάρτηση main(), όπου η συνάρτηση addNumbers() καλείται χρησιμοποιώντας τις παραμέτρους num1 και num2. Ο ορισμός της συνάρτησης addNumbers() ακολουθεί κάτω από τη συνάρτηση main().

26 Ιουνίου, 2023
top
error: Content is protected !!
Μετάβαση σε γραμμή εργαλείων