C/Wskaźniki

Zmienne w komputerze są przechowywane w pamięci. To wie każdy programista, a dobry programista potrafi kontrolować zachowanie komputera w przydzielaniu i obsłudze pamięci dla zmiennych. W tym celu pomocne są wskaźniki.

Co to jest wskaźnik?

Wskaźnik a wskazujący na zmienną b. Zauważmy, że b przechowuje liczbę, podczas gdy a przechowuje adres b w pamięci (1462)

Wskaźnik (ang. pointer) to specjalny rodzaj zmiennej, w której zapisany jest adres w pamięci komputera. Oznacza to, że wskaźnik wskazuje miejsce, gdzie zapisana jest jakaś informacja (np. zmienna typu liczbowego czy struktura).

Obrazowo możemy wyobrazić sobie pamięć komputera jako bibliotekę a zmienne jako książki. Zamiast brać książkę z półki samemu (analogicznie do korzystania wprost ze zwykłych zmiennych), możemy podać bibliotekarzowi wypisany rewers z numerem katalogowym książki a on znajdzie ją za nas. Analogia ta nie jest doskonała, ale pozwala wyobrazić sobie niektóre cechy wskaźników: numer na rewersie identyfikuje pewną książkę, kilka rewersów może dotyczyć tej samej książki, numer w rewersie możemy skreślić i użyć go do zamówienia innej książki, a jeśli wpiszemy nieprawidłowy numer, to możemy dostać nie tę książkę, którą chcemy, albo też nie dostać nic.

Warto też przytoczyć w tym miejscu definicję adresu pamięci. Możemy powiedzieć, że adres to pewna liczba całkowita, jednoznacznie definiująca położenie pewnego obiektu w pamięci komputera. Tymi obiektami mogą być np. zmienne, elementy tablic czy nawet funkcje. Dokładniejszą definicję możesz znaleźć w Wikipedii.

Podstawy wskaźników

symbol	znaczenie	użycie
*	weź wartość x	*x
*	deklaracja wskaźnika do wartości	int *x;
&	weź adres	&x

Kiedy korzystać ze wskaźników ?

• listy

Jak dokumentować użycie wskaźników ?

Grafika Unicode

  ┌─head─┐     ┌──value──┐       ┌──value──┐
  │   ├───────►│    4    │       │    0    │
  └──────┘     ├───next──┤       ├───next──┤
               │    ├───────────►│   NULL  │
               └─────────┘       └─────────┘

Operowanie na wskaźnikach

By stworzyć wskaźnik do zmiennej i móc się nim posługiwać, należy przypisać mu odpowiednią wartość - adres obiektu, na jaki chcieliśmy aby wskazywał. Skąd mamy znać ten adres? W języku C możemy "zapytać się" o adres za pomocą operatora & (operatora pobrania adresu). Przeanalizuj następujący kod:

 #include <stdio.h>
 
 int main (void)
 {
   int liczba = 80;
   printf("Wartość zmiennej liczba: %d\n", liczba );
   printf("Adres zmiennej liczba: %p\n", &liczba );
   return 0;
 }

Program ten wypisuje adres pamięci, pod którym znajduje się zmienna oraz wartość jaką kryje zmienna przechowywana pod owym adresem. Przykładowy wynik:

Wartość zmiennej liczba: 80
Adres zmiennej liczba: 0022FF74

Aby móc przechowywać taki adres, zadeklarujemy zmienną wskaźnikową. Ważną informacją, oprócz samego adresu wskazywanej zmiennej, jest typ wskazywanej zmiennej. Mimo że wskaźnik jest zawsze typu adresowego, kompilator wymaga od nas, abyśmy przy deklaracji podali typ zmiennej, na którą wskaźnik będzie wskazywał. Robi się to poprzez dodanie * (gwiazdki) przed nazwą wskaźnika, np.:

 int *wskaznik1;    // zmienna wskaźnikowa na obiekt typu liczba całkowita
 char *wskaznik2;    // zmienna wskaźnikowa na obiekt typu znak
 float *wskaznik3;    // zmienna wskaźnikowa na obiekt typu liczba zmiennoprzecinkowa

