Показивач (понекад поинтер, према енгл. pointer) представља промјенљиву специјалног типа у неким програмским језицима попут C-а, C++-а, Паскала итд. Показивач има сврху да чува адресу меморијске локације неке друге промјенљиве, константе или показивача.

Основна својства показивача су:

• показивач може мијењати вриједност (тј. може показивати на разне локације за вријеме свог радног вијека)
• преко њега се може добити вриједност промјенљиве чију адресу чува (на коју показује)
• преко њега се може мијењати вриједност промјенљиве на коју показује

Када узимамо или мијењамо вриједност елемента на којег показивач показује, кажемо да га дереференцирамо.

У већини програмских језика који подржавају показиваче, показивачи се дијеле на типске и бестипске.

Уз типске показиваче се веже информација о типу промјенљивих на које ће дати показивач моћи показивати, односно чије ће адресе моћи чувати. Када декларишемо типски показивач, он до краја свог вијека има исти тип.

Бестипски показивачи немају одређен тип промјенљиве на које ће моћи показивати, те могу показивати на све промјенљиве подједнако. На уштрб тога, међутим, постоје одређена ограничења везана за ову врсту показивача:

• није дозвољено дереференцирање (видјети поглавље „Референцирање и дереференцирање“, ниже)
• није дозвољена показивачка аритметика у језицима у којима је подржана за типске показиваче

Бестипски показивачи се најчешће користе у ситуацијама када одређена функција прихвата податке промјенљивог типа или када нам тип податка није унапријед познат.

Референцирање је процес у којем показивачу додјељујемо адресу одређене меморијске локације. Након тога кажемо да показивач показује на ту меморијску локацију.

Дереференцирање је процес у којем преко показивача који већ показује на неку меморијску локацију приступамо самој локацији, било ради читања њене вриједности, било ради њеног мијењања. Забрањено је, и најчешће узрокује прекид рада програма, дереференцирање показивача који:

• садржи вриједност која служи за означавање да показивач ни не показује ни на шта (најчешће вриједност 0)
• показује на адресу која се не налази у меморијском простору процеса који извршава програм. То су најчешће показивачи са неиницијализованим вриједностима, који садрже адресу која се случајно затекла у простору заузетом за дати показивач.

Показивачка аритметика се односи на посебан начин вршења рачунских операција сабирања и одузимања када међу операндима има и показивача. Тада често не важе уобичајена правила при рачунању, тј. адресе које показивачи чувају неће се сабирати и одузимати као обични бројеви. Показивачка аритметика за сврху има софистицирано руковање показивачима како би се добили одређени резултати. Помоћу показивачке аритметике, показивач се може кретати по одређеним меморијским локацијама, могу се мјерити удаљености једне меморијске локације од друге у зависности од типова показивача итд.

У програмском језику 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 );

Да бисмо додијелили одређену вриједност показивачкој промјенљивој, користимо уобичајен оператор додјеле:

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];

тада настаје 10 елемената низа (који ниједан нема своје право име), и једна показивачка промјенљива a преко које се приступа свим елементима низа користећи синтаксу a[0] (први елемент, јер у C-у индексирање креће од нуле, а не од јединице), a[1], a[2], итд.

Низови се у C-у имплементирају преко показивача захваљујући специфичној показивачкој аритметици. Ако је a показивач на први елемент низа, онда *a представља сам елемент. Даље, пошто показивачка аритметика диктира да a+1 буде показивач на сљедећи елемент низа, онда ће *(a+1) представљати сам други елемент низа. Идући даље, примјећујемо да је a[n] еквивалентно са *(a+n). То је управо оно што компајлер види када путем оператора индекса референцирамо одређени елемент низа.

Ако идемо даље, и представимо матрицу реалних бројева М димензија m x n, тада је стање у меморији сљедеће:

• M представља показивач на први елемент низа од m показивача.
• сваки од m показивача показује на по први елемент низа од n реалних бројева (видјети слику десно).

Када користимо статичке декларације низова, оваква стања меморије се формирају аутоматски, али је такође могуће формирати их ручно, користећи обичну декларацију показивача и неку од уграђених C-ових функција за алоцирање меморије. Слиједи примјер:

char ** alocirajMatricu(int m, int n )
{
    char ** M;
    int i;
    M = malloc(m * sizeof(char *) );        /* алоцирамо меморију за низ показивача */
    for (i = 0; i < m; i++ )                /* за сваки показивач у том низу алоцирамо по још један низ */
         M[i] = malloc(n * sizeof(char) );  /* карактера да бисмо формирали матрицу. */
    return M;                                /* враћамо показивач „на матрицу“. */
}

int main()
{
    char ** M;
    int m, n;
    int i, j;
    scanf("%d %d", &m, &n );         /* питамо корисника колика матрица је потребна */
    M = alocirajMatricu(m, n );      /* позивамо функцију да нам алоцира простор те величине */
    for (i = 0; i < m; i++ )         /* надаље се понашамо као према обичној матрици */
         for (j = 0; j < n; j++ )
               M[i][j] = 'x';

    // овако алоцирану матрицу морамо обрисати ручно
    for (i = 0; i < m; i++ )
         free(M[i] );
    free(M );
    return 0;
}

