Wstep do programowania 1

Wstep
˛ do programowania 1
Wstep
˛ do programowania 1
Bożena Woźna-Szcześniak
[email protected]
Jan Długosz University, Poland
Wykład 5
Wstep
˛ do programowania 1
Typ zmiennoprzecinkowy
Typy zmiennoprzecinkowy
float Najmniejszy typ rzeczywisty w C. Dobry do
obliczeń z dokładnościa˛ do 6 miejsc po przecinku.
Obliczenia przy użyciu tego typu sa˛ szybkie, ale
łatwo można uzyskać przepełnienie. Typowa
wartość minimalna to 10−38 . Typowa wartość
maksymalna to 1038 .
double “Średni” typ rzeczywisty w C. Dobry do obliczeń z
dokładnościa˛ do 12 miejsc po przecinku. Typowa
wartość minimalna to 10−308 . Typowa wartość
maksymalna to 10308 . Znacznie wolniejszy w
obliczeniach od float, ale za to bardziej
precyzyjny.
Wstep
˛ do programowania 1
Typ zmiennoprzecinkowy
Typy zmiennoprzecinkowy
long double Najwiekszy
˛
typ rzeczywisty w C. Dobry do
obliczeń z dokładnościa˛ do 18 miejsc po
przecinku. Typowa wartość minimalna to 10−4000 .
Typowa wartość maksymalna to 104000 . Obliczenia
sa˛ najwolniejsze, ale najbardziej dokładne.
float.h Zbiór nagłówkowy zawierajacy
˛ stałe zwiazane
˛
z
typem zmiennoprzecinkowym.
Wstep
˛ do programowania 1
Typ zmiennoprzecinkowy
Typ zmiennoprzecinkowy - float.h
1
2
3
4
5
6
7
8
9
# include < s t d i o . h>
# include < f l o a t . h>
i n t main ( void )
{
p r i n t f ( " f l o a t min=%g , max=%g \ n " , FLT_MIN ,FLT_MAX ) ;
p r i n t f ( " double min=%l g , max=%l g \ n " , DBL_MIN ,DBL_MAX ) ;
p r i n t f ( " l o n g double min=%Lg , max=%Lg \ n " , LDBL_MIN ,LDBL_MAX ) ;
return 0;
}
float min=1.17549e-38, max=3.40282e+38
double min=2.22507e-308, max=1.79769e+308
long double min=3.3621e-4932, max=1.18973e+4932
Wstep
˛ do programowania 1
Typ zmiennoprzecinkowy
double
Typ zmiennoprzecinkowy - double
%lf printf wyświetla liczbe˛ rzeczywista˛ z dokładnościa˛
do 6 miejsc po przecinku.
%le printf wyświetla liczbe˛ rzeczywista˛ z dokładnościa˛
do 6 miejsc po przecinku, ale w notacji wykładniczej.
Np., 1.200000e − 05 znaczy 1.2 · 10−5 .
%lg printf wyświetla liczbe˛ rzeczywista˛ z pominieciem
˛
“zbednych”
˛
zer i w najkrótszej możliwej postaci. Np.
Zamiast 0.000012 dostajemy 1.2e-05.
%a.blf a (np., a=7) wskazuje szerokość liczby, b (np. b=2)
wskazuje precyzje˛ (dokładność po przecinku).
%.2le Dokładność do 2 miejsc po przecinku w formacie
wykładniczym.
%.4lg Dokładność do 4 miejsc po przecinku w “zwiezłym”
˛
formacie.
Wstep
˛ do programowania 1
Typ zmiennoprzecinkowy
double
Typ zmiennoprzecinkowy - double - przykład 1
1
2
3
4
5
6
7
8
9
10
11
# include < s t d i o . h>
# include < f l o a t . h>
i n t main ( void )
{
double f = 3.1416 , g = 1 .2 e−5, h = 5000000000.0;
p r i n t f ( " f=% l f \ t g=% l f \ t h=% l f \ n " , f , g , h ) ;
p r i n t f ( " f=%l e \ t g=%l e \ t h=%l e \ n " , f , g , h ) ;
p r i n t f ( " f=%l g \ t g=%l g \ t h=%l g \ n " , f , g , h ) ;
p r i n t f ( " f =%7.2 l f \ t g =%.2 l e \ t h =%.4 l g \ n " , f , g , h ) ;
return 0;
}
Wstep
˛ do programowania 1
Typ zmiennoprzecinkowy
double
Typ zmiennoprzecinkowy - double - przykład 1,
wykonanie
1
2
3
4
5
6
7
8
9
10
11
# include < s t d i o . h>
# include < f l o a t . h>
i n t main ( void )
{
double f = 3.1416 , g = 1 .2 e−5, h = 5000000000.0;
p r i n t f ( " f=% l f \ t g=% l f \ t h=% l f \ n " , f , g , h ) ;
p r i n t f ( " f=%l e \ t g=%l e \ t h=%l e \ n " , f , g , h ) ;
p r i n t f ( " f=%l g \ t g=%l g \ t h=%l g \ n " , f , g , h ) ;
p r i n t f ( " f =%7.2 l f \ t g =%.2 l e \ t h =%.4 l g \ n " , f , g , h ) ;
return 0;
}
f=3.141600
f=3.141600e+00
f=3.1416
f=
3.14
g=0.000012
g=1.200000e-05
g=1.2e-05
g=1.20e-05
h=5000000000.000000
h=5.000000e+09
h=5e+09
h=5e+09
Wstep
˛ do programowania 1
Typ zmiennoprzecinkowy
float
Typ zmiennoprzecinkowy - float - przykład 2
1
2
3
4
5
6
7
8
9
10
11
# include < s t d i o . h>
# include < f l o a t . h>
i n t main ( void )
{
f l o a t f = 3.1416 f , g = 1 .2 e−5f , h = 5000000000.0 f ;
p r i n t f ( " f=%f \ t g=%f \ t h=%f \ n " , f , g , h ) ;
p r i n t f ( " f=%e \ t g=%e \ t h=%e \ n " , f , g , h ) ;
p r i n t f ( " f=%g \ t g=%g \ t h=%g \ n " , f , g , h ) ;
p r i n t f ( " f =%7.2 f \ t g =%.2e \ t h =%.4g \ n " , f , g , h ) ;
return 0;
}
Wstep
˛ do programowania 1
Typ zmiennoprzecinkowy
float
Typ zmiennoprzecinkowy - float - przykład 2,
wykonanie
1
2
3
4
5
6
7
8
9
10
11
# include < s t d i o . h>
# include < f l o a t . h>
i n t main ( void )
{
f l o a t f = 3.1416 f , g = 1 .2 e−5f , h = 5000000000.0 f ;
p r i n t f ( " f=%f \ t g=%f \ t h=%f \ n " , f , g , h ) ;
p r i n t f ( " f=%e \ t g=%e \ t h=%e \ n " , f , g , h ) ;
p r i n t f ( " f=%g \ t g=%g \ t h=%g \ n " , f , g , h ) ;
p r i n t f ( " f =%7.2 f \ t g =%.2e \ t h =%.4g \ n " , f , g , h ) ;
return 0;
}
f=3.141600
f=3.141600e+00
f=3.1416
f=
3.14
g=0.000012
g=1.200000e-05
g=1.2e-05
g=1.20e-05
h=5000000000.000000
h=5.000000e+09
h=5e+09
h=5e+09
Wstep
˛ do programowania 1
Typ zmiennoprzecinkowy
float
Typ zmiennoprzecinkowy - long double - przykład 3,
wykonanie
1
2
3
4
5
6
7
8
9
10
11
# include < s t d i o . h>
# include < f l o a t . h>
i n t main ( void )
{
long double f = 3.1416 L , g = 1 .2 e−5L ,
p r i n t f ( " f=%L f \ t g=%L f \ t h=%L f \ n " , f , g ,
p r i n t f ( " f=%Le \ t g=%Le \ t h=%Le \ n " , f , g ,
p r i n t f ( " f=%Lg \ t g=%Lg \ t h=%Lg \ n " , f , g ,
p r i n t f ( " f =%7.2 L f \ t g =%.2Le \ t h =%.4Lg \ n "
return 0;
}
f=3.141600
f=3.141600e+00
f=3.1416
f=
3.14
h = 5000000000.0L ;
h);
h);
h);
, f , g, h);
g=0.000012
g=1.200000e-05
g=1.2e-05
g=1.20e-05
h=5000000000.000000
h=5.000000e+09
h=5e+09
h=5e+09
Wstep
˛ do programowania 1
Typ wyliczeniowy
Typ wiliczeniowy
◮
Typ wyliczeniowy to automatyczny mechnizm służacy
˛ do
generowania stałych o konkretnych nazwach.
◮
Przykład:
enum dzien { poniedzialek, wtorek, sroda,
czwartek, piatek, sobota, niedziela }
◮
W typie wyliczeniowym pierwsza wartość domyślnie jest
równa zero (patrz przykład 1).
◮
Każda nastepna
˛
ma wartość wieksz
˛
a˛ o jeden - chyba że
zostanie zdefiniowana inaczej (patrz przykłady 2 i 3).
◮
Stałe definiowane przy pomocy enums sa˛
implementowane przez kompilator jako “typy calkowite”.
Konkretny typ – int, long, long long – jest
dobierany na podstawie wartości stałej.
Wstep
˛ do programowania 1
Typ wyliczeniowy
Typ wiliczeniowy
◮
Typ wyliczeniowy to automatyczny mechnizm służacy
˛ do
generowania stałych o konkretnych nazwach.
◮
Przykład:
enum dzien { poniedzialek, wtorek, sroda,
czwartek, piatek, sobota, niedziela }
◮
W typie wyliczeniowym pierwsza wartość domyślnie jest
równa zero (patrz przykład 1).
◮
Każda nastepna
˛
ma wartość wieksz
˛
a˛ o jeden - chyba że
zostanie zdefiniowana inaczej (patrz przykłady 2 i 3).
◮
Stałe definiowane przy pomocy enums sa˛
implementowane przez kompilator jako “typy calkowite”.
Konkretny typ – int, long, long long – jest
dobierany na podstawie wartości stałej.
Wstep
˛ do programowania 1
Typ wyliczeniowy
Typ wiliczeniowy
◮
Typ wyliczeniowy to automatyczny mechnizm służacy
˛ do
generowania stałych o konkretnych nazwach.
◮
Przykład:
enum dzien { poniedzialek, wtorek, sroda,
czwartek, piatek, sobota, niedziela }
◮
W typie wyliczeniowym pierwsza wartość domyślnie jest
równa zero (patrz przykład 1).
◮
Każda nastepna
˛
ma wartość wieksz
˛
a˛ o jeden - chyba że
zostanie zdefiniowana inaczej (patrz przykłady 2 i 3).
◮
Stałe definiowane przy pomocy enums sa˛
implementowane przez kompilator jako “typy calkowite”.
Konkretny typ – int, long, long long – jest
dobierany na podstawie wartości stałej.
Wstep
˛ do programowania 1
Typ wyliczeniowy
Typ wiliczeniowy
◮
Typ wyliczeniowy to automatyczny mechnizm służacy
˛ do
generowania stałych o konkretnych nazwach.
◮
Przykład:
enum dzien { poniedzialek, wtorek, sroda,
czwartek, piatek, sobota, niedziela }
◮
W typie wyliczeniowym pierwsza wartość domyślnie jest
równa zero (patrz przykład 1).
◮
Każda nastepna
˛
ma wartość wieksz
˛
a˛ o jeden - chyba że
zostanie zdefiniowana inaczej (patrz przykłady 2 i 3).
◮
Stałe definiowane przy pomocy enums sa˛
implementowane przez kompilator jako “typy calkowite”.
Konkretny typ – int, long, long long – jest
dobierany na podstawie wartości stałej.
Wstep
˛ do programowania 1
Typ wyliczeniowy
Typ wiliczeniowy
◮
Typ wyliczeniowy to automatyczny mechnizm służacy
˛ do
generowania stałych o konkretnych nazwach.
◮
Przykład:
enum dzien { poniedzialek, wtorek, sroda,
czwartek, piatek, sobota, niedziela }
◮
W typie wyliczeniowym pierwsza wartość domyślnie jest
równa zero (patrz przykład 1).
◮
Każda nastepna
˛
ma wartość wieksz
˛
a˛ o jeden - chyba że
zostanie zdefiniowana inaczej (patrz przykłady 2 i 3).
◮
Stałe definiowane przy pomocy enums sa˛
implementowane przez kompilator jako “typy calkowite”.
Konkretny typ – int, long, long long – jest
dobierany na podstawie wartości stałej.
Wstep
˛ do programowania 1
Typ wyliczeniowy
enum - przykład 1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# include < s t d i o . h>
enum d z i e n { p o n i e d z i a l e k , wtorek , sroda , czwartek , p i a t e k , / /
sobota , n i e d z i e l a } ;
i n t main ( void )
{
enum d z i e n d z i s = wtorek ;
while ( d z i s != sobota ) {
p r i n t f ( " Dzi ś j e s t %d d z i e n t y g o d n i a wiec s i e˛ ucze ! \ n " , d z i s + 1 ) ;
d z i s ++;
}
p r i n t f ( " Dzi ś j e s t %d d z i e n ty g o d n i a , c z y l i sobota " ,++ d z i s ) ;
p r i n t f ( " wi ec
˛ mam wolne : ) ! \ n " ) ;
p r i n t f ( " J u t r o j e s t %d d z i e n ty g o d n i a , c z y l i n i e d z i e l a " ,++ d z i s ) ;
p r i n t f ( " wi ec
˛ mam t e ż wolne : ) ! \ n " ) ;
return 0;
}
Wstep
˛ do programowania 1
Typ wyliczeniowy
enum - przykład, wykonanie
e ucze !
Dziś jest 2 dzien tygodnia wiec si˛
Dziś jest 3 dzien tygodnia wiec si˛
e ucze !
Dziś jest 4 dzien tygodnia wiec si˛
e ucze !
Dziś jest 5 dzien tygodnia wiec si˛
e ucze !
Dziś jest 6 dzien tygodnia czyli sobota wi˛
ec
mam wolne :)!
Jutro jest 7 dzien tygodnia czyli niedziela
wi˛
ec mam też wolne :)!
Wstep
˛ do programowania 1
Typ wyliczeniowy
enum - przykład 2
1
2
3
4
5
6
7
8
9
10
# include < s t d i o . h>
enum m i e s i a c { s ty c z e n =1 , l u t y , marzec , kwiecien , maj , czerwiec , l i p i e c , / /
s i e r p i e n , wrzesien , p a z d z i e r n i k , l i s t o p a d , g r u d z i e n } ;
i n t main ( void ) {
p r i n t f ( "%d , %d , %d , " , styczen , l u t y , marzec ) ;
p r i n t f ( "%d , %d , %d , " , kwiecien , maj , c z e r w i e c ) ;
p r i n t f ( " . . . , %d . \ n " , g r u d z i e n ) ;
return 0;
}
1, 2, 3, 4, 5, 6,..., 12.
Wstep
˛ do programowania 1
Typ wyliczeniowy
enum - przykład 2
1
2
3
4
5
6
7
8
9
10
# include < s t d i o . h>
enum m i e s i a c { s ty c z e n =1 , l u t y , marzec , kwiecien , maj , czerwiec , l i p i e c , / /
s i e r p i e n , wrzesien , p a z d z i e r n i k , l i s t o p a d , g r u d z i e n } ;
i n t main ( void ) {
p r i n t f ( "%d , %d , %d , " , styczen , l u t y , marzec ) ;
p r i n t f ( "%d , %d , %d , " , kwiecien , maj , c z e r w i e c ) ;
p r i n t f ( " . . . , %d . \ n " , g r u d z i e n ) ;
return 0;
}
1, 2, 3, 4, 5, 6,..., 12.
Wstep
˛ do programowania 1
Typ wyliczeniowy
enum - przykład 3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# include < s t d i o . h>
enum d i r e c t i o n { n o r t h = 0 , e a s t = 90 , south = 180 , west = 270 } ;
i n t main ( void ) {
int n;
do {
p r i n t f ( " Podaj co pokazuje kompas : " ) ;
s c a n f ( "%d " ,&n ) ;
switch ( n ) {
case n o r t h : p r i n t f ( " I d z na Polnoc ! \ n " ) ; break ;
case e a s t : p r i n t f ( " I d z na Wschod ! \ n " ) ; break ;
case south : p r i n t f ( " I d z na P o l u d n i e ! \ n " ) ; break ;
case west : p r i n t f ( " I d z na Zachod ! \ n " ) ; break ;
d e f a u l t : p r i n t f ( " Kierunek n i e p r a w i d ł o w y ! ! ! \ n " ) ; break ;
}
} while ( ! ( ( n== n o r t h ) | | ( n== e a s t ) | | ( n==south ) | | ( n==west ) ) ) ;
return 0;
}
Wstep
˛ do programowania 1
Typ wyliczeniowy
enum - przykład 3, przykładowe wykonanie
Podaj co pokazuje kompas: 2
Kierunek nieprawidłowy !!!
Podaj co pokazuje kompas: 4
Kierunek nieprawidłowy !!!
Podaj co pokazuje kompas: 90
Idz na Wschod .
Wstep
˛ do programowania 1
Typ wyliczeniowy
typdef i enum
◮
Standardowa definicja typu wyliczeniowego, wymaga
użycia słowa kluczowego enum przy definiowaniu
zmiennych tego typu, przy przekazywaniu argumentów do
funkcji, itd. (patrz przykład 1).
◮
Aby uniknać
˛ tak uciażliwego
˛
stosowania nowo
zdefiniowanego typu, można wykorzystać instrukcje˛ typdef
◮
Przykład:
typedef enum {poniedzialek, wtorek, sroda,
czwartek, piatek, sobota, niedziela} dzien;
dzien dzis = wtorek;
Wstep
˛ do programowania 1
Typ wyliczeniowy
typdef i enum
◮
Standardowa definicja typu wyliczeniowego, wymaga
użycia słowa kluczowego enum przy definiowaniu
zmiennych tego typu, przy przekazywaniu argumentów do
funkcji, itd. (patrz przykład 1).
◮
Aby uniknać
˛ tak uciażliwego
˛
stosowania nowo
zdefiniowanego typu, można wykorzystać instrukcje˛ typdef
◮
Przykład:
typedef enum {poniedzialek, wtorek, sroda,
czwartek, piatek, sobota, niedziela} dzien;
dzien dzis = wtorek;
Wstep
˛ do programowania 1
Typ wyliczeniowy
typdef i enum
◮
Standardowa definicja typu wyliczeniowego, wymaga
użycia słowa kluczowego enum przy definiowaniu
zmiennych tego typu, przy przekazywaniu argumentów do
funkcji, itd. (patrz przykład 1).
◮
Aby uniknać
˛ tak uciażliwego
˛
stosowania nowo
zdefiniowanego typu, można wykorzystać instrukcje˛ typdef
◮
Przykład:
typedef enum {poniedzialek, wtorek, sroda,
czwartek, piatek, sobota, niedziela} dzien;
dzien dzis = wtorek;
Wstep
˛ do programowania 1
Typ wyliczeniowy
typdef i enum - przykład 4
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# include < s t d i o . h>
typedef enum { p o n i e d z i a l e k , wtorek , sroda , czwartek , p i a t e k , / /
sobota , n i e d z i e l a } d z i e n ;
i n t main ( void )
{
m i e s i a c d z i e n = wtorek ;
while ( d z i s != sobota ) {
p r i n t f ( " Dzi ś j e s t %d d z i e n t y g o d n i a wiec s i e˛ ucze ! \ n " , d z i s + 1 ) ;
d z i s ++;
}
p r i n t f ( " Dzi ś j e s t %d d z i e n ty g o d n i a , c z y l i sobota " ,++ d z i s ) ;
p r i n t f ( " wi ec
˛ mam wolne : ) ! \ n " ) ;
p r i n t f ( " J u t r o j e s t %d d z i e n ty g o d n i a , c z y l i n i e d z i e l a " ,++ d z i s ) ;
p r i n t f ( " wi ec
˛ mam t e ż wolne : ) ! \ n " ) ;
return 0;
}
Wstep
˛ do programowania 1
L- i R-wartości
L-wartości oraz R-wartości
◮
L-wartość to wyrażenie, które może stać po lewej stronie
operatora przypisania.
◮
◮
◮
R-wartość to wyrażenie, które może stać po prawej stronie
operatora przypisania.
◮
◮
◮
a = b + 25;
tab[3] = 0;
// b + 25 = a;
// tab = 5;
Każda L-wartość jest R-wartościa˛
Wstep
˛ do programowania 1
Wskaźniki
Pamieć
˛ i adresy
◮
Pamieć
˛ i adresy. Adresy i zawartość. (p00.c)
◮
◮
◮
Wartości i ich typy. (p01.c)
◮
◮
Każda lokalizacja w pamieci
˛ jest identyfikowana przez
unikalny adres.
Każda lokalizacja w pamieci
˛ zawiera pewna˛ wartość.
Typ wartości nie może być określony jedynie przez
sprawdzenie sekwencji bitów
Zawartość zmiennej wskaźnikowej.
◮
Zawartościa˛ zmiennej wskaźnikowej jest adres.
Wstep
˛ do programowania 1
Wskaźniki
Pamieć
˛ i adresy
p00.c
#include <stdio.h>
#include <string.h>
int main(void) {
int a = -1;
printf("a = %d\n\n", a);
unsigned b = 0;
memcpy(&b, &a, sizeof(b));
printf("b = %u\n\n", b);
float c = 3.14; printf("c = %f\n\n", c);
unsigned d = 0;
memcpy(&d, &c, sizeof(d));
printf("d = %u\n\n", d);
int* p = &a;
printf("p = %p, *p=%d\n\n", p,*p);
float* q = &c;
printf("q = %p\n\n", q);
return 0;
}
Wstep
˛ do programowania 1
Wskaźniki
Pamieć
˛ i adresy
p01.c
#include <stdio.h>
#include <string.h>
int main(void) {
char a[4] = {’s’, ’l’, ’a’, ’x’};
printf("a = %c%c%c%c\n\n", a[0], a[1], a[2], a[3]);
printf("%p = \n",a);
int b;
memcpy(&b, &a, sizeof(b));
printf("b = %d\n\n", b);
unsigned c;
memcpy(&c, &a, sizeof(c));
printf("c = %u\n\n", c);
float d;
memcpy(&d, &a, sizeof(d));
printf("d = %f\n\n", d);
int* p;
memcpy(&p, &a, sizeof(p));
printf("p = %p\n\n", p);
return 0;
}
Wstep
˛ do programowania 1
Wskaźniki
Operator dereferencji
◮
Operator dereferencji.
◮
◮
◮
◮
◮
◮
Niezainicjalizowane i nieprawidłowe wskaźniki.
◮
◮
◮
int a = 10;
int* p = &a; // p wskazuje na zmienna˛ a
printf("%d\n", *p); // 10
*p = 20; // *p to zmienna, na która˛ wskazuje p
printf("%d\n", a); // 20
int* q; // zmienna q ma przypadkowa˛ wartość
*q = 10;
Wskaźnik NULL.
◮
int* q = NULL;
Wstep
˛ do programowania 1
Wskaźniki
Operator dereferencji
Wyrażenie
a
b
c
d
p
q
*p
*q
R-wartość
-1
4294967295
3.14
1078523331
0xbf9e3574
0xbf9e356c
-1
3.14
Typ
int
unsigned
float
unsigned
int*
float*
int
float
Wstep
˛ do programowania 1
Wskaźniki
Dereferencja i L-wartości
◮
Wskaźniki, dereferencja i L-wartości.
◮
◮
◮
◮
int a = 10;
int* p = &a;
*p = 10 - *p;
// p = 10 - *p;
Wyrażenie
a
p
*p
&a
L-wartość
Tak
Tak
Tak
Nie
Wskazywana lokalizacja
a
p
a
—
Wstep
˛ do programowania 1
Wskaźniki
Wskaźniki do wskaźników
◮
Wskaźniki, dereferencja i zmienne.
◮
◮
◮
Stałe wskaźnikowe.
◮
◮
◮
int a;
*&a = 10;
// *100 = 25;
*(int*)100 = 25;
Wskaźniki do wskaźników.
◮
◮
◮
◮
◮
int a = 10;
int* p;
p = &a;
int** q;
q = &p;
Wstep
˛ do programowania 1
Wskaźniki
Wskaźniki do wskaźników
Wartoźci wyrażeń
Wyrażenie
Odpowiadajace
˛ mu wyrażenia
a
p
*p
q
*q
**q
10
&a
a, 10
&p
p, &a
*p, a, 10
Wstep
˛ do programowania 1
Wskaźniki
Operacje na wskaźnikach
◮
Operacje na wskaźnikach.
◮
◮
char c = ’A’;
char* p = &c;
Wyrażenie
c
&c
p
&p
*p
p
* + 1
*(p + 1)
R-wartość
’A’
adres zmiennej c
adres zmiennej c
adres zmiennej p
’A’
’B’
?
L-wartość
Tak
Nie
Tak
Nie
Tak
Nie
Tak
Wstep
˛ do programowania 1
Wskaźniki
Operacje na wskaźnikach
◮
Operacje na wskaźnikach.
◮
◮
char c = ’A’;
char* p = &c;
Wyrażenie
++p
p++
*++p
*p++
++*p
(*p)++
++*++p
++*p++
R-wartość
adres nast. znaku
adres c
?
’A’
’B’
’A’
?+1
’B’
L-wartość
Nie
Nie
Tak
Tak
Nie
Nie
Nie
Nie
Wstep
˛ do programowania 1
Arytmetyka wskaźników
Wyrażenie
p+1
p+2
p jest
wskaźnikiem
na
char
short
int
double
char
short
int
double
sizeof(*p)
1
2
4
8
1
2
4
8
Wartościa˛
dodawana
do wskaźnika
1
2
4
8
2
4
8
16