Показивач (понекад поинтер, према ) представља промјенљиву специјалног типа у неким програмским језицима попут -{C}--а, -{C++}--а, Паскала итд. Показивач има сврху да чува адресу меморијске локације неке друге промјенљиве, константе или показивача.
Основна својства показивача су: показивач може мијењати вриједност (тј. може показивати на разне локације за вријеме свог радног вијека) преко њега се може добити вриједност промјенљиве чију адресу чува (на коју показује) преко њега се може мијењати вриједност промјенљиве на коју показује
Када узимамо или мијењамо вриједност елемента на којег показивач показује, кажемо да га дереференцирамо.
Типови показивача У већини програмских језика који подржавају показиваче, показивачи се дијеле на типске и бестипске.
Уз типске показиваче се веже информација о типу промјенљивих на које ће дати показивач моћи показивати, односно чије ће адресе моћи чувати. Када декларишемо типски показивач, он до краја свог вијека има исти тип.
Бестипски показивачи немају одређен тип промјенљиве на које ће моћи показивати, те могу показивати на све промјенљиве подједнако. На уштрб тога, међутим, постоје одређена ограничења везана за ову врсту показивача: није дозвољено дереференцирање (видјети поглавље „Референцирање и дереференцирање“, ниже) није дозвољена показивачка аритметика у језицима у којима је подржана за типске показиваче
Бестипски показивачи се најчешће користе у ситуацијама када одређена функција прихвата податке промјенљивог типа или када нам тип податка није унапријед познат.
Референцирање и дереференцирање Референцирање је процес у којем показивачу додјељујемо адресу одређене меморијске локације. Након тога кажемо да показивач показује на ту меморијску локацију.
Дереференцирање је процес у којем преко показивача који већ показује на неку меморијску локацију приступамо самој локацији, било ради читања њене вриједности, било ради њеног мијењања. Забрањено је, и најчешће узрокује прекид рада програма, дереференцирање показивача који: садржи вриједност која служи за означавање да показивач ни не показује ни на шта (најчешће вриједност 0) показује на адресу која се не налази у меморијском простору процеса који извршава програм. То су најчешће показивачи са неиницијализованим вриједностима, који садрже адресу која се случајно затекла у простору заузетом за дати показивач.
Показивачка аритметика Показивачка аритметика се односи на посебан начин вршења рачунских операција сабирања и одузимања када међу операндима има и показивача. Тада често не важе уобичајена правила при рачунању, тј. адресе које показивачи чувају неће се сабирати и одузимати као обични бројеви. Показивачка аритметика за сврху има софистицирано руковање показивачима како би се добили одређени резултати. Помоћу показивачке аритметике, показивач се може кретати по одређеним меморијским локацијама, могу се мјерити удаљености једне меморијске локације од друге у зависности од типова показивача итд.
Показивачи у програмском језику -{C}- Типови показивача У програмском језику -{C}-, показивачи се дијеле на типске и бестипске.
Поред показивача на обичне промјенљиве, постоје и показивачи на функције. Показивачи на функције се могу просљеђивати другим функцијама као аргументи и преко њих се могу позивати функције на које показују, што им је и примарна примјена.
Декларација Типски показивачи се декларишу на сљедећи начин:
-{tip_pokazivaca * ime_pokazivaca;}- Прво се наводи тип промјенљиве на какве ће моћи показивати показивач, затим слиједи звјездица (*) и на крају име показивачке промјенљиве терминиране тачка-зарезом. За име показивача важе уобичајена правила именовања у п. ј. -{C}-.
Бестипски показивачи се декларишу на сљедећи начин: -{void * ime_pokazivaca;}-
Умјесто типа овде се наводи кључна ријеч void, након које важе правила као за типске показиваче.
Показивачи на функције се декларишу на сљедећи начин: -{tip_rezultata_originalne_funkcije (*ime_pokazivaca)(tip_prvog_argumenta_funkcije, tip_drugog_argumenta_funkcije, ...);}-
Слиједи примјер за декларацију показивача на одређену функцију: -{/* декларација произвољне функције */ char * kopiraj(char * odrediste, char * izvoriste ) { /* блок функције */ }
/* декларација показивача на овакву функцију (без иницијализације) */ char * (*pkopiraj)(char * odrediste, char * izvoriste );}-
Референцирање десно|мини|250п|Показивач показује на промјенљиву тако што чува у себи њену адресу Да бисмо додијелили одређену вриједност показивачкој промјенљивој, користимо уобичајен оператор додјеле:
-{p1 = <<adresa>>;}-
Пошто је сврха показивача да чувају адресу неког другог податка, морамо да:
знамо унапријед на којој тачно локацији се налази одговарајућа промјенљива користимо оператор & да бисмо добили адресу дате промјенљиве позовемо неку од уграђених функција које нам алоцирају нову меморију и враћају адресу алоцираног простора
Слиједе примјери за сваку од ставки, редом:
-{int * p1; int a = 3; p1 = 0x4CC7EC5C; /* изузетно је опасно и не препоручује се додјељивати адресе директно */ p1 = &a; /* користимо оператор & за добијање адресе од a да бисмо је додијелили промјенљивој p1 */ p1 = malloc(sizeof(int) ); /* користимо функцију malloc да алоцирамо простор величине једне цјелобројне промјенљиве. */ /* malloc враћа адресу новоалоцираног простора */}-
У случајевима када се жели показати да показивач не чува никакву адресу, тада му додјељујемо нулу помоћу уграђене константе NULL: -{int * p1 = NULL;}-
Код показивача на функције важи нешто другачија синтакса референцирања. Ако постоји функција f, и показивач pf декларисан тако да може на њу да показује, онда се референцирање врши једноставном додјелом промјенљиве f промјенљивој pf, без коришћења обичних заграда, као код самог позива: -{pf = f;}-
Дереференцирање Дереференцирање је процес у којем преко показивача који већ показује на неку меморијску локацију приступамо самој локацији. За ову операцију се користи оператор звјездице (*) испред имена показивачке промјенљиве: -{int * p1; int a; p1 = &a; /* p1 нека показује на a */ *p1 = 10; /* оно на шта p1 показује (a), нека постане једнако 10 */}-
Показивачи на функције се деференцирају на нешто другачији начин. Заправо, код њих се не може говорити о правом дереференцирању, него радије само о позивању функције преко показивача. Наиме, оног тренутка када је нпр. показивач pf почео да показује на функцију f, он је постао алиас (лажно име, друго име) за функцију f, и користи се равноправно, на исти начин као и сама функција. Слиједи примјер: -{int saberi(int a, int b ) { return a + b; }
int main() { int (*psaberi)(int, int ); int x = 3, y = 4; int z; psaberi = saberi; z = saberi(x, y ); /* позив оригиналне функције */ z = psaberi(x, y ); /* позив функције преко показивача */
Слиједи примјер просљеђивања показивача на функцију другој функцији, која је позива преко тог показивача: -{int saberi(int x, int y ) { return x + y; }
int pozovi(int (*psaberi)(int, int), int x, int y ) { return psaberi(x, y ); /* позивамо функцију преко показивача, и просљеђујемо јој преостала два аргумента */ }
int main() { int z; z = pozovi(saberi, 3, 4 ); /* први аргумент је само име функције, без заграда, а други су аргументи за сабирање */ return 0;
Показивачка аритметика У показивачкој аритметици програмског језика -{C}- не важе уобичајена правила при рачунању, тј. адресе које показивачи чувају неће се сабирати и одузимати као обични бројеви. Начин рачунања ће заправо зависити од тога који је тип промјенљиве на коју показивачи показују, односно који је тип самих показивача. Сабирање и одузимање показивача са цијелим бројем се врши по сљедећој формули:
-{p1 ± n = p1 ± (n * sizeof(*p1));}-
Погледајмо сљедећи примјер: -{double x = 3.14; /* претпоставимо да се x налази на адреси 10000 */ double * px = &x; /* px добија вриједност 10000 */ printf("%d\n", px + 5 ); /* штампа се број 10000 + 5*sizeof(double) = нпр. 10000 + 5*8 = 10040 (не 10005) */}-
Показивачи се могу и међусобно одузимати, када важе слична правила као код показивача и цијелог броја.
Важе сљедећа рестриктивна правила везана за показиваче: показивачи се не смију множити нити дијелити цијелим бројем показивачи се не смију међусобно сабирати, множити нити дијелити
Примјена У програмском језику -{C}-, најважније примјене показивача су сљедеће: пренос аргумената функцији по референци имплементација низова имплементација динамичких структура
Пренос аргумената функцији по референци У програмском језику -{C}-, функције су такве да добијају увијек копије аргумената које јој просљеђујемо, а никад оригиналне аргументе. На овај начин функција не може имати спољашње ефекте јер све што добија од функције-позиваоца су копије оригиналних аргумената који остају нетакнути. Овакав начин преноса аргумената се популарно назива пренос аргумената по вриједности, јер функција добија практично само вриједности оригиналних аргумената али никад и директно њих саме.
Проблеми се јављају, међутим, у случајевима када желимо да функција ипак измијени одређене промјенљиве које јој прослиједимо као аргументе. Та се потреба јавља нпр. када желимо функцију која ће имати више резултата, јер помоћу уобичајене кључне ријечи return она може вратити само један резултат. Тада користимо тзв. пренос аргумената по референци који у ствари представља праксу да умјесто оригиналног елемента прослиједимо његову адресу као аргумент. Ова адреса представља показивач на оригинални елемент, па иако се опет поштује правило да функција добија копију аргумента који јој се прослиједи, овај пут она добија копију адресе, што је ипак сасвим довољно да се оригиналном аргументу приђе директно, дереференцирањем.
Погледајмо сљедећи примјер: -{void povecaj(int c ) { c = c+1; }
int main() { int x = 1; povecaj(x ); printf("%d", x ); return 0;
Из претходног параграфа закључујемо да функција povecaj неће извршити своју улогу јер на мјесто промјенљиве c добија копију од x. На тај начин копија од x бива повећана за 1, али не и оригинални елемент x у функцији main. Да бисмо поправили кôд, мораћемо извршити пар измјена: функција povecaj треба да се прилагоди тако да прихвата адресу цјелобројне промјенљиве, а не њу саму када добије адресу, дереференцираће је и повећати оно што се налази на тој адреси за 1 функција main треба да пошаље адресу од x, а не сāмо x Погледајмо како изгледа резултат измјена: -{void povecaj(int * pc ) { *pc = *pc + 1; /* *pc представља оно на шта pc показује, тј. оно што се налази на адреси pc */ }
int main() { int x = 1; povecaj(&x ); /* &x представља адресу од x */ printf("%d", x ); return 0;
Користећи пренос аргумената по референци, програмер такође штеди на копирању аргумената при позивању једне функције из друге. Ако је аргумент који преносимо велик податак, нпр. структура од више елемената чија укупна величина превазилази величину показивачке промјенљиве на датом систему, добро га је прослиједити по референци јер на тај начин копирамо мање података.
Имплементација низова десно|мини|Скица уређења низа у меморији У програмском језику -{C}- не постоје низови као уграђени типови. Напротив, они се имплементирају преко осталих уграђених типова и показивача. Ово важи и за једнодимензионалне и вишедимензионалне низове (матрице, коцке итд.). Сваки низ и -{C}--у се састоји од два физичка дијела - елемената који сачињавају низ и једног показивача који показује на почетак тог низа, тј. његов први елемент (видјети слику десно). Дакле, када представимо низ на сљедећи начин: -{int a;}- тада настаје 10 елемената низа (који ниједан нема своје право име), и једна показивачка промјенљива a преко које се приступа свим елементима низа користећи синтаксу a (први елемент, јер у -{C}--у индексирање креће од нуле, а не од јединице), a, a, итд.