Αντικειμενοστρεφής προγραμματισμός στη C: Διαφορά μεταξύ των αναθεωρήσεων

 

Αν και η [[γλώσσα προγραμματισμού]] [[C (γλώσσα προγραμματισμού)|C]] είναι πολύ ισχυρή, με αυξημένη δυνατότητα ελέγχου του [[Υλικό υπολογιστών|υλικού]] και των παραμέτρων αυτού, δεν είναι αντικειμενοστρεφής. Εντούτοις, και με την χρήση των δυνατοτήτων της γλώσσας, μπορεί να προσομοιωθεί η λειτουργικότητα που προσφέρουν οι αντικειμενοστρεφείς γλώσσες και ο αντικειμενοστρεφής προγραμματισμός.

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

 

 

 

Στην [[C++]], οι δύο αυτές μέθοδοι είναι κάποιες ειδικές μέθοδοι που καλούνται όταν ένα αντικείμενο δημιουργείται ή καταστρέφεται αντιστοίχως. Ο χειριστής new κατανέμει την μνήμη για την κλάση και μετά καλεί τον κατασκευαστή (Constructor) της κλάσης αυτής. Αντίστοιχα, ο χειριστής delete καλεί πρώτα τον Destructor της κλάσης και μετά αποδεσμεύει την μνήμη που χρησιμοποιούσε η κλάση.

 

Στην C πρέπει να δημιουργήσουμε δύο μεθόδους για κάθε κλάση. Μία για τον Constructor και μία για τον Destructor. Το όνομα της μεθόδου του Constructor θα είναι το όνομα της κλάσης μαζί με το _Ctor και το όνομα της μεθόδου του Destructor θα είναι το όνομα της κλάσης μαζί με το _Dtor (π.χ. για την κλάση X, θα έχουμε: X_Ctor και X_Dtor).

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

 

 

Στην C, για να υλοποιήσουμε τον δείκτη this, δηλώνουμε μία μεταβλητή global integer που ονομάζουμε ECX. Πριν καλέσουμε οποιαδήποτε μέθοδο, η μεταβλητή ECX θα τεθεί ώστε να δείχνει στην διεύθυνση μνήμης που χρησιμοποιεί η δομή δεδομένων μας. Όλες οι μέθοδοι χρησιμοποιούν, έτσι, την μεταβλητή ECX ώστε να αποκτήσουν πρόσβαση στα μέλη της δομής.

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

 

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

 

 

Ο εικονικός πίνακας για την κλάση Y θα περιέχει τις διευθύνσεις του Destructor και τις διευθύνσεις των εικονικών μεθόδων που κληρονομούνται από την κλάση X. Στην περίπτωση της μεθόδου Y_One που υπερκαλύπτει την X_One, η διεύθυνση της δεύτερης θα αντικατασταθεί από την διεύθυνση της πρώτης στον πίνακα.

 

 

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

Ορίζουμε λοιπόν την κλάση "Person" στη γλώσσα C++, η οποία αποτελείται από τα πεδία pFirstName, pLastName; καθώς και κάποιες μεθόδους οι οποίες επιδρούν στα δεδομένα αυτά.

class Person

{

void writeToFile(const char* pFileName);

};

Για να αναπαραστήσουμε την κλάση "Person" στη γλώσσα C θα χρησιμοποιήσουμε δομές, και συναρτήσεις που επιδρούν πάνω τους. Για παράδειγμα η κλάση "Person" θα μπορούσε να γραφεί στη γλώσσα C ως εξής<ref>Object Oriented Programming with ANSI-C</ref>:

typedef struct _Person Person;

 

void Person_DisplayInfo(Person* const pPersonObj);

void Person_WriteToFile(Person* const pPersonObj, const char* pFileName);

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

 

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

struct base