Niektórzy programiści mogą nieco błędnie interpretować wskaźnik do typu jako nowy typ i uważać, że jeśli napiszą:

 int * a,b,c;

to otrzymają trzy wskaźniki do liczby całkowitej. W rzeczywistości uzyskamy jednak tylko jeden wskaźnik a, oraz dwie liczby całkowite b i c (tak jakbyśmy napisali int *a; int b, int c). W tym przypadku trzy wskaźniki otrzymamy pisząc:

 int *a,*b,*c;

Aby uniknąć pomyłek, lepiej jest pisać gwiazdkę tuż przy zmiennej, albo jeszcze lepiej - nie mieszać deklaracji wskaźników i zmiennych:

 int *a;
 int b,c;

Dostęp do wskazywanego obiektu

Aby dobrać się do wartości wskazywanej przez wskaźnik, należy użyć unarnego operatora * (gwiazdka), zwanego operatorem wyłuskania. Mimo, że kolejny raz używamy gwiazdki, oznacza ona teraz coś zupełnie innego. Jest tak, ponieważ używamy jej w zupełnie innym miejscu: nie przy deklaracji zmiennej (gdzie gwiazdka oznacza deklarowanie wskaźnika), a przy wykorzystaniu zmiennej, gdzie odgrywa rolę operatora, podobnie jak operator & (pobrania adresu obiektu). Program ilustrujący:

 #include <stdio.h>
 
 int main (void)
 {
   int liczba = 80;
   int *wskaznik = &liczba;   // wskaznik przechowuje adres, ktory pobieramy od zmiennej liczba

   printf("Wartosc zmiennej: %d, jej adres: %p.\n", liczba, &liczba);
   printf("Adres przechowywany we wskazniku: %p, wskazywana wartosc: %d.\n",
          wskaznik, *wskaznik);
 
   *wskaznik = 42;   // zapisanie liczby 42 do obiektu, na który wskazuje wskaznik
   printf("Wartosc zmiennej: %d, wartosc wskazywana przez wskaznik: %d\n",
          liczba, *wskaznik);
 
   liczba = 0x42;  // liczba podana w systemie szesnastkowym, podana po prefiksie 0x
   printf("Wartosc zmiennej: %d, wartosc wskazywana przez wskaznik: %d\n",
          liczba, *wskaznik);
 
   return 0;
 }

Przykładowy wynik programu:

Wartosc zmiennej: 80, jej adres: 0022FF74.
Adres przechowywany we wskazniku: 0022FF74, wskazywana wartosc: 80.
Wartosc zmiennej: 42, wartosc wskazywana przez wskaznik: 42
Wartosc zmiennej: 66, wartosc wskazywana przez wskaznik: 66

Gdy argument jest wskaźnikiem...

Czasami zdarza się, że argumentami funkcji są wskaźniki. W przypadku zwykłych zmiennych, nasza funkcja otrzymuje jedynie lokalne kopie argumentów, które zostały jej podane. Wszelkie zmiany dokonują się lokalnie i nie są widziane poza funkcją. Przekazując do funkcji wskaźnik, również zostaje stworzona kopia... wskaźnika, na którym możemy operować. Tu jednak kopiowanie i niewidoczne lokalne zmiany się kończą. Obiekt, na który wskazuje ten wskaźnik, znajduje się gdzieś w pamięci i możemy na nim działać (czyli na oryginale), tak więc zmiany te są widoczne po wyjściu z funkcji. Spróbujmy rozpatrzyć poniższy przykład:

 #include <stdio.h>
 
 void func_var (int zmienna)
 {
   zmienna = 4;
 }
 void func_pointer (int *zmienna)
 {
   (*zmienna) = 5;
 }

 int main (void)
 {
   int z=3;
   printf ("z= %d\n", z);

   func_var (z);
   printf ("z= %d\n", z);

   func_pointer (&z);
   printf ("z= %d\n", z);

   return 0;
 }

