KURS C/C++ WYKŁAD 6

KURS C/C++
WYKŁAD 6
Wskaźniki
Każda zmienna ma unikalny adres wskazujący początkowy obszar pamięci zajmowany przez
tą zmienną. Ilość pamięci zajmowanej przez zmienną zależy od typu zmiennej.
Adres można przechowywać, zmienna która przechowuje adres do obiektu nazywa się
wskaźnikiem.
Wskaźniki deklarujemy używając następującej składni:
typ_zmiennej *nazwa_zmiennej
Operator * informuje nas, że mamy do czynienia ze wskaźnikiem.
Wskaźnik nazywa się tak jak zmienna.
float pi = 3.14;
float *wsk;
wsk = π
float *wsk; - wsk � przechowuje adres
zmiennej typu float
float pi = 3.14;
wsk=π
pi = 3.14
&pi � adres zmiennej pi
printf("pi = %f", pi);
EKRAN: pi = 3.14
wsk = FFF0
wsk � przechowuje adres zmiennej pi
printf("adres zmiennej pi = %p", wsk);
EKRAN: adres zmiennej pi = FFF0;
Przykłady:
char *wsk; - wsk jest wskaźnikiem do pokazywania na obiekty typu char
int *wsk;
- wsk jest wskaźnikiem do pokazywania na obiekty typu int
float *wsk; - wsk jest wskaźnikiem do pokazywania na obiekty typu float
void *wsk; - wsk jest wskaźnikiem do pokazywania na obiektu nieznanego typu
float *wsk_tab[10];
- tablica 10 wskaźników do liczb rzeczywistych
float (*wsk_tab)[10];
- wskaźnik do tablicy 10 liczb rzeczywistych
Treścią wskaźnika jest informacja, gdzie wskazany obiekt się znajduje.
Przed użyciem musimy wskaźnikowi nadać wartość początkową, czyli przypisać go do
konkretnego obiektu.
Do inicjowania wskaźnika może służyć operator adresu & i może być stosowany tylko do
obiektów zajmujących pamięć: zmienne, elementy tablic. Nie można go stosować do wyrażeń
stałych i zmiennych typu register.
int *wsk;
int *wsk;
float a;
int i;
wsk = &a; //nieprawidłowo.
wsk = &i; //prawidłowo.
Chcemy wskaźnikiem do int pokazywać na float
Kiedy wskaźnik pokazuje już na konkretnie miejsce możemy odnieść się do tego obiektu na
który on wskazuje, odczytać jego wartość, lub wpisać wartość pod wskazany adres.
Podstawową operacją na wskaźniku jest wyłuskanie, czyli odwołanie się do obiektu
wskazywanego przez wskaźnik. Operacja ta nazywa się adresowaniem pośrednim.
Operatorem adresowania pośredniego jest jednoargumentowa * zapisywana jako przedrostek.
Zastosowana do wskaźnika daje zawartość obiektu wskazanego przez ten wskaźnik np.:
int *wsk ;
int j, i=3;
wsk = &i;
wsk przechowuje adres zmiennej i.
cout<<"wartość zmiennej i wynosi "<<*wsk;
Ekran: wartość zmiennej i wynosi 3
int i, j;
int *wsk;
i=3;
wsk=&i;
j =*wsk;
=*wsk - pobierz wartość spod adresu
(1)
j =*wsk - pobranie wartości spod adresu i przypisanie tej wartośći zmiennej j
po wykonaniu intsrukcji (1) j=3;
(2)
*wsk = 200; // wstaw wartość 200 pod adres wskazywany przez zmienną wsk
po wykonaniu intsrukcji (2) i = 200;
Zmieni się wartość zmiennej i z 3 na 200.
Jeśli wsk wskazuje na zmienną całkowitą, to *wsk może wystąpić wszędzie tam gdzie może
wystąpić zmienna, np:
int *wsk, x, zm;
zm=10;
wsk = &zm;
zm=zm+2;
//zm=12
zm=10;
*wsk = *wsk + 2; // zm = 12;
x = *wsk + 1;
//x=13;
Ponieważ operatory * oraz & są silniejsze niż operatory arytmetyczne, to dla wyrażeń:
*wsk = *wsk + 2;
x = *wsk + 1;
najpierw pobierana jest zawartość spod adresu wsk i zwiększona o 1 zostaje przypisana
zmiennej x.
int i, j;
int *wsk=&i, *wsk1;
wsk1 = wsk;
Zapis ten mówi, że teraz wsk będzie wskazywał na to samo co wsk1, czyli na zmienną i.
wsk=wsk+1; wskaźnik zostaje powiększony o rozmiar typu obiektu na który wskazuje, w naszym
przypadku o sizeof (int) (czyli o dwa bajty) ponieważ wskazuje na obiekt typu int.
wsk=wsk+1; lub wsk++;
Wskaźniki a tablice
W C++ wskażniki i tablice są ze sobą ścisle związane. Nazwa tablicy może byc używana jako
wskaźnik do jej pierwszego elementu.
Zadeklarujemy wskaźnik i tablicę:
int *wsk;
int tab[10];
instrukcja: wsk = &tab[n];
ustawia wskaźnik na n-tym elemencie tablicy. Typ wskaźnika musi się zgadzać z typem tablicy.
instrukcja: wsk = &tab[0]; jest równoważna instrukcji: wsk = tab;
i oznacza ustawienie wskaźnika na pierwszy element tablicy czyli na jej początek. Zapisy są
równoważne, ponieważ jak już wspomnieliśmy, nazwa tablicy stanowi adres jej zerowego
elementu.
int *wsk;
int tab[4]={-1,-20, 3, 5};
wsk = tab;
2000
2002
2004
2006
tab:
-1
-20
3
5
wsk
wsk +1
wsk +2
wsk +3
cout<<*wsk << " to wyświetlenie wartości tab[0]\n";
cout<<*(wsk+1) << " to wyświetlwnie wartości tab[1]\n";
cout<<*(wsk+2) << " to wyświetlwnie wartości tab[2]\n";
cout<<wsk[0]<< "\n"<<wsk[1] <<"\n"<<wsk[2];
Możemy również zmieniać adres dodając do wskaźnika liczbę całkowitą.
Przejście do następnego elementu tablicy umożliwia instrukcja :
wsk= wsk + 1; lub wsk ++; //gubimy adres początkowy
Aby przesunąć się o n elementów w tablicy piszemy
instrukcja: wsk = wsk+n;
Z definicji wskaźnika wynika że wsk jest wskaźnikiem do int. Stąd kompilator wnioskuje, że
aby odnaleźć następny element typu int należy przesunąć się o sizeof (int).
cout<<*wsk << "to wyświetlwnie wartości tab[0]";
wsk++;
//wsk=wsk+1;
cout<<*wsk<<�\n�<< "to wyświetlwnie wartości tab[1]";
wsk++; //wsk=wsk+2;
cout<<*wsk<<�\n�<< "to wyświetlwnie wartości tab[2]";
int *wsk;
int tab[10]={1, 3, 5, 6, 7, 8, 9}, i;
wsk = tab;
//inicjowanie wskaźnika
for(i = 0; i<10; i++) printf("%d\n", *wsk++);
Uwaga!!!
Mimo, że możemy zapisać:
wsk = tab;
to o ile możemy zapisać:
wsk++;
to nie możemy napisać:
tab++;
Różnicą między wskaźnikiem a nazwą tablicy jest taka, że na wskaźniku możemy dokonywać
operacji arytmetycznych, a na adresie tablicy nie, jest ona traktowana jak wielkość stała.
Dla tak zadeklarowanego wskaźnika:
int *wsk;
adresem tego wskaźnika jest wartość wyrażenia:
&wsk;
Wskaźnik void
Deklaracja wskaźnika niesie w sobie dwie informacje: adres miejsca w pamięci, oraz typ obiektu na
który te adres wskazuje.
Przy deklaracji
void *wsk;
wskaźnik wsk wskazuje jedynie na konkretne miejsce w pamięci nie informując o typie obiektów
tam przechowywanych.
void *adres;
char *wsk;
int *wsk1;
//inicjalizowanie zmiennych wsk i wsk1.
.................................
adres = wsk; //lub adres = wsk1;
Zapisy te oznaczają, że teraz wskaźnik typu void wskazuje na to samo, na co wskazuje
wskaźnik typu char //int.
Wskaźnik każdego typu można przypisać wskaźnikowi typu void, bez konieczności konwersji.
Odwrotne przypisanie wymaga stosowania operatora konwersji.
float *wsk;
void *wsk1;
....................
wsk = wsk1;
//błąd
wsk = (float *) wsk1; //poprawnie z operatorem rzutowania
Arytmetyka wskaźników
1. Możemy dodawać i odejmować liczby całkowite od wskaźników tak, aby w potrzebny sposób
przesuwać je po tablicy. Operacje te nie są sprawdzane przez kompilator, i możemy przesunąć
wskaźnik poza zadeklarowany obszar tablicy i zniszczyć istniejące dane. Takie błędy są trudne
do wykrycia.
int *wsk;
int tab[4]={-1,-20, 3, 5};
wsk = tab;
wsk=wsk+10; lub wsk=wsk-10;
co najwyżej wsk=wsk+3 lub wsk=wsk-3
2. Możemy odjąć dwa wskaźniki od siebie:
wsk_a - wsk_b
Gdy pokazują one na różne elementy tej samej tablicy to wynikiem takiej operacji jest liczba
dzielących je elementów. Liczba może być ze znakiem - lub +.
int tab[12], *wsk;
wsk= &tab[0] � &tab[2]; //wsk = -2
3. Wskaźniki można ze sobą porównać. Do tego celu służą nam operatory:
==
!= < > <= >=
Dla dwóch wskaźników:
int *wsk1, *wsk2;
przypisanie:
wsk1 = wsk2 oznacza, że wskazują one na ten sam obiekt.
if (wsk1 = = wsk2)
cout<<"Oba wskaźniki pokazują na ten sam obiekt";
Jeśli wskaźniki wskazują na elementy tej samej tablicy, to wyrażenie wsk1 < wsk2
że wsk1 wskazuje na element tablicy o mniejszym indeksie.
4. Każdy wskaźnik można porównać z adresem 0 zwanym NULL. Takie ustawienie
wsk = 0;
oznacza,
wskaźnika:
//lub wsk = NULL
informuje, że wskaźnik nie pokazuje na nic konkretnego, niektóre funkcje biblioteczne
zwracają wskaźnik NULL (null pointer), możemy go użyć do kontroli np:
if (wsk = = 0)
if(wsk = =NULL)
if(!wsk)
Inicjowanie wskaźników
W tym punkcie zbierzemy wszystkie sposoby inicjowania wskaźników:
1. można przypisać adres konkretnego obiektu:
int *wsk, obiekt, tab[12];
wsk = &obiekt;
wsk = tab;
// wsk = &tab[0]; wsk = &tab[2];
2. zarezerwować obszar dynamicznie
char *wsk;
wsk = new char[12];
wsk = (char*) malloc (12 * sizeof (char));
3. można przypisać inny wskaźnik:
int *wsk, *ptr;
wsk = new int;
ptr = wsk;
4. ustawić wskaźnik na konkretny
wsk = FFDA
Dynamiczna alokacja pamięci
Stajemy więc przed problemem, jak tworzyć tymczasowe obiekty tak, i gdy nie będą potrzebne
pozbyć się ich z pamięci.Odpowiedź jest prosta - rezerwować pamięć.
W języku C pamięć dostępna dla programu w czasie jego uruchomienia nazywa się HEAP'em, w
C++ - FREE STORE- pamięć wolna. Różnica leży tylko w funkcjach używanych do dostępu do tej
pamięci.
Funkcje alokacji pamięci: malloc(...), calloc(...)
W języku C, do alokacji pamięci służy grupa funkcji malloc.
void *malloc (size_t size);
typedef unsigned size_t
Przydziela w obszarze stosu zmiennych dynamicznych obszar o rozmiarze size i zwraca
wskaźnik do n bajtów niezainicjowanej pamięci, lub NULL jeśli żądanie nie może być spełnione.
void *calloc (size_t n, size_t size);
Przydziela w obszarze stosu zmiennych dynamicznych obszar o rozmiarze
pamięć nie może być przydzielona. Pamięć inicjowana jest zerami.
size n*size oraz zwraca NULL, gdy
char *wsk = (char*) malloc (100 * sizeof (char));
char *ptr = (char*) calloc (100, sizeof (char));
Funkcje zwalniania pamięci: free(...)
Po wykorzystaniu pamięci można ją zwolnić. Do tego celu służy funkcja free().
void free ( void *p);
free (ptr); free (wsk);
zwalnia pamięć wskazaną przez p, przy czym p musi być wynikiem wcześniejszego wywołania
funkcji malloc() lub calloc(). Nie ma ograniczeń na kolejność zwalniania pamięci, natomiast
poważnym błędem jest zwalnianie czegoś, co nie było poprzednio przydzielone w/w funkcjami.
W języku C możemy korzystać z jednego z 6 standardowych modeli pamięci: tiny, small,
medium,compact, large, huge które różnią się min. ilością pamięci przeznaczonej na dane. Dla
modelu compact, large i huge, gdzie pamięć na dane jest ponad 64 kB, funkcja malloc zamieniana
jest na funkcję farmalloc, farfree operujące na pamięci o długości ponad 1 segment.
Operatory new i delete.
Alternatywą do tych funkcji w języku C++ jest operator new i delete. Operator new tworzy
obiekt, a operator delete usuwa obiekt z pamięci. Jeśli zdefiniujemy wskaźnik:
char *wsk;
Alokacja pamięci.
wsk = new char;
powoduje utworzenie nowego obiektu typu char. Nie ma on nazwy, ale możemy się do niego
odwoływać poprzez wskaźnik zawierający adres tego obiektu.
int *wsk_tab;
wsk_tab = new int[10];
operator new utworzył 10-elementowa tablicę typu int.
Zwalnianie pamięci.
delete wsk;
powoduje usunięcie obiektu wskazanego przez wsk z pamięci.
Kasowanie tablicy zarezerwowanej dynamicznie:
delete [] wsk_tab;
Zwróćmy uwagę na nawiasy kwadratowe.
Cechy obiektów utworzonych operatorem new
1.
obiekty żyją od momentu utworzenia operatorem new aż do
momentu usunięcia operatorem delete
2.
obiekty nie mają nazwy. Operujemy na nich tylko przy pomocy wskaźników.
3.
obiekty utworzone operatorem new nie są automatycznie
inicjowane
int dl_tab,i;
cout<<"podaj rozmiar tablicy: "
cin>>dl_tab;
int *wsk_tab = new int[dl_tab];
for(i = 0;i<dl_tab;i++)
*wsk_tab++ = i;
................................
delete [] wsk_tab;
Za pomocą operatora delete kasuje się tylko obiekty utworzone przy pomocy operatora new,
przy czym nie należy kasować wcześniej skasowanego obiektu. Można kasować natomiast
wskaźnik ustawiony na NULL:
wsk = NULL;
delete wsk;
W trakcie alokowania pamięci może zdarzyć się tak, że operator new zwróci NULL. Oznacza to, że
wyczerpaliśmy pamięć dostępną na dane. W związku z tym w programach tworzących dużą liczbę
dużych obiektów należy kontrolować poprawność operacji alokacji. Można tego dokonać albo
poprzez fragment programu:
int *wsk;
wsk = new int[10000];
if(!wsk)
cout<<"pamięć się wyczerpała";
lub przy wykorzystaniu funkcji set_new-handler:
Przykład
#include<iostram.h>
#include<stdlib.h>
// exit
#include<new.h>
//set_new_handler
long k;
void alarm(){
cout<<"Brak pamięci przy k = "<<k;
exit(1);
}
void main(){
set_new_handler(alarm);
for( k = 0; ; k++)
new int;
}
W funkcji main wykonuje się nieskończona pętla tworząca dynamicznie obiekty. Jeśli w
którymś momencie zabraknie pamięci, sterowanie automatycznie przejmuje funkcja
set_new_handler uruchamiająca funkcję alarmową napisaną przez użytkownika. Argumentem tej
funkcji jest wskaźnik do funkcji alarm
Wskaźniki a stringi
Jeśli wskaźnik ma pokazywać na ciąg znaków, to można go zadeklarować jako:
char *text;
można go inicjalizować:
char *text = "Poniedziałek";
do tej pory:
char text_tab []
= "Poniedziałek";
char text_tab [13] = "Poniedziałek";
Przykład:
printf (″%s″, text);
Ekran: poniedziałek
printf (″%s″, text_tab);
Ekran: poniedziałek
printf (″%c″, text_tab[1]); Ekran: o
printf (″%c″, text[1]);
Ekran: o
text++;
printf (″%s″, text);
Ekran: oniedziałek
Przykład:
char text[]="BORLAND C++";
char *cel, *zrodlo;
il = strlen (text)+1;
// +1 na znak NULL
cel = new char [il];
// rezerwacja miejsca
zrodlo=text;
(1) while ((*zrodlo) != NULL) {
*cel = *zrodlo;
cel++; zrodlo++;
// BEZ NULL�A
}
*cel=NULL;
(2) while (*cel = *zrodlo)
// inaczej while ((*cel = *zrodlo) != �\0�)
{
cel++; zrodlo++;
// Z NULL�EM
}
(3) while (*cel++ = *zrodlo++);
//Z NULL�EM
(4) Można wykorzystać funkcję biblioteczną:
strcpy (cel, zrodlo); - kopiowanie znaków ze źródła do celu, znak NULL jest kopiowany.
Przykład: char *cel, zrodlo[]=″informatyka″;
cel=new char [strlen (zrodlo)+1];
strcpy (cel, zrodlo);