Η 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;
}

Συνοπτικός Πίνακας

Είναι ο μόνος τελεστής που μπορεί να προσθέσει ή να αφαιρέσει το const (ή το volatile) από μια μεταβλητή.

• Γιατί να το κάνεις: Συνήθως χρησιμοποιείται όταν έχεις να κάνεις με παλιές βιβλιοθήκες (Legacy C code) που δέχονται char* ενώ ξέρεις ότι δεν πρόκειται να τροποποιήσουν το περιεχόμενο, αλλά εσύ έχεις ένα const char*.
• Ο Κίνδυνος: Αν αφαιρέσεις το const από μια μεταβλητή που ορίστηκε εξ αρχής ως const και προσπαθήσεις να την αλλάξεις, το αποτέλεσμα είναι Undefined Behavior (μπορεί να “σκάσει” το πρόγραμμα ή να μην αλλάξει η τιμή ποτέ).

cost_cast.cpp

void legacy_function(char* str) { 
   /* ... */ 
}
 
const char* my_text = "Hello";
// legacy_function(my_text); // ΣΦΑΛΜΑ
legacy_function(const_cast<char*>(my_text)); // Επιτρέπεται

Αυτός είναι ο πιο ισχυρός και επικίνδυνος τελεστής. Λέει στον compiler: “Κάνε αυτή τη μετατροπή, ακόμα και αν δεν βγάζει νόημα”.

Τι κάνει: Μετατρέπει οποιονδήποτε δείκτη σε οποιονδήποτε άλλον τύπο δείκτη, ή ακόμα και δείκτη σε ακέραιο και το αντίστροφο. Προσοχή: Δεν ελέγχει τίποτα. Αν μετατρέψεις έναν int* σε Dog* και καλέσεις μια μέθοδο, ο compiler θα το κάνει και απλώς θα προσπαθήσει να διαβάσει τη μνήμη του integer σαν να ήταν αντικείμενο κλάσης.

reinterpret_cast.cpp

long address = 0x7FFF1234;
// Ερμήνευσε αυτόν τον αριθμό ως διεύθυνση μνήμης ενός ακεραίου
int* p = reinterpret_cast<int*>(address);

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