Wynikiem będzie:

z= 3
z= 3
z= 5

Widzimy, że funkcje w języku C nie tylko potrafią zwracać określoną wartość, lecz także zmieniać dane, podane im jako argumenty. Ten sposób przekazywania argumentów do funkcji jest nazywany przekazywaniem przez wskaźnik (w przeciwieństwie do normalnego przekazywania przez wartość).

Pułapki wskaźników

Ważne jest, aby przy posługiwaniu się wskaźnikami nigdy nie próbować odwoływać się do komórki wskazywanej przez wskaźnik o wartości NULL ani nie używać niezainicjowanego wskaźnika! Przykładem nieprawidłowego kodu może być np.:

 int *wsk;
 printf ("zawartosc komorki: %d\n", *(wsk));   /* Błąd */
 wsk = NULL;
 printf ("zawartosc komorki: %d\n", *(wsk));   /* Błąd */

Pamiętaj też, że możesz być rozczarowany używając operatora sizeof, podając zmienną wskaźnikową. Uzyskana wielkość będzie oznaczała rozmiar adresu, a nie rozmiar typu użytego podczas deklarowania naszego wskaźnika. Wielkość ta będzie zawsze miała taki sam rozmiar dla każdego wskaźnika, w zależności od kompilatora, a także docelowej platformy. Zamiast tego używaj: sizeof(*wskaźnik). Przykład:

  char *zmienna;
  int z = sizeof zmienna; /* z może być równe 4 (rozmiar adresu na maszynie 32bit) */
  z = sizeof(char*);      /* robimy to samo, co wyżej */
  z = sizeof *zmienna;    /* tym razem z= rozmiar znaku, tj. 1 */
  z = sizeof(char);       /* robimy to samo, co wyżej */

Stałe wskaźniki

Podobnie jak możemy deklarować zwykłe stałe, tak samo możemy mieć stałe wskaźniki - jednak są ich dwa rodzaje. Wskaźniki na stałą wartość:

 const int *a;
 int const * a;  /* równoważnie */

oraz stałe wskaźniki:

 int * const b;

Słówko const przed typem działa jak w przypadku zwykłych stałych, tzn. nie możemy zmienić wartości wskazywanej przy pomocy wskaźnika.

W drugim przypadku słowo const jest tuż za gwiazdką oznaczającą typ wskaźnikowy, co skutkuje stworzeniem stałego wskaźnika, czyli takiego którego nie można przestawić na inny adres.

Obie opcje można połączyć, deklarując stały wskaźnik, którym nie można zmienić wartości wskazywanej zmiennej, i również można zrobić to na dwa sposoby:

 const int * const c;
 int const * const c;  /* równoważnie  */

 int i=0;
 const int *a=&i;
 int * const b=&i;
 int const * const c=&i;
 *a = 1;  /* kompilator zaprotestuje */
 *b = 2;  /* ok */
 *c = 3;   /* kompilator zaprotestuje */
 a = b;   /* ok */
 b = a;   /* kompilator zaprotestuje */
 c = a;   /* kompilator zaprotestuje */

Wskaźniki na stałą wartość są przydatne między innymi w sytuacji gdy mamy duży obiekt (na przykład strukturę z kilkoma polami). Jeśli przypiszemy taką zmienną do innej zmiennej, kopiowanie może potrwać dużo czasu, a oprócz tego zostanie zajęte dużo pamięci. Przekazanie takiej struktury do funkcji albo zwrócenie jej jako wartość funkcji wiąże się z takim samym narzutem. W takim wypadku dobrze jest użyć wskaźnika na stałą wartość.

 void funkcja(const duza_struktura *ds)
 {
    /* czytamy z ds i wykonujemy obliczenia */
 }
 ....
 funkcja(&dane); /* mamy pewność, że zmienna dane nie zostanie zmieniona */

Dynamiczna alokacja pamięci - tablice dynamiczne