{

struct base *base_ptr = (struct base *)&d; // upcast

struct derived derived_ptr = (struct derived *)base_ptr; // downcast

 

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

 

Θέλουμε να κατασκευάσουμε την κλάση "Point" με τέτοιο τρόπο ώστε η κλάση "Circle" να μπορεί να κληρονομήσει απ ο αυτή. Κάθε κλάση στον αντικειμενοστρεφή προγραμματισμό έχει κάποια κοινά χαρακτηριστικά με τις υπόλοιπες κλάσεις (κάθε κλάση έχει ένα κατασκευαστή), για να διατηρήσουμε μία συνοχή με τις αντικειμενοστρεφείς γλώσσες θα πρέπει να παρέχουμε μία παρόμοια διεπαφή. Καθώς το να παρέχουμε ένα γενικό τρόπο κατασκευής και δημιουργίας αντικειμένων προσθέτει αρκετά προβλήματα, κάνει τον κώδικα επιρρεπή σε λάθη και περιορίζει τις δυνατότητες θα πρέπει το κάθε αντικείμενο να γνωρίζει τη πόρους χρειάζεται καθώς και πώς να τους ελευθερώσει. Έτσι μπορούμε να χρησιμοποιούμε τη γενική συνάρτηση "new()" η οποία θα αναλαμβάνει να δημιουργεί τα αντικείμενα και η συνάρτηση "delete()" η οποία θα καταστρέφει το αντικείμενο.

struct Class {

size_t size;

void * (* dtor) (void * self);

};

Η μεταβλητή "size" περιέχει το μέγεθος το οποίο θα δεσμεύσει η "new()" για το αντικείμενο, "ctor" είναι η συνάρτηση δημιουργίας του αντικειμένου η οποία λαμβάνει σαν είσοδο τη μνήμη που έχει δεσμεύσει η "new()" καθώς και επιπλέον ορίσματα για την αρχικοποίηση των μεταβλητών, "dtor" είναι η συνάρτηση καταστροφής ενός αντικειμένου οι οποία δέχεται το αντικείμενο προς διαγραφή.

void * new (const void * _class, ...){

const struct Class * class = _class;

return p;

}

 

 

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

void delete (void * self){

const struct Class ** cp = self;

free(self);

}

 

Μπορούμε να χρησιμοποιήσουμε την κλάση "Class" προσθέτοντας ένα δείκτη προς τη μέθοδο void (* draw) (const void * self) η οποία θα σχεδιάζει το σημείο.

struct Point {

const void * class;

printf("Draw point at (%d,%d)", self -> x, self -> y);

}

Η συνάρτηση "move()" δεν χρειάζεται να "συνδεθεί" με την κλάση καθώς η μεταφορά του σημείου και του κύκλου είναι ίδια καθώς ο κύκλος αποτελείται από ένα σημείο και την ακτίνα.

 

Η κλάση "Circle" αποτελείται απ ο ένα σημείο και την ακτίνα άρα η κλάση "Circle" γίνεται:

stuct Circle{

const struct Point _p;

self -> x, self -> y, self -> rad);

}

 

 

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

 

Η πιο συνηθισμένη χρήση των templates είναι για την υλοποίηση δομών δεδομένων(Containers) οι οποίες μπορούν να χρησιμοποιηθούν για οποιονδήποτε τύπο δεδομένων. Έτσι, ο προγραμματιστής μπορεί να χρησιμοποιήσει έτοιμο αλγόριθμο, όπως η λειτουργία μίας λίστας, με διαφορετικούς τύπους δεδομένων αρχικοποιώντας κάθε φορά την δομή αυτή με τον τύπο δεδομένων που επιθυμεί. Ένα παράδειγμα είναι η κλάση CAtlArray, της βιβλιοθήκης atlcoll.h, που ανήκει στη βιβλιοθήκη ATL (Active Template Library). Ενδεικτικά, για τη λειτουργία της αρχικοποίησης:

CAtlArray<int> myTestArray;

int theElement;

myTestArray.add(theElement);

}

 

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

 

/*

* Singly-linked List declarations.

struct type *sle_next; /* next element */ \

}

Έτσι, εάν είναι επιθυμητή η δημιουργία μίας λίστας με τύπους int, τότε μπορεί να κανείς να γράψει:

SLIST_HEAD(myListHead, int) myHead = SLIST_HEAD_INITIALIZER(myHead);

Το ίδιο μπορεί να γίνει και για την λειτουργικότητα που μπορεί να προσφέρει μία λίστα. Π.χ.,

#define SLIST_NEXT(elm, field) ((elm)->field.sle_next)

#define SLIST_FOREACH(var, head, field) \

for ((var) = SLIST_FIRST((head)); (var); (var) = SLIST_NEXT((var), field))

Όπου, και πάλι, μπορεί να φανεί η διαχείριση του κειμένου από τον prepocessor για την παραγωγή κώδικα και την προσομοίωση της λειτουργικότητας των προτύπων. Έτσι, για τη λειτουργία foreach ο προεπεξεργαστής:

 

 

<references />