Посебан чланак: Динамичке структуре података

Уопштено, динамичке структуре података представљају тип структуре која заузима тачно онолико меморије колико јој је неопходно, и може се ширити и смањивати по потреби. Најчешће спомињане динамичке структуре су бинарно стабло (или бинарно дрво), листа, стек, граф, ред, и други. У програмском језику C оне се имплементирају користећи цеовске структуре (struct), показиваче и динамичко алоцирање меморије помоћу неке од уграђених функција C-а.

У програмском језику Паскал, показивачи се дијеле на типске и бестипске.

Паскал не подржава показиваче на функције.

Типски показивачи се декларишу на сљедећи начин:

ime_pokazivaca: ^tip_pokazivaca;

Прво се наводи име показивачке промјенљиве и двотачка (као код декларације осталих елементарних типова промјенљивих у Паскалу), затим слиједи капица (^) и на крају тип промјенљиве на какве ће показивач моћи показивати. За име показивача важе уобичајена правила именовања у п. ј. Паскал.

Бестипски показивачи се декларишу на сљедећи начин:

ime_pokazivaca: pointer;

Умјесто типа и капице, овде се наводи кључна ријеч pointer.

Референцирање је процес у којем показивачу додјељујемо адресу одређене меморијске локације. Да бисмо додијелили одређену вриједност показивачкој промјенљивој, користимо један од следећа два начина:

• уобичајен оператор додјеле
• команду new ради алокације меморије и истовремене додјеле адресе те меморије показивачу

Слиједе примјери за обје ставке, редом:

var
p1: ^integer;
a: integer;
begin
p1 := @a; (* користимо оператор @ за добијање адресе од a да бисмо је додијелили промјенљивој p1 *)
new(p1) (* користимо команду new да алоцирамо простор величине једне цјелобројне промјенљиве (у складу са декларацијом показивача) *)
end.

У случајевима када се жели показати да показивач не чува никакву адресу, тада му додјељујемо нулу помоћу уграђене константе nil:

p := nil;

За ову операцију се користи оператор капице (^) иза имена показивачке промјенљиве:

var
p1: ^integer;
a: integer;
begin
p1 := @a; (* p1 нека показује на a *)
p1^ := 10; (* оно на шта p1 показује (a), нека постане једнако 10 *)
end.

Показивачка аритметика није подржана у стандардном Паскалу. Постоје поједине екстензије Паскала које дозвољавају показивачку аритметику, као што је GPC (Гну-ова екстензија Паскала). Показивачка аритметика Паскала је и тада једноставна и ограничена. Код ње важе уобичајена правила при рачунању, тј. адресе које показивачи чувају ће се сабирати и одузимати као обични бројеви, на тај начин додајући и одузимајући тачно задати број бајтова од адресе коју показивач чува.

Погледајмо сљедећи примјер:

var
x: real; (* претпоставимо да се x налази на адреси 10000 *)
px: ^real;
{$X+} (* коришћење екстензије која дозвољава показивачку аритметику *)
begin
x := 3.14;
px := @x; (* px добија вриједност 10000 *)
px := px+5; (* px добија вредност 10005 *)
end.

Команде inc и dec служе да повећају односно смање вриједност показивача за онолико бајтова колико заузима промјенљива на коју показује. Дакле, команде inc и dec се врше по следећим формулама:

inc(p1) <=> p1 := p1 + sizeof(^p1);
dec(p1) <=> p1 := p1 - sizeof(^p1);

Ово обезбјеђује нпр. итерирање по низу служећи се једним показивачем.

У програмском језику Паскал, показивачи немају превелику примјену, за разлику од програмског језика C. Паскал садржи низ као уграђени тип (користећи кључне ријечи array ... of), преношење аргумента функцији по референци је обезбијеђено синтаксом језика (користећи кључну ријеч var), те је једина примјена показивача у Паскалу најчешће само имплементација динамичких структура података.

Ада подржава само типске показиваче и конверзија између показивача различитих типова је подржана само у одређеном броју случајева. Сви показивачи се подразумијевано иницијализију на нулу (null), и дереференцирање показивача са том вриједношћу изазива изузетак. У програмском језику Ада, показивачи се називају приступни типови, и не подржавају показивачку аритметику, без коришћења екстензија (System.Storage_Elements)

C++, као језик настао на основу C-а, подржава цјелокупну синтаксу C-а везану за показиваче.

У програмском језику C#, показивачи су подржани али само под одређеним условима: било који блок кода који садржи показиваче мора бити означен као „несигуран“, користећи кључну ријеч unsafe. Програми или модули који садрже такве блокове обично захтијевају више нивое дозвола од стране корисника да би се покренули. Синтакса је јако слична синтакси програмског језика C.

Фортран подржава показиваче од верзије 90. Показивачи у Фортрану, међутим, представљају сложене типове података, који поред адресе циљне промјенљиве такође садрже и доњу и горњу границу низа (уколико показивач служи низ), податке о секцијама низа и друге помоћне податке.

• Референца

Показивач на Викимедијиној остави.

• Показивачи у језику C