Mając styczność z tablicami można się zastanowić, czy nie dałoby się mieć tablic, których rozmiar dostosowuje się do naszych potrzeb a nie jest na stałe zaszyty w kodzie programu. Chcąc pomieścić więcej danych możemy po prostu zwiększyć rozmiar tablicy - ale gdy do przechowania będzie mniej elementów okaże się, że marnujemy pamięć. Język C umożliwia dzięki wskaźnikom i dynamicznej alokacji pamięci tworzenie tablic takiej wielkości, jakiej akurat potrzebujemy.

O co chodzi

Pamięć w C

Czym jest dynamiczna alokacja pamięci? Normalnie zmienne programu przechowywane są na tzw. stosie (ang. stack) - powstają, gdy program wchodzi do bloku, w którym zmienne są zadeklarowane a zwalniane w momencie, kiedy program opuszcza ten blok. Jeśli deklarujemy tak tablice, to ich rozmiar musi być znany w momencie kompilacji - żeby kompilator wygenerował kod rezerwujący odpowiednią ilość pamięci.

Dostępny jest jednak drugi rodzaj rezerwacji (czyli alokacji) pamięci. Jest to alokacja na stercie (ang. heap). Sterta to obszar pamięci wspólny dla całego programu, przechowywane są w nim zmienne, których czas życia nie jest związany z poszczególnymi blokami. Musimy sami rezerwować dla nich miejsce i to miejsce zwalniać, ale dzięki temu możemy to zrobić w dowolnym momencie działania programu.

Należy pamiętać, że rezerwowanie i zwalnianie pamięci na stercie zajmuje więcej czasu niż analogiczne działania na stosie. Dodatkowo, zmienna zajmuje na stercie więcej miejsca niż na stosie - sterta utrzymuje specjalną strukturę, w której trzymane są wolne partie (może to być np. lista). Tak więc używajmy dynamicznej alokacji tam, gdzie jest potrzebna - dla danych, których rozmiaru nie jesteśmy w stanie przewidzieć na etapie kompilacji lub ich żywotność ma być niezwiązana z blokiem, w którym zostały zaalokowane.

Obsługa pamięci

Podstawową funkcją do rezerwacji pamięci jest funkcja malloc. Jest to niezbyt skomplikowana funkcja - podając jej rozmiar (w bajtach) potrzebnej pamięci, dostajemy wskaźnik do zaalokowanego obszaru.

Załóżmy, że chcemy stworzyć tablicę liczb typu float:

 //Pamietaj aby dodac na poczatku biblioteke stdlib.h!

 int rozmiar;
 float *tablica;
 
 rozmiar = 3;
 tablica = (float*) malloc(rozmiar * sizeof(*tablica)); //pierwsza gwiazdka (*) w funkcji malloc() to operator mnozenia
 tablica[0] = 0.1;

Przeanalizujmy teraz po kolei, co dzieje się w powyższym fragmencie. Najpierw deklarujemy zmienne - rozmiar tablicy i wskaźnik, który będzie wskazywał obszar w pamięci, gdzie będzie trzymana tablica. Do zmiennej "rozmiar" możemy w trakcie działania programu przypisać cokolwiek - wczytać ją z pliku, z klawiatury, obliczyć, wylosować - nie jest to istotne. rozmiar * sizeof(*tablica) oblicza potrzebną wielkość tablicy. Dla każdej zmiennej float potrzebujemy tyle bajtów, ile zajmuje ten typ danych. Ponieważ może się to różnić na rozmaitych maszynach, istnieje operator sizeof, zwracający dla danego wyrażenia rozmiar jego typu w bajtach.

W wielu książkach (również K&Rv2) i w Internecie stosuje się inny schemat użycia funkcji malloc a mianowicie: tablica = (float*)malloc(rozmiar * sizeof(float)). Takie użycie należy traktować jako błędne, gdyż nie sprzyja ono poprawnemu wykrywaniu błędów.

