Zmienna wskaźnikowa

Wskaźnik a wskazuje na zmienną b – czyli wartością a jest adres b (wszystkie wartości przedstawione są w systemie szesnastkowym)

Ten artykuł trzeba dopracować zgodnie z zaleceniami edycyjnymi: Artykuł ten napisany jest z punktu widzenia języków C/C++. Należy go przepisać tak, aby faktycznie dotyczył pojęcia wskaźników, a nie omawiania składni oraz możliwości C/C++. Dokładniejsze informacje o tym, co trzeba poprawić, być może leżą na stronie dyskusji tego artykułu. Po wyeliminowaniu niedoskonałości prosimy usunąć szablon {{Dopracować}} z kodu tego artykułu.

W językach programowania pozwalających na bezpośredni dostęp do pamięci (jak np. asembler, C, C++, Cyclone) pamięć jest reprezentowana jako jednowymiarowa tablica bajtów - wszystkie zmienne (statyczne oraz dynamiczne) są umieszczane w tej „tablicy”.

Wskaźnik jest indeksem do tej tablicy – najczęściej ów indeks jest równocześnie logicznym adresem. Zwykle istnieje też specjalny symbol, który wyznacza wskazanie jako puste. W językach C, C++, Cyclone jest to NULL, w Pascalu nil. Wskaźnik taki nie wskazuje na nic (konkretnie: jego wartość liczbowa jako adresu jest równa 0), albowiem w nowoczesnych systemach operacyjnych żaden proces nie ma dostępu do komórki pamięci o adresie 0, stąd też jest ona wykorzystywana do oznaczenia wskazania do niczego. Wartość ta służy np. do oznaczania końca listy jednokierunkowej, liści drzewa binarnego itp.

W nowszych językach takich jak Java czy C# zamiast wskaźników używa się ulepszonej formy referencji, które wcale nie potrafią wskazywać na przypadkowy adres pamięci, potrafią zaledwie wskazywać na rzeczywisty obiekt albo posiadać wartość null. Eliminuje to całą kategorię błędów wynikających z próby interpretacji przypadkowego fragmentu pamięci jako obszaru zawierającego konkretne, użyteczne dane. Nie dają one jednak pełnej kontroli nad pamięcią oraz uniemożliwiają wykorzystanie wskaźników do szybkiego poruszania się po tablicy.

Definicja wskaźnika na obiekt albo (prostą) zmienną

W językach C/C++ definicja wskaźnika jest instrukcją składającą się z nazwy typu zmiennej, znaku * (używanego też w innym kontekście jako operator wyłuskania) oraz identyfikatora nowo tworzonego wskaźnika:

TYP * zmienna;

Przykłady:

int*    p;  // 'p' jest zmienną wskaźnikową przechowującą adres liczby typu 'int'
double* q;  // 'q' jest zmienną wskaźnikową przechowującą adres liczby typu 'double'
 
struct X;   // deklaracja struktury
X* pp;      // definicja wskaźnika na obiekt/strukturę typu X

W języku C tradycyjnie znak * umieszcza się tuż przy nazwie zmiennej (co uwypukla nazwę typu, na który wskazuje wskaźnik); w C++ tuż przy nazwie typu (co uwypukla nazwę zmiennej oraz jej typ). Obydwie możliwości są jednak poprawne dla każdego z tych języków.

int *p;     // zapis w stylu języka C
int* p;     // ta sama instrukcja w stylu języka C++

W przypadku definiowania kilku zmiennych w jednej linii, wskaźnikami są tylko te, przy których postawiony stał się znak *:

int *a, *b, c; //a, b - wskaźniki na typ int, c - zmienna typu int

Operator pobrania adresu

Każda zmienna/obiekt ma jednoznaczny adres. W językach C oraz C++ adres ten da się pobrać przy pomocy operatora &

int *w;     /* 'w' jest wskaźnikiem na zmienną typu int */
int a = 5;
int b = 5;
 
w = &a;     /* wskaźnik 'w' wskazuje teraz na obszar
               pamięci zajmowany przez zmienną 'a' */
 
w = &b;     /* a teraz 'w' wskazuje na zmienną 'b' */

Wyłuskanie wskaźnika

