Η C++ εισάγει μια βασική αλλαγή στη φιλοσοφία διαχείρισης των μετατροπών τύπων δεδομένων σε σχέση με τη γλώσσα C. Οι τελεστές casting αποτελούν χαρακτηριστικό παράδειγμα αυτής της αλλαγής. Στη C το “παραδοσιακό” cast — με τη γνώριμη σύνταξη (type)value — λειτουργεί ως ένας μηχανισμός που εξαναγκάζει τη μετατροπή δεδομένων χωρίς ουσιαστικούς περιορισμούς. Αντίθετα, η C++ εισάγει μια οικογένεια τεσσάρων εξειδικευμένων τελεστών (static_cast, dynamic_cast, const_cast, και reinterpret_cast). Οι τελεστές αυτοί βελτιώνουν την αναγνωσιμότητα και επιπλέον (α) επιβάλλουν αυστηρότερο έλεγχο από τον compiler, (β) υποχρεώνουν στον προγραμματιστή να δηλώσει με σαφήνεια την πρόθεσή του, (γ) επιτρέπουν ασφαλείς μετατροπές κατά τη μεταγλώττιση ή (δ) διενεργούν ελέγχους πολυμορφισμού κατά την εκτέλεση του προγράμματος. Παρακάτω αναλύσουμε κάθε ένα ξεχωριστά

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

Παρακάτω δίνουμε ένα παράδειγμα μετατροπής τύπου από int σε double για τον υπολογισμό μέσου όρου. Η μετατροπή από ένα βασικό τύπο σε ένα άλλο μπορεί να γίνει με static_cast εφόσον η μετατροπή είναι εφικτή.

static_cast_int2double.cpp

#include <iostream>
 
int main() {
    int total_points = 45;
    int total_items = 10;
 
    // Πρόβλημα: Η διαίρεση ακεραίων θα δώσει 4 (χάνεται το .5)
    double average_bad = total_points / total_items; 
 
    // Λύση: Μετατρέπουμε τον έναν ακέραιο σε double πριν τη διαίρεση
    double average_good = static_cast<double>(total_points) / total_items;
 
    std::cout << "Bad Average: " << average_bad << std::endl;  // Εκτυπώνει 4
    std::cout << "Good Average: " << average_good << std::endl; // Εκτυπώνει 4.5
 
    // Μετατροπή από double σε int (explicit truncation)
    double pi = 3.14159;
    int truncated_pi = static_cast<int>(pi); 
 
    std::cout << "Truncated Pi: " << truncated_pi << std::endl; // Εκτυπώνει 3
 
    return 0;
}

Το static_cast επιτρέπει τη μετακίνηση στην ιεραρχία των κλάσεων, αλλά χωρίς έλεγχο ασφαλείας. Ο compiler υπακούει στην εντολή του προγραμματιστή και επιβάλλει την αλλαγή του τύπου κατά τη μεταγλώττιση. Παρακάτω δίνουμε δύο μετατροπές τύπου μεταξύ κλάσεων που διατηρούν σχέση κληρονομικότητας. Στην πρώτη περίπτωση, η μετατροπή από τη γονική στην απόγονο κλάση επιτρέπει στο πρόγραμμα να λειτουργεί απροβλημάτιστα. Στην δεύτερη περίπτωση η μετατροπή είναι λανθασμένη και το πρόγραμμα τερματίζει αναπάντεχα με SEGMENTATION FAULT.

static_cast_derived.cpp

#include <iostream>
#include <vector>
 
class Base {
public:
    virtual void info() { 
        std::cout << "Είμαι η Base" << std::endl; 
    }
    virtual ~Base() {} // Πάντα virtual destructor στη βασική κλάση
};
 
class Derived : public Base {
private:
    int array[10000];
public:
    void info() override { 
        std::cout << "Είμαι η Derived" << std::endl; 
    }
    void special_function() {
        array[9999] = 1;
        std::cout << "Ειδική λειτουργία της Derived!" << std::endl; 
    }
};
 
int main() {
    Derived* d = new Derived();
 
    // 1. Upcasting: Από Derived* σε Base* (Πάντα ασφαλές)
    // Γίνεται και αυτόματα, το static_cast το κάνει explicit.
    Base* b = static_cast<Base*>(d);
    b->info(); 
 
    // 2. Downcasting: Από Base* σε Derived*
    // Εδώ το static_cast εμπιστεύεται τον προγραμματιστή.
    // Αν το 'b' όντως δείχνει σε Derived, όλα καλά. Αν όχι, θα υπήρχε πρόβλημα
    Derived* d2 = static_cast<Derived*>(b);
    d2->special_function();
 
    Base* real_base = new Base();
    // Ο compiler επιτρέψει τη μετατροπη Base* -> Derived*. 
    // H d3 θα δείχνει σε αντικείμεν τύπου Base
    Derived* d3 = static_cast<Derived*>(real_base); 
 
    d3->special_function(); // ΚΙΝΔΥΝΟΣ: Runtime Crash
 
    delete d;
    delete real_base;
    return 0;
}