Rozważmy sytuację, gdy programista zapomni dodać plik nagłówkowy stdlib.h, wówczas kompilator (z braku deklaracji funkcji malloc) przyjmie, że zwraca ona typ int, zatem do zmiennej tablica (która jest wskaźnikiem) będzie przypisywana liczba całkowita, co od razu spowoduje błąd kompilacji (a przynajmniej ostrzeżenie), dzięki czemu będzie można szybko poprawić kod programu. Rzutowanie jest konieczne tylko w języku C++, gdzie konwersja z void* na inne typy wskaźnikowe nie jest domyślna, ale język ten oferuje nowe sposoby alokacji pamięci.

Teraz rozważmy sytuację, gdy zdecydujemy się zwiększyć dokładność obliczeń i zamiast typu float użyć typu double. Będziemy musieli wyszukać wszystkie wywołania funkcji malloc, calloc i realloc odnoszące się do naszej tablicy i zmieniać wszędzie sizeof(float) na sizeof(double). Aby temu zapobiec lepiej od razu użyć sizeof(*tablica), wówczas zmiana typu zmiennej tablica na double* zostanie od razu uwzględniona przy alokacji pamięci.

Dodatkowo, należy sprawdzić, czy funkcja malloc nie zwróciła wartości NULL - dzieje się tak, gdy zabrakło pamięci. Ale uwaga: może się tak stać również jeżeli jako argument funkcji podano zero.

Jeśli dany obszar pamięci nie będzie już nam więcej potrzebny powinniśmy go zwolnić, aby system operacyjny mógł go przydzielić innym potrzebującym procesom.

Do zwolnienia obszaru pamięci używamy funkcji free(), która przyjmuje tylko jeden argument - wskaźnik, który otrzymaliśmy w wyniku działania funkcji malloc().

 free (tablica);

Należy też uważać, by nie zwalniać dwa razy tego samego miejsca. Po wywołaniu free wskaźnik nie zmienia wartości, pamięć wskazywana przez niego może też nie od razu ulec zmianie. Czasem możemy więc korzystać ze wskaźnika (zwłaszcza czytać) po wywołaniu free nie orientując się, że robimy coś źle - i w pewnym momencie dostać komunikat o nieprawidłowym dostępie do pamięci. Z tego powodu zaraz po wywołaniu funkcji free można przypisać wskaźnikowi wartość 0.

Czasami możemy potrzebować zmienić rozmiar już przydzielonego bloku pamięci. Tu z pomocą przychodzi funkcja realloc:

 tablica = realloc(tablica, 2*rozmiar*sizeof(*tablica));

Funkcja ta zwraca wskaźnik do bloku pamięci o pożądanej wielkości (lub NULL gdy zabrakło pamięci). Uwaga - może to być inny wskaźnik. Jeśli zażądamy zwiększenia rozmiaru a za zaalokowanym aktualnie obszarem nie będzie wystarczająco dużo wolnego miejsca, funkcja znajdzie nowe miejsce i przekopiuje tam starą zawartość. Jak widać, wywołanie tej funkcji może być więc kosztowne pod względem czasu.

Ostatnią funkcją jest funkcja calloc(). Przyjmuje ona dwa argumenty: liczbę elementów tablicy oraz wielkość pojedynczego elementu. Podstawową różnicą pomiędzy funkcjami malloc() i calloc() jest to, że ta druga zeruje wartość przydzielonej pamięci (do wszystkich bajtów wpisuje wartość 0).

Przykład tworzenia tablicy typu float przy użyciu calloc() zamiast malloc():

 int rozmiar;
 float *tablica;
 
 rozmiar = 3;
 tablica = (float*) calloc(rozmiar, sizeof (*tablica));
 tablica[0] = 0.1;

Inicjalizacja dynamicznej tablicy

  memset (data, 0.0f , sizeof (float ) * rozmiar);

dynamicze tablice wielowymiarowe VLA

