Aquest article tracta sobre el concepte de punter a punter en C++. El punter a punter apunta o emmagatzema l'adreça d'un altre punter i permet la manipulació dels propis punters. Amb aquest concepte, podem modificar fàcilment un punter des d'una altra ubicació de la memòria. Els punters dobles són beneficiosos en memòria assignada dinàmicament o matrius multidimensionals per manipular els elements d'una matriu. Parlarem d'aquest punter a punter sobre el funcionament i l'ús en C++ amb exemples adequats.
Escenari 1: Representació de memòria de punter a punter
En aquest escenari, declarar el punter doble és similar a la declaració del punter amb un asterisc addicional (*) abans del nom del punter. Podem representar fàcilment la ubicació de memòria d'un punter doble en C++. El fragment de codi del punter a punter es mostra a continuació:
#inclou
utilitzant namespace std;
int principal ( )
{
int dígit = 50 ;
int * ptrr;
ptrr = & dígit;
int ** ptrr1;
ptrr1 = & ptrr;
cout << 'L'adreça de memòria del punter és: \n ' ;
cout << 'ptrr (punter):' << ptrr << ' \n ' ;
cout << '*ptrr1 (punter doble):' <<* ptrr1 << ' \n ' ;
cout << 'El valor emmagatzemat al punter és: \n ' ;
cout << '*ptrr = ' <<* ptrr << endl;
cout << '**ptrr1 (punter a punter) = ' <<** ptrr1 << endl;
tornar 0 ;
}
A la funció principal, prenem una variable l'adreça de memòria de la qual s'ha d'emmagatzemar en un punter. Ara, inicialitzem la variable 'dígit'. Després d'això, declarem el punter 'ptrr' que emmagatzema l'adreça de memòria 'dígit'. Ara, declarem el punter doble el nom del qual és '**ptrr1' que emmagatzema l'adreça del punter '*ptrr'. Al final del codi, mostrem la memòria i el valor del punter i el punter doble a la pantalla de la consola. La sortida d'aquest codi s'esmenta a continuació:
L'adreça de memòria del punter 'ptrr' és '0x6ffe04', i el punter '*ptrr1' també emmagatzema l'adreça de memòria del punter 'ptrr'. El valor que s'emmagatzema dins del punter és '50'. Bàsicament, l'adreça del punter doble és sempre la mateixa que l'adreça de memòria del punter.
Escenari 2: punter a punter com a paràmetre de funció
En aquest escenari, aprendrem a passar el punter doble en qualsevol funció com a paràmetre per realitzar l'assignació de memòria temporal en qualsevol variable. El fragment de codi del paràmetre de funció amb doble punter s'esmenta a continuació:
#include
void getMemoryAddress ( int ** doble_ptr ) {
el teu temps = 200 ;
* double_ptr = & temperatura;
}
int principal ( ) {
int * ptr_1;
int ** doble_ptr;
double_ptr = & ptr_1;
getMemoryAddress ( doble_ptr ) ;
std::cout << 'El valor de **double_ptr és: ' << ** doble_ptr << std::endl;
tornar 0 ;
}
Aquí, aprendrem com funciona el concepte punter a punter en C++. Recordeu que es declara un punter al programa per treballar amb un punter doble. Per tant, construïm la funció 'getMemoryAddress'. Dissenyem aquesta funció de manera que quan passem el paràmetre, obtingui automàticament l'adreça de memòria del punter doble.
A la funció, prenem la variable 'tempp' i el punter doble '**double_ptr'. Passem l'adreça de la variable especificada que és 'tempp' al punter doble i els valors del punter doble com a argument de la funció. El programa mostra el resultat del codi de funció principal a la pantalla de la consola, de manera que totes les coses que hi ha a la funció principal són executables. Prenem el punter 'ptr_1' i el punter doble com 'double_ptr' a la funció principal. Passem l'adreça del punter al punter doble.
Ara, passem la variable de punter doble a la funció de substitució i passem el punter a la variable de punter a la instrucció de flux de sortida 'cout' per mostrar el resultat del punter doble.
Quan el compilador arriba a la funció de substitució, el verificador del compilador on es defineix aquesta funció executa el codi dins de la funció i retorna el resultat a la funció principal.
La sortida d'aquest codi s'adjunta a continuació:
Resultat: el valor del punter doble és 200.
Escenari 3: Ús de la matriu 2D amb punter a punter
En aquest exemple, tractarem una matriu 2D amb un punter doble. Agafem una matriu i passem l'adreça d'una matriu al punter. El codi complet d'aquest escenari es proporciona de la següent manera:
int principal ( ) {const int files = 3 ;
const int cols = 2 ;
int ** matriu = nou int * [ files ] ;
per ( int i = 0 ; i < files; ++i ) {
matriu [ i ] = nou int [ cols ] ;
}
per ( int i = 0 ; i < files; ++i ) {
per ( int j = 0 ; j < cols; ++j ) {
matriu [ i ] [ j ] = i * cols + j;
}
}
per ( int i = 0 ; i < files; ++i ) {
per ( int j = 0 ; j < cols; ++j ) {
cout << matriu [ i ] [ j ] << ' ' ;
}
cout << endl;
}
per ( int i = 0 ; i < files; ++i ) {
esborrar [ ] matriu [ i ] ;
}
esborrar [ ] matriu;
tornar 0 ;
}
Com tots sabem, tenim moltes files i diverses columnes en una matriu 2D. A la funció principal, inicialitzem les files i columnes que tenen 'const int'. Després d'això, assignem l'espai de memòria per a les files i l'espai de memòria per a les columnes al llarg de cada fila. Passem el valor del nombre de files com a punter en el punter doble de la matriu com a '**matrix'. En aquest punter doble, el bucle del nombre de files s'executa o és cert. Aleshores, s'executa un altre bucle intern fins que la condició esdevé falsa.
Després de l'assignació de memòria, tornem a assignar un valor a una matriu: un bucle exterior per a les files i un bucle intern per a les columnes de la matriu 2D. En el bucle interior, el valor de les files i columnes s'assigna al punter doble i realitza una operació aritmètica necessària. Mostrem els valors d'una matriu 2D com el nombre de files i columnes assignades a la memòria. El nombre de files i columnes sempre apunta al punter doble que emmagatzema els valors de files i columnes. Al final, netegem la memòria i desassignem aquesta matriu de la memòria en C++.
La sortida de la matriu 2D amb un punter doble s'adjunta al següent:
Escenari 4: canviar els punters amb punter a punter
Aquí, aprendrem a intercanviar els punters en C++ declarant el punter doble. El fragment de codi d'aquest escenari s'adjunta a continuació:
#inclouintercanvi buit ( int ** ptrr_1, tu ** ptrr_2 ) {
int * temp_var = * ptrr_1;
* ptrr_1 = * ptrr_2;
* ptrr_2 = temp_var;
}
int principal ( ) {
int x = 15 , i = 25 ;
int * ptrrA = & x, * ptrrB = & i;
std::cout << 'Abans de canviar: *ptrrA is = ' << * ptrrA << ', *ptrrB és = ' << * ptrrB << std::endl;
intercanviar ( & ptrrA, & ptrrB ) ;
std::cout << 'Després de l'intercanvi: *ptrrA is = ' << * ptrrA << ', *ptrrB is= ' << * ptrrB << std::endl;
tornar 0 ;
}
Primer, construïm la funció d'intercanvi, passant els dos punters com a argument de la funció. A la funció d'intercanvi, agafem el punter 'temp' i passem el valor de 'punter1' a 'temp' durant un temps. Aleshores, passem el valor de 'punter2' a 'punter1'. Al final, passem el valor del punter 'temp' al 'punter2'.
A la funció principal, necessitem dos punters que passem o substituïm a la funció 'swap'. Passem les adreces de les variables als punters donats. Aleshores, es mostra el valor del punter abans i després de canviar-lo.
La sortida d'aquest codi s'adjunta a continuació:
Com podem veure, els valors del punter s'intercanvien amb èxit mitjançant un punter doble en C++.
Conclusió
Vam concloure que el punter a punter sempre emmagatzema l'adreça de memòria de qualsevol punter en C++. Podem utilitzar el punter doble per utilitzar temporalment la ubicació de memòria de qualsevol punter en qualsevol moment. Aquesta és una manera molt eficaç de manipular indirectament l'adreça de memòria i aproximar-se a les dades.