Γιατί να προτιμήσεις το static_cast αντί για το C-style cast (Derived*)b;

1. Αποτροπή “τρελών” μετατροπών: Αν προσπαθήσεις να κάνεις static_cast<Derived*>(some_int_pointer), ο compiler θα σου βγάλει σφάλμα. Το C-style cast θα το άφηνε να περάσει, οδηγώντας σε καταστροφικά bugs.
2. Δήλωση πρόθεσης: Όταν κάποιος διαβάζει static_cast, καταλαβαίνει ότι υπάρχει μια λογική σχέση μεταξύ των τύπων. Ο προγραμματιστής αναλαμβάνει την ευθύνη της σωστής μετατροπής.

 double d = static_cast<double>(5); 

 
Derived derived(100);
Base& b = static_cast<Derived&>(derived); 

Το dynamic_cast είναι ο τύπος casting που εφαρμόζεται στον πολυμορφισμό. Το χρησιμοποιούμε όταν έχουμε έναν δείκτη προς μια βασική κλάση (Base*) και εξετάζουμε αν το αντικείμενο στο οποίο δείχνει είναι μια συγκεκριμένη παράγωγη κλάση (Derived*).

Ακολουθεί ένα σενάριο από ένα σύστημα πληρωμών, όπου έχουμε διαφορετικούς τύπους τραπεζικών λογαριασμών. Έχουμε μια βασική κλάση Account και δύο παράγωγες: SavingsAccount (που έχει επιτόκιο) και CheckingAccount (επαγγελματικός λογαριασμός όψεως, χωρίς επιτόκιο). Θέλουμε να γράψουμε μια συνάρτηση που δέχεται οποιονδήποτε λογαριασμό, αλλά εφαρμόζει τόκο μόνο αν ο λογαριασμός είναι αποταμιευτικός.

account_polymorphism.cpp

#include <iostream>
#include <vector>
 
// Η Base κλάση πρέπει να είναι πολυμορφική (να έχει τουλάχιστον μία virtual function)
class Account {
public:
    virtual void withdraw(double amount) {
        std::cout << "Ανάληψη " << amount << " από τον βασικό λογαριασμό." << std::endl;
    }
    virtual ~Account() {} // Απαραίτητος ΠΑΝΤΑ ο virtual destructor
};
 
class SavingsAccount : public Account {
public:
    void applyInterest() {
        std::cout << "Εφαρμογή επιτοκίου στον αποταμιευτικό λογαριασμό!" << std::endl;
    }
};
 
class CheckingAccount : public Account {
public:
    void printStatement() {
        std::cout << "Εκτύπωση κίνησης λογαριασμού όψεως." << std::endl;
    }
};
 
void processAccount(Account* acc) {
    // Θέλουμε να καλέσουμε την applyInterest(), αλλά αυτή υπάρχει ΜΟΝΟ στην SavingsAccount.
    // Χρησιμοποιούμε dynamic_cast για να ελέγξουμε με ασφάλεια.
 
    SavingsAccount* savings = dynamic_cast<SavingsAccount*>(acc);
 
    if (savings != nullptr) {
        // Η μετατροπή πέτυχε! Το acc δείχνει όντως σε SavingsAccount.
        savings->applyInterest();
    } else {
        // Η μετατροπή απέτυχε. Το acc είναι κάτι άλλο (π.χ. CheckingAccount).
        std::cout << "Αποτυχία cast: Αυτός ο λογαριασμός είναι επαγγελματικός." << std::endl;
    }
}
 
int main() {
    // Δημιουργούμε ένα vector από διαφορετικούς λογαριασμούς (Base pointers)
    std::vector<Account*> bank_vault;
    bank_vault.push_back(new SavingsAccount());
    bank_vault.push_back(new CheckingAccount());
 
    for (Account* acc : bank_vault) {
        processAccount(acc);
        delete acc;
    }
 
    return 0;
}

• Runtime Check: Το dynamic_cast χρησιμοποιεί μια πληροφορία που ονομάζεται RTTI (Run-Time Type Information). Όταν καλείται η processAccount, ο compiler δεν ξέρει τι περιέχει το acc. Η απόφαση παίρνεται την ώρα που τρέχει το πρόγραμμα.
• Ασφάλεια (Safety): Αν χρησιμοποιούσαμε static_cast και το αντικείμενο ήταν CheckingAccount, ο pointer savings θα ήταν έγκυρος (αλλά θα έδειχνε σε λάθος δεδομένα). Η κλήση savings→applyInterest() θα οδηγούσε σε crash. Το dynamic_cast μας επιστρέφει nullptr και μας σώζει.
• Πολυμορφισμός: Πρόσεξε ότι η Account έχει virtual συναρτήσεις. Χωρίς αυτές, το dynamic_cast θα έβγαζε σφάλμα στο compilation, γιατί δεν θα υπήρχε πίνακας vtable για να ελέγξει τον τύπο.