Αυτό το άρθρο αφορά την έννοια δείκτη σε δείκτη στην C++. Ο δείκτης προς δείκτη δείχνει ή αποθηκεύει τη διεύθυνση ενός άλλου δείκτη και επιτρέπει τον χειρισμό των ίδιων των δεικτών. Χρησιμοποιώντας αυτήν την έννοια, μπορούμε εύκολα να τροποποιήσουμε έναν δείκτη από άλλη θέση στη μνήμη. Οι διπλοί δείκτες είναι χρήσιμοι σε δυναμικά εκχωρημένη μνήμη ή πολυδιάστατους πίνακες για τον χειρισμό των στοιχείων ενός πίνακα. Θα συζητήσουμε αυτή τη λειτουργία και τη χρήση του δείκτη προς δείκτη στην C++ με κατάλληλα παραδείγματα.
Σενάριο 1: Αναπαράσταση μνήμης δείκτη σε δείκτη
Σε αυτό το σενάριο, η δήλωση του διπλού δείκτη είναι παρόμοια με τη δήλωση του δείκτη με έναν πρόσθετο αστερίσκο (*) πριν από το όνομα του δείκτη. Μπορούμε εύκολα να αναπαραστήσουμε τη θέση μνήμης ενός διπλού δείκτη στη C++. Το απόσπασμα κώδικα του δείκτη σε δείκτη δίνεται ως εξής:
#include
χρησιμοποιώντας namespace std?
int main ( )
{
int ψηφίο = πενήντα ;
ενθ * ptrr;
ptrr = & ψηφίο;
ενθ ** ptrr1;
ptrr1 = & ptrr;
cout << 'Η διεύθυνση μνήμης δείκτη είναι: \n ' ;
cout << 'ptrr (δείκτης):' << ptrr << ' \n ' ;
cout << '*ptrr1 (διπλός δείκτης):' <<* ptrr1 << ' \n ' ;
cout << ' Η τιμή που αποθηκεύεται στον δείκτη είναι: \n ' ;
cout << '*ptrr =' <<* ptrr << endl;
cout << '**ptrr1 (δείκτης σε δείκτη) = ' <<** ptrr1 << endl;
ΕΠΙΣΤΡΟΦΗ 0 ;
}
Στην κύρια συνάρτηση, παίρνουμε μια μεταβλητή της οποίας η διεύθυνση μνήμης πρέπει να αποθηκευτεί σε έναν δείκτη. Τώρα, αρχικοποιούμε τη μεταβλητή 'ψηφίο'. Μετά από αυτό, δηλώνουμε τον δείκτη 'ptrr' που αποθηκεύει τη διεύθυνση μνήμης 'ψηφίο'. Τώρα, δηλώνουμε τον διπλό δείκτη του οποίου το όνομα είναι '**ptrr1' που αποθηκεύει τη διεύθυνση του δείκτη '*ptrr'. Στο τέλος του κωδικού, εμφανίζουμε τη μνήμη και την τιμή του δείκτη και του διπλού δείκτη στην οθόνη της κονσόλας. Η έξοδος αυτού του κώδικα αναφέρεται στα ακόλουθα:
Η διεύθυνση μνήμης του δείκτη 'ptrr' είναι '0x6ffe04' και ο δείκτης '*ptrr1' αποθηκεύει επίσης τη διεύθυνση μνήμης του δείκτη 'ptrr'. Η τιμή που είναι αποθηκευμένη μέσα στον δείκτη είναι '50'. Βασικά, η διεύθυνση του διπλού δείκτη είναι πάντα η ίδια με τη διεύθυνση μνήμης του δείκτη.
Σενάριο 2: Δείκτης σε δείκτη ως παράμετρος συνάρτησης
Σε αυτό το σενάριο, θα μάθουμε πώς να περνάμε τον διπλό δείκτη σε οποιαδήποτε συνάρτηση ως παράμετρο για την εκτέλεση της προσωρινής εκχώρησης μνήμης σε οποιαδήποτε μεταβλητή. Το απόσπασμα κώδικα της παραμέτρου συνάρτησης με διπλό δείκτη αναφέρεται παρακάτω:
#include
void getMemoryAddress ( ενθ ** double_ptr ) {
εσύ καιρός = 200 ;
* double_ptr = & θερμοκρασία?
}
int main ( ) {
ενθ * ptr_1;
ενθ ** double_ptr;
double_ptr = & ptr_1;
getMemoryAddress ( double_ptr ) ;
std::cout << 'Η τιμή του **double_ptr είναι : ' << ** double_ptr << std::endl;
ΕΠΙΣΤΡΟΦΗ 0 ;
}
Εδώ, θα μάθουμε πώς λειτουργεί η έννοια δείκτη σε δείκτη στην C++. Θυμηθείτε ότι ένας δείκτης δηλώνεται στο πρόγραμμα για να λειτουργεί με διπλό δείκτη. Έτσι, χτίζουμε τη συνάρτηση 'getMemoryAddress'. Σχεδιάζουμε αυτή τη συνάρτηση έτσι ώστε όταν περνάμε την παράμετρο, να παίρνει αυτόματα τη διεύθυνση μνήμης του διπλού δείκτη.
Στη συνάρτηση, παίρνουμε τη μεταβλητή 'tempp' και τον διπλό δείκτη '**double_ptr'. Περνάμε τη διεύθυνση της καθορισμένης μεταβλητής που είναι «tempp» στον διπλό δείκτη και τις τιμές του διπλού δείκτη ως όρισμα της συνάρτησης. Το πρόγραμμα εμφανίζει το αποτέλεσμα του κύριου κώδικα λειτουργίας στην οθόνη της κονσόλας, ώστε όλα τα πράγματα που βρίσκονται στην κύρια συνάρτηση να είναι εκτελέσιμα. Παίρνουμε τον δείκτη «ptr_1» και τον διπλό δείκτη ως «double_ptr» στην κύρια συνάρτηση. Περνάμε τη διεύθυνση του δείκτη στον διπλό δείκτη.
Τώρα, περνάμε τη μεταβλητή διπλού δείκτη στη συνάρτηση παράκαμψης και περνάμε τον δείκτη στη μεταβλητή δείκτη στη δήλωση ροής εξόδου «cout» για να δείξουμε το αποτέλεσμα του διπλού δείκτη.
Όταν ο μεταγλωττιστής φτάσει στη συνάρτηση παράκαμψης, ο ελεγκτής μεταγλωττιστή όπου ορίζεται αυτή η συνάρτηση εκτελεί τον κώδικα μέσα στη συνάρτηση και επιστρέφει το αποτέλεσμα στην κύρια συνάρτηση.
Η έξοδος αυτού του κώδικα επισυνάπτεται στα ακόλουθα:
Αποτέλεσμα: Η τιμή του διπλού δείκτη είναι 200.
Σενάριο 3: Χρήση του πίνακα 2D με δείκτη προς δείκτη
Σε αυτό το παράδειγμα, θα ασχοληθούμε με έναν πίνακα 2D που έχει διπλό δείκτη. Παίρνουμε έναν πίνακα και περνάμε τη διεύθυνση ενός πίνακα στον δείκτη. Ο πλήρης κώδικας αυτού του σεναρίου παρέχεται ως εξής:
int main ( ) {const int σειρές = 3 ;
const int cols = 2 ;
ενθ ** matrix = νέος ενθ * [ σειρές ] ;
Για ( int i = 0 ; Εγώ < σειρές? ++i ) {
μήτρα [ Εγώ ] = νέος ενθ [ cols ] ;
}
Για ( int i = 0 ; Εγώ < σειρές? ++i ) {
Για ( int j = 0 ; ι < cols? ++j ) {
μήτρα [ Εγώ ] [ ι ] = θ * cols + j;
}
}
Για ( int i = 0 ; Εγώ < σειρές? ++i ) {
Για ( int j = 0 ; ι < cols? ++j ) {
cout << μήτρα [ Εγώ ] [ ι ] << '' ;
}
cout << endl;
}
Για ( int i = 0 ; Εγώ < σειρές? ++i ) {
διαγράφω [ ] μήτρα [ Εγώ ] ;
}
διαγράφω [ ] μήτρα;
ΕΠΙΣΤΡΟΦΗ 0 ;
}
Όπως όλοι γνωρίζουμε, έχουμε πολλές σειρές και πολλές στήλες σε έναν πίνακα 2D. Στην κύρια συνάρτηση, αρχικοποιούμε τις γραμμές και τις στήλες που έχουν “const int”. Μετά από αυτό, εκχωρούμε το χώρο μνήμης για τις γραμμές και το χώρο μνήμης για τις στήλες κατά μήκος κάθε γραμμής. Περνάμε την τιμή του αριθμού των γραμμών ως δείκτη στον διπλό δείκτη του πίνακα ως '**matrix'. Σε αυτόν τον διπλό δείκτη, ο βρόχος του αριθμού των σειρών εκτελείται ή true. Στη συνέχεια, εκτελείται ένας άλλος εσωτερικός βρόχος έως ότου η συνθήκη γίνει ψευδής.
Μετά την εκχώρηση μνήμης, εκχωρούμε ξανά μια τιμή σε έναν πίνακα: έναν εξωτερικό βρόχο για τις σειρές και έναν εσωτερικό βρόχο για τις στήλες του πίνακα 2D. Στον εσωτερικό βρόχο, η τιμή των γραμμών και στηλών εκχωρείται στον διπλό δείκτη και εκτελεί μια απαιτούμενη αριθμητική πράξη. Εμφανίζουμε τις τιμές ενός πίνακα 2D όπως τον αριθμό των γραμμών και στηλών που έχουν εκχωρηθεί στη μνήμη. Ο αριθμός των σειρών και των στηλών δείχνει πάντα τον διπλό δείκτη που αποθηκεύει τις τιμές σειρών και στηλών. Στο τέλος, καθαρίζουμε τη μνήμη και διαθέτουμε αυτόν τον πίνακα από τη μνήμη στη C++.
Η έξοδος του πίνακα 2D με διπλό δείκτη επισυνάπτεται ως εξής:
Σενάριο 4: Αλλαγή των δεικτών με χρήση δείκτη σε δείκτη
Εδώ, θα μάθουμε πώς να ανταλλάσσουμε τους δείκτες στη C++ δηλώνοντας τον διπλό δείκτη. Το απόσπασμα κώδικα αυτού του σεναρίου επισυνάπτεται στα ακόλουθα:
#includeεναλλαγή κενού ( ενθ ** ptrr_1, εσύ ** ptrr_2 ) {
ενθ * temp_var = * ptrr_1;
* ptrr_1 = * ptrr_2;
* ptrr_2 = temp_var;
}
int main ( ) {
int x = δεκαπέντε , y = 25 ;
ενθ * ptrrA = & Χ, * ptrrB = & και;
std::cout << 'Πριν από την ανταλλαγή: *ptrrA is = ' << * ptrrA << ', *ptrrB is = ' << * ptrrB << std::endl;
ανταλαγή ( & ptrrA, & ptrrB ) ;
std::cout << 'Μετά την ανταλλαγή: *ptrrA is = ' << * ptrrA << ', *ptrrB is= ' << * ptrrB << std::endl;
ΕΠΙΣΤΡΟΦΗ 0 ;
}
Αρχικά, χτίζουμε τη συνάρτηση swap, περνώντας και τους δύο δείκτες ως όρισμα συνάρτησης. Στη συνάρτηση swap, παίρνουμε τον δείκτη 'temp' και περνάμε την τιμή του 'pointer1' σε 'temp' για κάποιο χρονικό διάστημα. Στη συνέχεια, περνάμε την τιμή του “pointer2” στο “pointer1”. Στο τέλος περνάμε την τιμή του δείκτη “temp” στον “pointer2”.
Στην κύρια συνάρτηση, χρειαζόμαστε δύο δείκτες που περνάμε ή παρακάμπτουμε στη συνάρτηση «swap». Περνάμε τις διευθύνσεις των μεταβλητών στους δείκτες που δίνονται. Στη συνέχεια, εμφανίζεται η τιμή του δείκτη πριν και μετά την εναλλαγή του δείκτη.
Η έξοδος αυτού του κώδικα επισυνάπτεται στα ακόλουθα:
Όπως μπορούμε να δούμε, οι τιμές του δείκτη εναλλάσσονται με επιτυχία χρησιμοποιώντας έναν διπλό δείκτη στη C++.
συμπέρασμα
Καταλήξαμε στο συμπέρασμα ότι ο δείκτης προς τον δείκτη αποθηκεύει πάντα τη διεύθυνση μνήμης οποιουδήποτε δείκτη στη C++. Μπορούμε να χρησιμοποιήσουμε τον διπλό δείκτη για να χρησιμοποιήσουμε προσωρινά τη θέση μνήμης οποιουδήποτε δείκτη ανά πάσα στιγμή. Αυτός είναι ένας πολύ αποτελεσματικός τρόπος για να χειριστείτε τη διεύθυνση μνήμης έμμεσα και να προσεγγίσετε τα δεδομένα.