Obszar wskazywany przez wskaźnik na TYP da się interpretować jako zmienną (obiekt) typu TYP. Do odczytywania tej zmiennej służy operator *. Operację pobrania danych za pośrednictwem wskaźnika zwie się wyłuskiwaniem (ang. dereferencing) albo adresowaniem pośrednim (ang. indirection)

int *w;       /* wskaźnik na zmienną typu int */
int  a = 100;
int  b;
 
w = &a;       /* wskaźnik 'w' wskazuje na zmienną typu int 'a' */
b = *w;       /* przypisz zmiennej 'b' wartość spod adresu wskazywanego
                 przez 'w'; teraz 'b' równe jest 100  */

Rzutowanie wskaźnika

Gdyż formalnie wskaźnik pokazuje na obszar pamięci, da się dowolnie interpretować zawartość tej pamięci. Jest to pewne uogólnienie, które może powodować błędy. Rzutowaniem nazywa się operację wymuszającą interpretację danego wskazania jako określonego typu danych, np.

char* wiki = "Optopedia ";
printf("Adres %d interpreterowany jako\n", (unsigned int)wiki);
printf("* łańcuch znaków: %s\n", wiki);
printf("* znak: %c\n", *(char*)wiki);
printf("* wartość całkowita ze znakiem: %d\n",  *(int*)wiki);
printf("* wartość całkowita bez znaku: %d\n",  *(unsigned int*)wiki);

I przykładowy wynik działania programu:

Adres 134514016 interpretowany jako
* łańcuch znaków: Optopedia 
* znak: W
* wartość całkowita ze znakiem: 1768646999
* wartość całkowita bez znaku: 1768646999

Problemy podczas rzutowania

O ile takie rzutowanie np.: z typu long double* na typ char* jest bezpieczne, o tyle rzutowanie z char* na long double* może już takowe nie być:

long double c = 0.0;
char d = 'x';
 
long double* wsk1LongDouble = &c;
d = *(char*)wsk1LongDouble; // bezpiecznie
 
char* wskChar = &d;
c = *(long double*)wskChar; // niebezpieczne

Jest to spowodowane tym, że rozmiar zmiennej typu char wynosi 1 bajt (jest to pewne uproszczenie, ale dla potrzeb przykładu wystarczy), z tym że zmiennej typu long double wynosi 8 bajtów. W momencie dereferencji zrzutowanego wskaźnika, wskazującego na wartość jedno bajtową, nastąpi próba odczytania wartości long double, czyli ośmiu bajtów, które leżą być może w obszarze pamięci, który nie stał się przydzielony programowi przez system operacyjny. Podobna sytuacja ma miejsce podczas rzutowania w dół.

Rzutowanie w dół

Przykład w języku C++:

class Bazowa {
  public:
    int x;
};
 
class Pochodna : public Bazowa {
  public:
    int y;
};
 
void fun1( Bazowa& obiekt ) {
  obiekt.x = 5;
}
 
void fun2( Pochodna& obiekt ) {
  obiekt.y = 5;
}
 
int main() {
  Bazowa obiektBazowy;     // deklaracja obiektu klasy Bazowa
  Pochodna obiektPochodny; // deklaracja obiektu klasy Pochodna
  Bazowa* wskBazowa = &obiektBazowy;
  Pochodna* wskPochodna = &obiektPochodny;
  fun1( obiektPochodny ); // ok
  fun1( *wskPochodna ); // ok
  fun2( *((Pochodna*)wskBazowa) ); // nie ok!!
}

Możliwa jest konwersja standardowa obiektu typu pochodnego na typ bazowy. Zarówno obiekt bazowy, jak oraz pochodny posiadają w swojej strukturze pole x. Problem może się pojawić podczas konwersji w drugą stronę: z typu bazowego na typ pochodny (w tym wypadku musi być ona jawna). Obiekt klasy bazowej nie ma w swojej strukturze pola y (jest mniejszy z punktu widzenia rozmiaru) stąd też wskazanie w funkcji void fun2( Pochodna& ) obiekt.y = 5; będzie wskazywało poza obszar zajmowany przez obiekt klasy bazowej, co może naruszyć ochronę pamięci.

Pomimo tego czasem celowo rzutuje się w dół, lecz trzeba dbać o bezpieczeństwo takiego rzutowania.

Sprawdź też

Sprawdź podręcznik na Wikibooks: C - Wskaźniki

• referencja