Od C99, C ma tablice 2D z dynamicznymi wymiarami, czyli mogą teraz być wyrażeniem (ang. a run-time expression ) . Takie tablice nazywane są tablicami o zmiennej długości (ang. Variable Length Arrays, VLA) mogą uprościć zarządzanie pamięcią masową w programie i umożliwić użycie normalnej notacji tablicowej, nawet jeśli problem do rozwiązania wymaga, aby tablice miały różne rozmiary w różnym czasie.

Oba wymiary takie same:

double (*A)[n] = malloc(sizeof(double[n][n]));
free(a);

różne wymiary

double (*a)[y] = malloc(sizeof(double[x][y])); // 2D
double (*a)[y][z] = malloc(sizeof(double[x][y][z])); // 3D

/*
 https://stackoverflow.com/questions/365782/how-do-i-best-handle-dynamic-multi-dimensional-arrays-in-c-c


gcc a.c -Wall -Wextra
./a.out


*/

#include <stdio.h> // printf
#include <stdlib.h> // malloc



void manipulate(int rows, int cols, int (*data)[cols]) {
    for(int i=0; i < rows; i++) {
        for(int j=0; j < cols; j++) {
            printf("%d ", data[i][j]);       
        }
        printf("\n");
    }
}

int main(void) {
    int rows = 10;
    int cols = 9;
    int (*data)[cols] = malloc(rows*sizeof(*data));
    
    manipulate(rows, cols, data);
    
    free(data);
}

Możliwe deklaracje wskaźników

Tutaj znajduje się krótkie kompendium jak definiować wskaźniki oraz co oznaczają poszczególne definicje:

int i;         /* zmienna całkowita (typu int) 'i' */
int *p;        /* wskaźnik 'p' wskazujący na zmienną całkowitą */
int a[];       /* tablica 'a' liczb całkowitych typu int */
int f();       /* funkcja 'f' zwracająca liczbę całkowitą typu int */
int **pp;      /* wskaźnik 'pp' wskazujący na wskaźnik wskazujący na liczbę całkowitą typu int */
int (*pa)[];   /* wskaźnik 'pa' wskazujący na tablicę liczb całkowitych typu int */
int (*pf)();   /* wskaźnik 'pf' wskazujący na funkcję zwracającą liczbę całkowitą typu int */
int *ap[];     /* tablica 'ap' wskaźników na liczby całkowite typu int */
int *fp();     /* funkcja 'fp', która zwraca wskaźnik na zmienną typu int */
int ***ppp;    /* wskaźnik 'ppp' wskazujący na wskaźnik wskazujący na wskaźnik wskazujący na liczbę  typu int */
int (**ppa)[]; /* wskaźnik 'ppa' wskazujący na wskaźnik wskazujący na tablicę liczb całkowitych typu int */
int (**ppf)(); /* wskaźnik 'ppf' wskazujący na wskaźnik funkcji zwracającej dane typu int */
int *(*pap)[]; /* wskaźnik 'pap' wskazujący na tablicę wskaźników na typ int */
int *(*pfp)(); /* wskaźnik 'pfp' na funkcję zwracającą wskaźnik na typ int*/
int **app[];   /* tablica wskaźników 'app' wskazujących na wskaźniki wskazujące na typ int */
int (*apa[])[];/* tablica wskaźników 'apa' wskazujących na tablicę liczb całkowitych typu int */
int (*apf[])();/* tablica wskaźników 'apf' na funkcje, które zwracają typ int */
int **fpp();   /* funkcja 'fpp', która zwraca wskaźnik na wskaźnik, który wskazuje typ int */
int (*fpa())[];/* funkcja 'fpa', która zwraca wskaźnik na tablicę liczb typu int */
int (*fpf())();/* funkcja 'fpf', która zwraca wskaźnik na funkcję, która zwraca dane typu int */

Popularne błędy

Jednym z najczęstszych błędów, oprócz prób wykonania operacji na wskaźniku NULL, są odwołania się do obszaru pamięci po jego zwolnieniu. Po wykonaniu funkcji free() nie możemy już wykonywać żadnych odwołań do zwolnionego obszaru. Innymi rodzajami błędów są:

