====== C++ casting ======

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

===== static_cast<> =====

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

==== Παράδειγμα 1ο: Αριθμητικές Μετατροπές και Ακρίβεια ====

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

<code cpp 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;
}
</code>

==== Παράδειγμα 2ο: Κληρονομικότητα (Upcasting & Downcasting) ====

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

<code cpp 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;
}
</code>

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

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

<WRAP tip>
Χρησιμοποιήστε **static_cast** μόνο όταν 
  * η μετατροπή τύπου είναι απόλυτα λογική, για παράδειγμα 
<code> double d = static_cast<double>(5); </code> 
  * είναι σίγουρο ότι το casting δεν θα αποτύχει σε καμία περίπτωση. Για παράδειγμα,
<code> 
Derived derived(100);
Base& b = static_cast<Derived&>(derived); 
</code>

Το **static_cast** εφαρμόζεται σχεδόν στα πάντα:

  * **Κανονικούς Τύπους:** Μπορείς να μετατρέψεις βασικούς τύπους μεταξύ τους (π.χ. double σε int, float σε char).
  * **Pointers:** Μετατροπή μεταξύ δεικτών σε μια ιεραρχία κλάσεων (Base* σε Derived* και αντίστροφα).
  * **References**: Λειτουργεί ακριβώς όπως και με τους pointers για αναφορές σε κλάσεις.
  * **Enums:** Μετατροπή enums σε integers και αντίστροφα.

**Σημαντικό:** Στο **static_cast**, αν η μετατροπή αναφορών (references) αποτύχει λογικά (π.χ. το αντικείμενο δεν είναι αυτό που νομίζεις), το πρόγραμμα θα συνεχίσει να τρέχει με λάθος δεδομένα (undefined behavior), γιατί δεν υπάρχει έλεγχος στο runtime. 
</WRAP>

===== dynamic_cast<> =====

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

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

<code cpp 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;
}
</code>

<WRAP tip 80% center round>

  * **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 θα έβγαζε σφάλμα στη μεταγλώττιση, γιατί δεν θα υπήρχε πίνακας vtable για να ελέγξει τον τύπο.
  * **Δε λειτουργεί για κανονικούς τύπους:** Δεν μπορείς να κάνεις dynamic_cast<int>(my_double). Θα πάρεις σφάλμα κατά τη μεταγλώττιση. Το **dynamic_cast** απαιτεί ο τύπος προορισμού να είναι δείκτης ή αναφορά σε τύπο κλάσης.

</WRAP>

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

^  Τύπος  ^  static_cast  ^  dynamic_cast  ^
^ Βασικοί Τύποι (int, double, κλπ)  | Ναι  | Όχι  |
^ Pointers (Base* -> Derived*)  | Ναι (χωρίς check)  | Ναι (επιστρέφει nullptr σε αποτυχία)  |
^ References (Base& -> Derived&)  | Ναι (χωρίς check)  | Ναι (πετάει std::bad_cast σε αποτυχία)  |
^ Enums  | Ναι  | Όχι  |  


===== const_cast<> =====

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

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

<code cpp cost_cast.cpp>
void legacy_function(char* str) { 
   /* ... */ 
}

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

====== reinterpret_cast<> ======

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

**Τι κάνει:** Μετατρέπει οποιονδήποτε δείκτη σε οποιονδήποτε άλλον τύπο δείκτη, ή ακόμα και δείκτη σε ακέραιο και το αντίστροφο.

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

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

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