Овај чланак је о концепту показивача на показивач у Ц++. Поинтер на показивач указује или чува адресу другог показивача и омогућава манипулацију самим показивачима. Користећи овај концепт, лако можемо модификовати показивач са друге локације у меморији. Двоструки показивачи су корисни у динамички додељеној меморији или вишедимензионалним низовима за манипулисање елементима низа. Разговараћемо о раду и употреби показивача на показивач у Ц++ са одговарајућим примерима.
Сценарио 1: Меморијска репрезентација показивача на показивач
У овом сценарију, декларисање двоструког показивача је слично декларацији показивача са додатном звездицом (*) испред имена показивача. Лако можемо да представимо меморијску локацију двоструког показивача у Ц++. Исечак кода показивача на показивач је дат у следећем:
#инцлуде <иостреам>
користећи простор имена стд;
инт маин ( )
{
инт цифра = педесет ;
инт * птрр;
птрр = & цифра;
инт ** птрр1;
птрр1 = & птрр;
цоут << „Меморијска адреса показивача је: \н ' ;
цоут << 'птрр (показивач): ' << птрр << ' \н ' ;
цоут << '*птрр1 (двоструки показивач): ' <<* птрр1 << ' \н ' ;
цоут << ' Вредност ускладиштена у показивачу је: \н ' ;
цоут << '*птрр = ' <<* птрр << ендл;
цоут << '**птрр1 (показивач на показивач) = ' <<** птрр1 << ендл;
повратак 0 ;
}
У главној функцији узимамо променљиву чија меморијска адреса треба да буде сачувана у показивачу. Сада иницијализујемо променљиву „цифра“. Након тога, декларишемо показивач „птрр“ који чува „цифрену“ меморијску адресу. Сада декларишемо двоструки показивач чије је име „**птрр1“ који чува адресу „*птрр“ показивача. На крају кода приказујемо меморију и вредност показивача и двоструког показивача на екрану конзоле. Излаз овог кода се помиње у следећем:
Меморијска адреса показивача “птрр” је “0к6ффе04”, а показивач “*птрр1” такође чува меморијску адресу “птрр” показивача. Вредност која се чува унутар показивача је „50“. У основи, адреса двоструког показивача је увек иста као меморијска адреса показивача.
Сценарио 2: Показивач на показивач као параметар функције
У овом сценарију ћемо научити како да проследимо двоструки показивач у било којој функцији као параметар да извршимо привремену алокацију меморије у било којој променљивој. Исечак кода параметра функције са двоструким показивачем помиње се у наставку:
#инцлуде<иостреам>
воид гетМемориАддресс ( инт ** доубле_птр ) {
ти време = 200 ;
* доубле_птр = & темп;
}
инт маин ( ) {
инт * птр_1;
инт ** доубле_птр;
доубле_птр = & птр_1;
гетМемориАддресс ( доубле_птр ) ;
стд::цоут << 'Вредност **доубле_птр је: ' << ** доубле_птр << стд::ендл;
повратак 0 ;
}
Овде ћемо научити како концепт показивача на показивач функционише у Ц++. Запамтите да је један показивач декларисан у програму да ради са двоструким показивачем. Дакле, градимо функцију „гетМемориАддресс“. Дизајнирамо ову функцију тако да када проследимо параметар, она аутоматски добије меморијску адресу двоструког показивача.
У функцији узимамо променљиву „темпп“ и двоструки показивач „**доубле_птр“. Адресу наведене променљиве која је „темпп“ прослеђујемо двоструком показивачу и вредности двоструког показивача као аргумент функције. Програм приказује резултат кода главне функције на екрану конзоле, тако да су све ствари које се налазе у главној функцији извршне. Узимамо показивач „птр_1“ и двоструки показивач као „доубле_птр“ у главној функцији. Адресу показивача прослеђујемо двоструком показивачу.
Сада, ми прослеђујемо променљиву двоструког показивача у функцији преклапања и преносимо показивач на променљиву показивача у наредби излазног тока „цоут“ да бисмо приказали резултат двоструког показивача.
Када компајлер достигне функцију надјачавања, проверач компајлера где је ова функција дефинисана извршава код унутар функције и враћа резултат главној функцији.
Излаз овог кода је приложен у следећем:
Резултат: Вредност двоструког показивача је 200.
Сценарио 3: Коришћење 2Д низа са показивачем на показивач
У овом примеру ћемо се бавити 2Д низом који има двоструки показивач. Узимамо низ и прослеђујемо адресу низа у показивач. Комплетан код овог сценарија је дат на следећи начин:
инт маин ( ) {цонст инт ровс = 3 ;
цонст инт цолс = 2 ;
инт ** матрица = нова инт * [ редова ] ;
за ( инт и = 0 ; и < редови; ++и ) {
матрица [ и ] = нова инт [ цолс ] ;
}
за ( инт и = 0 ; и < редови; ++и ) {
за ( инт ј = 0 ; ј < цолс; ++ј ) {
матрица [ и ] [ ј ] = и * цолс + ј;
}
}
за ( инт и = 0 ; и < редови; ++и ) {
за ( инт ј = 0 ; ј < цолс; ++ј ) {
цоут << матрица [ и ] [ ј ] << ' ' ;
}
цоут << ендл;
}
за ( инт и = 0 ; и < редови; ++и ) {
избрисати [ ] матрица [ и ] ;
}
избрисати [ ] матрица;
повратак 0 ;
}
Као што сви знамо, имамо много редова и неколико колона у 2Д низу. У главној функцији иницијализујемо редове и колоне који имају „цонст инт“. Након тога, додељујемо меморијски простор за редове и меморијски простор за колоне дуж сваког реда. Ми прослеђујемо вредност броја редова као показивач у двоструком показивачу матрице као „**матрица“. У овом двоструком показивачу, петља броја редова се извршава или тачно. Затим се извршава друга унутрашња петља све док услов не постане нетачан.
Након алокације меморије, поново додељујемо вредност низу: спољну петљу за редове и унутрашњу петљу за колоне 2Д низа. У унутрашњој петљи, вредност редова и колона се додељује двоструком показивачу и врши потребну аритметичку операцију. Приказујемо вредности 2Д низа као што је број редова и колона који су додељени у меморији. Број редова и колона увек указује на двоструки показивач који чува вредности редова и колона. На крају, чистимо меморију и ослобађамо овај низ из меморије у Ц++.
Излаз 2Д низа са двоструким показивачем је приложен у следећем:
Сценарио 4: Замена показивача помоћу показивача на показивач
Овде ћемо научити како да заменимо показиваче у Ц++ тако што ћемо прогласити двоструки показивач. Исечак кода овог сценарија је приложен у следећем:
#инцлуде <иостреам>воид свап ( инт ** птрр_1, ти ** птрр_2 ) {
инт * темп_вар = * птрр_1;
* птрр_1 = * птрр_2;
* птрр_2 = темп_вар;
}
инт маин ( ) {
инт к = петнаест , и = 25 ;
инт * птрА = & Икс, * птррБ = & и;
стд::цоут << 'Пре замене: *птррА је = ' << * птрА << ', *птррБ је = ' << * птррБ << стд::ендл;
свап ( & птрА, & птррБ ) ;
стд::цоут << 'Након замене: *птррА је = ' << * птрА << ', *птррБ је = ' << * птррБ << стд::ендл;
повратак 0 ;
}
Прво, градимо функцију размене, прослеђујући оба показивача као аргумент функције. У функцији размене, узимамо показивач „темп“ и проследимо вредност „поинтер1“ у „темп“ неко време. Затим преносимо вредност „показивач2“ на „показивач1“. На крају, прослеђујемо вредност показивача „темп“ на „показивач2“.
У главној функцији, потребна су нам два показивача које прослеђујемо или замењујемо у функцији „свап“. Датим показивачима прослеђујемо адресе променљивих. Затим се приказује вредност показивача пре и после замене показивача.
Излаз овог кода је приложен у следећем:
Као што видимо, вредности показивача су успешно замењене коришћењем двоструког показивача у Ц++.
Закључак
Закључили смо да показивач на показивач увек чува меморијску адресу било ког показивача у Ц++. Можемо да користимо двоструки показивач да привремено користимо меморијску локацију било ког показивача у било ком тренутку. Ово је веома ефикасан начин да се индиректно манипулише меморијском адресом и приступи подацима.