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

#include <iostream>
using namespace std;
 
int addition (int a, int b) { return a+b; }
 
int main () {
  int x=5;
  x = 5 + addition(8,2);
  cout << "x: " << x << endl;
}

Γνωρίζετε από τη C ότι η συνάρτηση main από την οποία εκκινεί το πρόγραμμα ορίζεται ως εξής:

int main(int argc, char *argv[]);

Σε ένα πρόγραμμα C++ η main μπορεί να δηλωθεί χωρίς να λαμβάνει κανένα όρισμα, όπως παρακάτω

int main();

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

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

power_of.cpp

#include <iostream>
using namespace std;
 
int powerOf(int base, int e=2) {
  if(e==0)
    return 1;
  int result = base;
  for(int i=1; i<e; i++) {
    result *= base;
  }
  return result;
}
 
int main() {
  int a = 2, b;
  b = powerOf(a);
  cout << "a: " << a <<", b: " << b << endl;
  b = powerOf(a, 3);
  cout << "a: " << a <<", b: " << b << endl;
  b = powerOf(a, 5);
  cout << "a: " << a <<", b: " << b << endl;
}

Κάθε φορά που καλείται μια συνάρτηση συνεπάγεται μία μικρή καθυστέρηση προκειμένου να αποθηκευτούν οι παράμετροι κλήσης της συνάρτησης στη στοίβα και να αποθηκευθεί η επιστρεφόμενη τιμή σε μία μεταβλητή. Για μικρές σε έκταση συναρτήσεις που καλούνται συχνά το συγκεκριμένο κόστος μπορεί να μην είναι αμελητέο σε σχέση με τον συνολικό χρόνο εκτέλεσης τους.

Μπορείτε να αποφύγετε την κλήση μίας συνάρτησης δηλώνοντας τη ως inline. Σε αυτή την περίπτωση δεν γίνεται καμία κλήση συνάρτησης, αλλά ο κώδικας της “καλούμενης” συνάρτησης ενσωματώνεται μέσα στον κώδικα που την καλεί. Σημειώστε ότι σε αυτή την περίπτωση θα έχετε τόσα αντίγραφα της συνάρτησης όσα και τα σημεία στον κώδικα που αυτή καλείται. Παρακάτω δίνεται το παράδειγμα της συνάρτησης add που δηλώνεται ως inline.

inline.cpp

#include <iostream>
using namespace std;
inline int add(int a, int b) { return a+b;}
int main() {
  int sum = 0;
  for(int i=1; i<=100; i++) {
    sum = add(sum,i);
    cout << i << "  " << sum << endl;
  }
  cout << "sum: " << sum << endl;
}

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

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

powerOf2.cpp

#include <iostream>
using namespace std;
 
int powerOf2(int x) {
  x = x*x;
  return x;
}
 
int powerOf2Ref(int &x) {
  x = x*x;
  return x;
}
 
int powerOf2Ptr(int *x) {
  *x = (*x)*(*x);
  return *x;
}
 
int main() {
  int a = 5, b;
  b = powerOf2(a);
  cout << "a: " << a <<", b: " << b << endl;
  a = 5;
  b = powerOf2Ref(a);
  cout << "a: " << a <<", b: " << b << endl;
  a = 5;
  b = powerOf2Ptr(&a);
  cout << "a: " << a <<", b: " << b << endl;  
}

Το αποτέλεσμα της εκτέλεσης του παραπάνω προγράμματος έχει ως εξής:

a: 5, b: 25
a: 25, b: 25
a: 25, b: 25

Παρατηρήστε ότι μετά την έξοδο από τις μεθόδους powerOf2Ref και powerOf2Ptr η μεταβλητή a έχει αλλάξει τιμή κάτι που δεν ισχύει μετά την έξοδο από την powerOf2.

Δείτε τη σχετική ενότητα.

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

powerOf2.cpp

#include <iostream>
using namespace std;
 
int powerOf2(int &x) {
  x = x*x;
  return x;
}
 
int powerOf2(int *x) {
  *x = (*x)*(*x);
  return *x;
}
 
double powerOf2(double *x) {
  *x = (*x)*(*x);
  return *x;
}
 
int main() {
  int a = 5, b;
  double d = 5.0, e;
  b = powerOf2(a);
  cout << "a: " << a <<", b: " << b << endl;
  a = 5;
  b = powerOf2(&a);
  cout << "a: " << a <<", b: " << b << endl;
  e = powerOf2(&d);
  cout << "d: " << d <<", e: " << e << endl;  
}

Υπερφορτωμένες συναρτήσεις συχνά έχουν τον ίδιο αριθμό και τύπο ορισμάτων, όπως παρακάτω

int sum (int a, int b) { return a+b; }
double sum (double a, double b) { return a+b; }

Παρατηρούμε ότι οι παραπάνω συναρτήσεις έχουν τον ίδιο αριθμό παραμέτρων και το ίδιο σώμα, αλλά διαφορετικούς τύπους παραμέτρων. Σε αυτές τις περιπτώσεις η C++ δίνει τη δυνατότητα ορισμού template συναρτήσεων, δηλαδή συναρτήσεων που λαμβάνουν ως επιπλέον χαρακτηριστικό τον τύπο δεδομένων στον οποίο θα εφαρμοστούν. Παράδειγμα τέτοιας templated συνάρτησης δίνεται παρακάτω (μην σας μπερδεύει η δεσμευμένη λέξη class):

template <class T>
T sum (T a, T b) {
  return a+b;
}

η δεσμευμένη έκφραση template <class T>) μπορεί να αντικατασταθεί από την επίσης δεσμευμένη έκφραση template <typename T>. Προκειμένου να κάνετε χρήση μιας template συνάρτησης θα πρέπει κατά την κλήση να ορίσετε και τον τύπο των δεδομένων για τον οποίο καλείται η συγκεκριμένη συνάρτηση ως εξής:

int s = sum<int>(5,10);

Δείτε το παραπάνω παράδειγμα που περιέχει επιμέρους κλήσεις για τη μέθοδο sum.

sumUsage.cpp

#include <iostream>
using namespace std;
 
template <typename T>
T sum (T a, T b) {
  return a+b;
}
 
int main() {
  cout << "10 + 20 = " << sum<int>(10,20) << endl;             // sum<int>
  cout << "10.5 + 20.5 = " << sum<double>(10.5,20.5) << endl;  // sum<double>
  cout << "1.5 + 2 = " << sum<>(1.5,2.0) << endl;              // compiler deducts sum<double>
}