1. odwołania do adresów pamięci, które są poza obszarem przydzielonym funkcją malloc() i stosem;
2. brak sprawdzania, czy dany wskaźnik nie ma wartości NULL;
3. wycieki pamięci, czyli gubienie wskaźników do zaalokowanej pamięci i w konsekwencji niezwalnianie całej, przydzielonej wcześniej pamięci;
4. odwołania do obszarów w których nie ma prawidłowych danych (np. poprzez rzutowanie wskaźnika na nieodpowiedni typ).

Wycieki pamięci

Wyciek pamięci ( ang. memory leak)

Przykład funkcji powodującej wyciek pamięci (tworzy wskaźnik, przydziela pamięć i nie zwalnia pamięci po zakończeniu funkcji):

/* 
 Function with memory leak 
 http://www.geeksforgeeks.org/what-is-memory-leak-how-can-we-avoid/
*/
#include <stdlib.h>
 
int main()
{
   int *ptr = (int *) malloc(sizeof(int));
 
   /* Do some work */
 
   return 0 ; /* Return without freeing ptr*/
}

Sprawdzamy za pomocą Valgrinda

 valgrind --leak-check=full ./a.out
==3382== Memcheck, a memory error detector
==3382== Copyright (C) 2002-2012, and GNU GPL'd, by Julian Seward et al.
==3382== Using Valgrind-3.8.1 and LibVEX; rerun with -h for copyright info
==3382== Command: ./a.out
==3382== 
==3382== 
==3382== HEAP SUMMARY:
==3382==     in use at exit: 4 bytes in 1 blocks
==3382==   total heap usage: 1 allocs, 0 frees, 4 bytes allocated
==3382== 
==3382== 4 bytes in 1 blocks are definitely lost in loss record 1 of 1
==3382==    at 0x4C2A2DB: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==3382==    by 0x40053E: main (l.c:13)
==3382== 
==3382== LEAK SUMMARY:
==3382==    definitely lost: 4 bytes in 1 blocks
==3382==    indirectly lost: 0 bytes in 0 blocks
==3382==      possibly lost: 0 bytes in 0 blocks
==3382==    still reachable: 0 bytes in 0 blocks
==3382==         suppressed: 0 bytes in 0 blocks
==3382== 
==3382== For counts of detected and suppressed errors, rerun with: -v
==3382== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 2 from 2)

Powinno być:

/* 
Function without memory leak
http://www.geeksforgeeks.org/what-is-memory-leak-how-can-we-avoid/
 */
#include <stdlib.h>;
 
int main()
{
   int *ptr = (int *) malloc(sizeof(int));
 
   /* Do some work */
 
   free(ptr);
   return 0;
}

valgrind --leak-check=full ./a.out
==3397== Memcheck, a memory error detector
==3397== Copyright (C) 2002-2012, and GNU GPL'd, by Julian Seward et al.
==3397== Using Valgrind-3.8.1 and LibVEX; rerun with -h for copyright info
==3397== Command: ./a.out
==3397== 
==3397== 
==3397== HEAP SUMMARY:
==3397==     in use at exit: 0 bytes in 0 blocks
==3397==   total heap usage: 1 allocs, 1 frees, 4 bytes allocated
==3397== 
==3397== All heap blocks were freed -- no leaks are possible
==3397== 
==3397== For counts of detected and suppressed errors, rerun with: -v
==3397== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 2 from 2)

Inne przykłady:.

Do znajdowania wycieków pamięci możemy użyć programów:

• Valgrind

Zobacz też

• Więcej o wskaźnikach
• Pamięć z punktu widzenia programowania
• Wojciech Myszka: jezyk-c-dynamiczne-tablice-dwuwymiarowe-i-funkcje
• test wiedzy o wskaźnikach
• so_you_think_you_know_c ? by Oleksandr Kaleniuk
• Pointer to Pointer and Reference to Pointer
• Pointers by steveb at codeproject
• libcsptr Smart pointers for the (GNU) C programming language