C/Składnia: Różnice pomiędzy wersjami
m wikitable |
→Typy danych: + _Bool, _Complex; poprawienie nieścisłości w rozmiarze (mieszanie bitów z bajtami) i wywalenie rozmiaru poza tabelke |
||
Linia 306: | Linia 306: | ||
== Typy danych == |
== Typy danych == |
||
{| class="wikitable" cellspace=20 |
{| class="wikitable" cellspace=20 |
||
! Typ |
! Typ !! Opis !! Inne nazwy |
||
|- |
|- |
||
! align=center colspan= |
! align=center colspan=3|Typy danych w/g norm C89 i C90 |
||
|- |
|- |
||
| '''char''' |
| '''char''' |
||
| align=center| ≥ 8 |
|||
| |
| |
||
* Służy głównie do przechowywania znaków |
|||
* Podstawowy typ danych w języku C |
|||
* Od kompilatora zależy czy jest to liczba ze znakiem czy bez; w większości kompilatorów jest liczbą ze znakiem |
|||
* Przechowuje wszystkie ośmiobitowe sposoby kodowania znaków (np. ASCII) |
|||
| |
|||
* Wielkość pozostałych typów jest zwykle całkowitą wielokrotnością rozmiaru '''char''' |
|||
* W większości kompilatorów jest tożsamy z typem '''signed char''' |
|||
⚫ | |||
|- |
|- |
||
| '''signed char''' |
| '''signed char''' |
||
| align=center| = '''sizeof'''('''char''') |
|||
| |
| |
||
* Typ char ze znakiem |
* Typ char ze znakiem |
||
| |
|||
* Może przechowywać liczby całkowite z zakresu od -128 do 127 |
|||
⚫ | |||
|- |
|- |
||
| '''unsigned char''' |
| '''unsigned char''' |
||
| align=center| = '''sizeof'''('''char''') |
|||
| |
| |
||
* Typ char bez znaku |
* Typ char bez znaku |
||
| |
|||
* Może przechowywać liczby całkowite z zakresu od 0 do 255 |
|||
⚫ | |||
|- |
|- |
||
| '''short''' |
| '''short''' |
||
| align=center| '''sizeof'''('''int''') ≥ 16, ≥ '''sizeof'''('''char''') |
|||
| |
| |
||
* Występuje, gdy docelowa maszyna wyszczególnia krótki typ danych całkowitych, w przeciwnym wypadku jest tożsamy z typem '''int''' |
* Występuje, gdy docelowa maszyna wyszczególnia krótki typ danych całkowitych, w przeciwnym wypadku jest tożsamy z typem '''int''' |
||
Linia 341: | Linia 333: | ||
|- |
|- |
||
| '''unsigned short''' |
| '''unsigned short''' |
||
| align=center| = '''sizeof'''('''short''') |
|||
| |
| |
||
* Liczba typu '''short''' bez znaku |
* Liczba typu '''short''' bez znaku |
||
Linia 348: | Linia 339: | ||
|- |
|- |
||
| '''int''' |
| '''int''' |
||
| align=center| '''sizeof'''('''long int''') ≥ 32,16, ≥ '''sizeof'''('''short''') |
|||
| |
| |
||
* Liczba całkowita, odpowiadająca |
* Liczba całkowita, odpowiadająca podstawowemu rozmiarowi liczby całkowitej w danym komputerze. |
||
* Podstawowy typ dla liczb całkowitych |
* Podstawowy typ dla liczb całkowitych |
||
⚫ | |||
* Zwykle ma rozmiar podwójnego słowa maszynowego |
|||
⚫ | |||
|- |
|- |
||
| '''unsigned''' |
|||
⚫ | |||
* Liczba całkowita bez znaku |
|||
| '''unsigned int''' |
| '''unsigned int''' |
||
⚫ | |||
| align=center| = '''sizeof'''('''int''') |
|||
| '''long''' |
|||
| |
| |
||
* |
* Długa liczba całkowita |
||
|- |
|- |
||
| ''' |
| '''unsigned long''' |
||
| align=center| 64,32 ≥ '''sizeof'''('''int''') |
|||
| |
| |
||
* Długa liczba całkowita |
* Długa liczba całkowita |
||
⚫ | |||
* Zależnie od maszyny liczba ma rozmiar podwójnego lub poczwórnego słowa maszynowego |
|||
⚫ | |||
|- |
|- |
||
| '''float''' |
| '''float''' |
||
| align=center| ≥ '''sizeof'''('''char''') |
|||
| |
| |
||
* Podstawowy typ do przechowywania liczb zmiennoprzecinkowych |
* Podstawowy typ do przechowywania liczb zmiennoprzecinkowych |
||
* W nowszym standardzie zgodny jest z normą [[w:en:IEEE 754|IEEE 754]] |
* W nowszym standardzie zgodny jest z normą [[w:en:IEEE 754|IEEE 754]] |
||
* Nie można stosować go z modyfikatorem '''unsigned''' |
* Nie można stosować go z modyfikatorem '''signed''' ani '''unsigned''' |
||
| |
| |
||
|- |
|- |
||
| '''double''' |
| '''double''' |
||
| align=center| ≥ '''sizeof'''('''float''') |
|||
| |
| |
||
* Liczba zmiennoprzecinkowa podwójnej precyzji |
* Liczba zmiennoprzecinkowa podwójnej precyzji |
||
* Podobnie jak float nie łączy się z modyfikatorem '''unsigned''' |
* Podobnie jak float nie łączy się z modyfikatorem '''signed''' ani '''unsigned''' |
||
| |
| |
||
|- |
|- |
||
| '''long double''' |
| '''long double''' |
||
| align=center| ≥ '''sizeof'''('''double''') |
|||
| |
| |
||
* Największa możliwa dokładność liczb zmiennoprzecinkowych |
* Największa możliwa dokładność liczb zmiennoprzecinkowych |
||
* Nie łączy się z modyfikatorem '''unsigned''' |
* Nie łączy się z modyfikatorem '''signed''' ani '''unsigned''' |
||
| |
| |
||
|- |
|- |
||
! colspan= |
! colspan=3|Typy danych według normy C99 |
||
⚫ | |||
| '''_Bool''' |
|||
| |
|||
* Przechowuje wartości 0 lub 1 |
|||
| |
|||
|- |
|- |
||
| '''long long |
| '''long long''' |
||
| align=center| ≥ 64, ≥ '''sizeof'''('''long int''') |
|||
| |
| |
||
* Nowy typ, umożliwiający obliczeniach na bardzo dużych liczbach całkowitych bez użycia typu float |
* Nowy typ, umożliwiający obliczeniach na bardzo dużych liczbach całkowitych bez użycia typu float |
||
| '''long long''', '''signed long long''', '''signed long long int''' |
| '''long long int''', '''signed long long''', '''signed long long int''' |
||
|- |
|- |
||
| '''unsigned long long |
| '''unsigned long long''' |
||
| align=center| ≥ 64, ≥ '''sizeof'''('''long int''') |
|||
| |
| |
||
* Długie liczby całkowite bez znaku |
* Długie liczby całkowite bez znaku |
||
| '''unsigned long long''' |
| '''unsigned long long int''' |
||
|- |
|- |
||
| '''float _Complex''' |
|||
⚫ | |||
| |
|||
* Słuzy do przechowywania liczb zespolonych |
|||
| |
|||
⚫ | |||
| '''double _Complex''' |
|||
| |
|||
* Słuzy do przechowywania liczb zespolonych |
|||
| |
|||
|- |
|||
| '''long double _Complex''' |
|||
| |
|||
* Słuzy do przechowywania liczb zespolonych |
|||
| |
|||
|- |
|||
⚫ | |||
|- |
|- |
||
| '''struct''' |
| '''struct''' |
||
| align=center| Suma rozmiarów pól struktury + ewentualne dopełnienie<ref>Patrz - rozdział [[C/Więcej o kompilowaniu|Więcej o kompilowaniu]].</ref> |
|||
| |
| |
||
* Rozmiar zależy od typów danych, umieszczonych w strukturze |
* Rozmiar zależy od typów danych, umieszczonych w strukturze plus ewentualne dopełnienie<ref>Patrz - rozdział [[C/Więcej o kompilowaniu|Więcej o kompilowaniu]].</ref> |
||
| |
| |
||
|- |
|- |
||
| '''union''' |
| '''union''' |
||
| |
|||
| align=center| Rozmiar największego pola |
|||
* Rozmiar typu jest taki jak rozmiar największego pola |
|||
⚫ | |||
| |
| |
||
|- |
|- |
||
| '''typedef''' |
| '''typedef''' |
||
| align=center| Rozmiar typu źródłowego |
|||
| |
| |
||
* Nowo zdefiniowany typ przyjmuje taki sam rozmiar, jak typ macierzysty |
* Nowo zdefiniowany typ przyjmuje taki sam rozmiar, jak typ macierzysty |
||
| |
| |
||
|- |
|- |
||
| '''enum''' |
| '''enum''' |
||
| align=center| ≥ '''sizeof'''('''char''') |
|||
| |
| |
||
* Zwykle elementy mają taką samą długość, jak typ '''int'''. |
* Zwykle elementy mają taką samą długość, jak typ '''int'''. |
||
Linia 429: | Linia 432: | ||
|- |
|- |
||
|} |
|} |
||
Zależności rozmiaru typów danych są następujące: |
|||
* sizeof(''cokolwiek'') = sizeof('''signed''' ''cokolwiek'') = sizeof('''unsigned''' ''cokolwiek''); |
|||
* 1 = sizeof('''char''') ≤ sizeof('''short''') ≤ sizeof('''int''') ≤ sizeof('''long''') ≤ sizeof('''long long'''); |
|||
* sizeof('''float''') ≤ sizeof('''double''') ≤ sizeof('''long double'''); |
|||
* sizeof(''cokolwiek'' '''_Complex''') = 2 * sizeof(''cokolwiek'') |
|||
* sizeof('''void *''') = sizeof('''char *''') ≥ sizeof(''cokolwiek'' '''*'''); |
|||
* sizeof(''cokolwiek'' '''*''') = sizeof('''signed''' ''cokolwiek'' '''*''') = sizeof('''unsigned''' ''cokolwiek'' '''*'''); |
|||
* sizeof(''cokolwiek'' '''*''') = sizeof('''const''' ''cokolwiek'' '''*'''). |
|||
Dodatkowo, jeżeli przez V(typ) oznaczymy liczbę bitów wykorzystywanych w typie to zachodzi: |
|||
* 8 ≤ V('''char''') = V('''signed char''') = V('''unsigned char'''); |
|||
* 16 ≤ V('''short''') = V('''unsigned short'''); |
|||
* 16 ≤ V('''int''') = V('''unsigned int'''); |
|||
* 32 ≤ V('''long''') = V('''unsigned long'''); |
|||
* 64 ≤ V('''long long''') = V('''unsigned long long'''); |
|||
* V('''char''') ≤ V('''short''') ≤ V('''int''') ≤ V('''long''') ≤ V('''long long'''). |
|||
<noinclude> |
<noinclude> |
||
{{Przypisy}} |
{{Przypisy}} |
Wersja z 20:54, 20 sty 2007
Uwaga: przedstawione tutaj informacje nie są w stanie zastąpić treści całego podręcznika.
Symbole i słowa kluczowe
Język C definiuje pewną ilość słów, za pomocą których tworzy się np. pętle itp. Są to tzw. słowa kluczowe, tzn. nie można użyć ich jako nazwy zmiennej, czy też stałej (o nich poniżej). Oto lista słów kluczowych języka C (według norm ANSI C oraz ISO C):
Słowo | Opis w tym podręczniku |
---|---|
auto | Zmienne |
break | Instrukcje sterujące |
case | Instrukcje sterujące |
char | Zmienne |
const | Zmienne |
continue | Instrukcje sterujące |
default | Instrukcje sterujące |
do | Instrukcje sterujące |
double | Zmienne |
else | Instrukcje sterujące |
enum | Typy złożone |
extern | Biblioteki |
float | Zmienne |
for | Instrukcje sterujące |
goto | Instrukcje sterujące |
if | Instrukcje sterujące |
int | Zmienne |
long | Zmienne |
register | Zmienne |
return | Procedury i funkcje |
short | Zmienne |
signed | Zmienne |
sizeof | Zmienne |
static | Biblioteki, Zmienne |
struct | Typy złożone |
switch | Instrukcje sterujące |
typedef | Typy złożone |
union | Typy złożone |
unsigned | Zmienne |
void | Wskaźniki |
volatile | Zmienne |
while | Instrukcje sterujące |
Specyfikacja ISO C (C99) dodaje następujące słowa:
- _Bool
- _Complex
- _Imaginary
- inline
- restrict
Polskie znaki
Pisząc program, możemy stosować polskie litery (tj. "ąćęłńóśźż") tylko w:
- komentarzach
- ciągach znaków (łańcuchach)
Niedopuszczalne jest stosowanie polskich znaków w innych miejscach.
Operatory
Operatory arytmetyczne
Są to operatory wykonujące znane wszystkim dodawanie,odejmowanie itp.:
operator | znaczenie |
---|---|
+ | dodawanie |
- | odejmowanie |
* | mnożenie |
/ | dzielenie |
% | dzielenie modulo - daje w wyniku samą resztę z dzielenia |
= | operator przypisania - wykonuje działanie po prawej stronie i wynik przypisuje obiektowi po lewej |
Operatory logiczne
Służą porównaniu zawartości dwóch zmiennych według okteślonych kryteriów:
Operator | Rodzaj porównania |
---|---|
== | czy równe |
> | większy |
>= | większy bądź równy |
< | mniejszy |
<= | mniejszy bądź równy |
!= | czy różny(nierówny) |
Są jeszcze operatory, służące do grupowania porównań (Patrz też:logika w Wikipedi):
|| | lub(OR) |
&& | i,oraz(AND) |
! | negacja(NOT) |
Operatory binarne
Są to operatory, które działają na bitach.
operator | funkcja | przykład |
---|---|---|
| | suma bitowa(OR) | 5 | 2 da w wyniku 7 ( 00000101 OR 00000010 = 00000111) |
& | iloczyn bitowy | 7 & 2 da w wyniku 2 ( 00000111 AND 00000010 = 00000010) |
~ | negacja bitowa | ~2 da w wyniku 253 ( NOT 00000010 = 11111101 ) |
>> | przesunięcie bitów o X w prawo | 7 >> 2 da w wyniku 1 ( 00000111 >> 2 = 00000001) |
<< | przesunięcie bitów o X w lewo | 7 << 2 da w wyniku 28 ( 00000111 << 2 = 00011100) |
^ | alternatywa wyłączna | 7 ^ 2 da w wyniku 5 ( 00000111 ^ 00000010 = 00000101) |
Operatory inkrementacji/dekrementacji
Służą do dodawania/odejmowania od liczby wartości jeden.
Przykłady:
Operacja | Opis operacji | Wartość wyrażenia |
---|---|---|
x++ | zwiększy wartość w x o jeden | wartość zmiennej x przed zmianą |
++x | zwiększy wartość w x o jeden | wartość zmiennej x powiększona o jeden |
x-- | zmniejszy wartość w x o jeden | wartość zmiennej x przed zmianą |
--x | zmniejszy wartość w x o jeden | wartość zmiennej x pomniejszona o jeden |
Parę przykładów dla zrozumienia:
int a=7; if ((a++)==7) /* najpierw porównuje, potem dodaje */ printf ("%d\n",a); /* wypisze 8 */ if ((++a)==9) /* najpier dodaje, potem porównuje */ printf ("%d\n", a); /* wypisze 9 */
Analogicznie ma się sytuacja z operatorami dekrementacji.
Pozostałe
Operacja | Opis operacji | Wartość wyrażenia |
---|---|---|
*x | operator wyłuskania dla wskaźnika | wartość trzymana w pamięci pod adresem przechowywanym we wskaźniku |
&x | operator pobrania adresu | zwraca adres zmiennej |
x[a] | operator wybrania elementu tablicy | zwraca element tablicy na miejscu a+1 |
x.a | operator wyboru składnika a ze zmiennej x | wybiera składnik ze struktury lub unii |
x->a | operator wyboru składnika a przez wskaźnik do zmiennej x | wybiera składnik ze struktury gdy używamy wskaźnika do struktury zamiast zwykłej zmiennej |
Operator ternarny
Istnieje jeden operator przyjmujący trzy argumenty - jest to operator wyrażenia warunkowego: a ? b : c. Zwraca on b gdy a jest prawdą lub c w przeciwnym wypadku.
Typy danych
Typ | Opis | Inne nazwy |
---|---|---|
Typy danych w/g norm C89 i C90 | ||
char |
|
|
signed char |
|
|
unsigned char |
|
|
short |
|
short int, signed short, signed short int |
unsigned short |
|
unsigned short int |
int |
|
signed int, signed |
unsigned |
|
unsigned int |
long |
| |
unsigned long |
|
long int, signed long, signed long int |
float |
|
|
double |
|
|
long double |
|
|
Typy danych według normy C99 | ||
_Bool |
|
|
long long |
|
long long int, signed long long, signed long long int |
unsigned long long |
|
unsigned long long int |
float _Complex |
|
|
double _Complex |
|
|
long double _Complex |
|
|
Typy danych definiowane przez użytkownika | ||
struct |
|
|
union |
|
|
typedef |
|
|
enum |
|
- |
Zależności rozmiaru typów danych są następujące:
- sizeof(cokolwiek) = sizeof(signed cokolwiek) = sizeof(unsigned cokolwiek);
- 1 = sizeof(char) ≤ sizeof(short) ≤ sizeof(int) ≤ sizeof(long) ≤ sizeof(long long);
- sizeof(float) ≤ sizeof(double) ≤ sizeof(long double);
- sizeof(cokolwiek _Complex) = 2 * sizeof(cokolwiek)
- sizeof(void *) = sizeof(char *) ≥ sizeof(cokolwiek *);
- sizeof(cokolwiek *) = sizeof(signed cokolwiek *) = sizeof(unsigned cokolwiek *);
- sizeof(cokolwiek *) = sizeof(const cokolwiek *).
Dodatkowo, jeżeli przez V(typ) oznaczymy liczbę bitów wykorzystywanych w typie to zachodzi:
- 8 ≤ V(char) = V(signed char) = V(unsigned char);
- 16 ≤ V(short) = V(unsigned short);
- 16 ≤ V(int) = V(unsigned int);
- 32 ≤ V(long) = V(unsigned long);
- 64 ≤ V(long long) = V(unsigned long long);
- V(char) ≤ V(short) ≤ V(int) ≤ V(long) ≤ V(long long).
Przypisy
- ↑ Patrz - rozdział Więcej o kompilowaniu.