C Language
Typy danych

Uwagi

Typy i stałe liczb całkowitych

Podpisane liczby całkowite mogą być z tych typów (w int po short lub long jest opcjonalne):

signed char c = 127; /* required to be 1 byte, see remarks for further information. */
signed short int si = 32767; /* required to be at least 16 bits. */
signed int i = 32767; /* required to be at least 16 bits */
signed long int li = 2147483647; /* required to be at least 32 bits. */

signed long long int li = 2147483647; /* required to be at least 64 bits */

Każdy z tych typów liczb całkowitych ze znakiem ma wersję bez znaku.

unsigned int i = 65535;
unsigned short = 2767;
unsigned char = 255;

Dla wszystkich typów oprócz char signed wersja jest zakładana, jeśli część signed lub unsigned zostanie pominięta. Typ char stanowi trzeci typ znaków, różny od signed char i unsigned char a podpis (lub nie) zależy od platformy.

Różne typy stałych całkowitych (zwane literałami w żargonie C) mogą być zapisywane w różnych podstawach i różnej szerokości, w zależności od ich przedrostka lub przyrostka.

/* the following variables are initialized to the same value: */
int d = 42;   /* decimal constant (base10) */
int o = 052;  /* octal constant (base8) */
int x = 0xaf; /* hexadecimal constants (base16) */
int X = 0XAf; /* (letters 'a' through 'f' (case insensitive) represent 10 through 15) */

Stałe dziesiętne są zawsze signed . Stałe szesnastkowe zaczynają się od 0x lub 0X a stałe ósemkowe zaczynają się od 0 . Dwa ostatnie są signed lub unsigned zależności od tego, czy wartość pasuje do typu podpisanego, czy nie.

/* suffixes to describe width and signedness : */
long int i = 0x32; /* no suffix represent int, or long int */
unsigned int ui = 65535u; /* u or U represent unsigned int, or long int */
long int li = 65536l; /* l or L represent long int */

Bez sufiksu stała ma pierwszy typ, który pasuje do jej wartości, to jest stała dziesiętna, która jest większa niż INT_MAX jest typu long jeśli to możliwe, lub long long przeciwnym razie.

Plik nagłówkowy <limits.h> opisuje limity liczb całkowitych w następujący sposób. Ich wartości zdefiniowane w realizacji powinny być równe lub większe (wartość bezwzględna) z wartościami pokazanymi poniżej, z tym samym znakiem.

Jeżeli wartość przedmiotu typ char znak-rozciąga gdy użyta w wyrażeniu wartość CHAR_MIN powinna być taka sama, jak w przypadku SCHAR_MIN a wartość CHAR_MAX powinna być taka sama, jak w przypadku SCHAR_MAX . Jeśli wartość obiektu typu char nie rozszerza się, gdy jest używana w wyrażeniu, wartość CHAR_MIN powinna wynosić 0, a wartość CHAR_MAX powinna być taka sama jak wartość UCHAR_MAX .

Literały smyczkowe

Dosłowny ciąg znaków w C jest sekwencją znaków, zakończoną dosłownie zero.

char* str = "hello, world"; /* string literal */

/* string literals can be used to initialize arrays */
char a1[] = "abc"; /* a1 is char[4] holding {'a','b','c','\0'} */
char a2[4] = "abc"; /* same as a1 */
char a3[3] = "abc"; /* a1 is char[3] holding {'a','b','c'}, missing the '\0' */

Literałów łańcuchowych nie można modyfikować (i w rzeczywistości można je umieścić w pamięci tylko do odczytu, takiej jak .rodata). Próba zmiany ich wartości skutkuje niezdefiniowanym zachowaniem.

char* s = "foobar";
s[0] = 'F'; /* undefined behaviour */

/* it's good practice to denote string literals as such, by using `const` */
char const* s1 = "foobar";
s1[0] = 'F'; /* compiler error! */

Wiele literałów łańcuchowych jest łączonych w czasie kompilacji, co oznacza, że możesz pisać takie konstrukcje.

/* only two narrow or two wide string literals may be concatenated */
char* s = "Hello, " "World";

/* since C99, more than two can be concatenated */
/* concatenation is implementation defined */
char* s1 = "Hello" ", " "World";

/* common usages are concatenations of format strings */
char* fmt = "%" PRId16; /* PRId16 macro since C99 */

Literały łańcuchowe, takie same jak stałe znaków, obsługują różne zestawy znaków.

/* normal string literal, of type char[] */
char* s1 = "abc";

/* wide character string literal, of type wchar_t[] */
wchar_t* s2 = L"abc";

/* UTF-8 string literal, of type char[] */
char* s3 = u8"abc";

/* 16-bit wide string literal, of type char16_t[] */
char16_t* s4 = u"abc";

/* 32-bit wide string literal, of type char32_t[] */
char32_t* s5 = U"abc";

Typy liczb całkowitych o stałej szerokości (od C99)

/* commonly used types include */
uint32_t u32 = 32; /* exactly 32-bits wide */

uint8_t u8 = 255;  /* exactly 8-bits wide */

int64_t i64 = -65  /* exactly 64 bit in two's complement representation */

Stałe zmiennoprzecinkowe

Język C ma trzy obowiązkowe rzeczywiste typy float , float , double i long double .

float f = 0.314f;        /* suffix f or F denotes type float */
double d = 0.314;        /* no suffix denotes double */
long double ld = 0.314l; /* suffix l or L denotes long double */

/* the different parts of a floating point definition are optional */
double x = 1.; /* valid, fractional part is optional */
double y = .1; /* valid, whole-number part is optional */

/* they can also defined in scientific notation */
double sd = 1.2e3; /* decimal fraction 1.2 is scaled by 10^3, that is 1200.0 */

Nagłówek <float.h> określa różne ograniczenia operacji zmiennoprzecinkowych.

Arytmetyka zmiennoprzecinkowa jest zdefiniowana implementacja. Jednak większość współczesnych platform (arm, x86, x86_64, MIPS) używa operacji zmiennoprzecinkowych IEEE 754 .

C ma również trzy opcjonalne złożone typy zmiennoprzecinkowe, które wywodzą się z powyższego.

Interpretacja deklaracji

Charakterystyczną cechą składniową języka C jest to, że deklaracje odzwierciedlają użycie zadeklarowanego obiektu, tak jak w normalnym wyrażeniu.

Następujący zestaw operatorów o identycznym pierwszeństwie i powiązaniu jest ponownie wykorzystywany w deklaratorach, a mianowicie:

• jednoargumentowy * operator „dereferencji”, który oznacza wskaźnik;
• binarny [] „abonament tablicowy”, który oznacza tablicę;
• operator (1 + n) -ary () „wywołanie funkcji”, który oznacza funkcję;
• () nawiasy grupujące, które zastępują pierwszeństwo i powiązanie pozostałych operatorów z listy.

Powyższe trzy operatory mają następujący priorytet i skojarzenie:

Podczas interpretacji deklaracji należy zacząć od identyfikatora na zewnątrz i zastosować sąsiednie operatory we właściwej kolejności, zgodnie z powyższą tabelą. Każdą aplikację operatora można zastąpić następującymi angielskimi słowami:

Wynika z tego, że początek angielskiej interpretacji zawsze zaczyna się od identyfikatora i kończy na typie, który znajduje się po lewej stronie deklaracji.

Przykłady

char *names[20];

[] ma pierwszeństwo przed * , więc interpretacja jest następująca: names to tablica o rozmiarze 20 wskaźnika do char .

char (*place)[10];

W przypadku użycia nawiasów w celu zastąpienia pierwszeństwa, * jest stosowane jako pierwsze: place jest wskaźnikiem do tablicy o wielkości 10 char .

int fn(long, short);

Nie ma tu żadnego pierwszeństwa: fn to funkcja zajmująca long , short i zwracające int .

int *fn(void);

Najpierw stosuje się () : fn jest funkcją void i zwracającą wskaźnik do int .

int (*fp)(void);

Przesłaniając priorytet () : fp jest wskaźnikiem do funkcji void i zwracającej wartość int .

int arr[5][8];

Tablice wielowymiarowe nie są wyjątkiem od reguły; operatory [] są stosowane w kolejności od lewej do prawej zgodnie ze skojarzeniem w tabeli: arr jest tablicą o rozmiarze 5 lub tablicą o rozmiarze 8 liczby int .

int **ptr;

Oba operatory dereferencyjne mają równy priorytet, więc asocjatywność obowiązuje. Operatory są stosowane w kolejności od prawej do lewej: ptr jest wskaźnikiem do wskaźnika do int .

Wiele deklaracji

int fn(void), *ptr, (*fp)(int), arr[10][20], num;

Zadeklarowane obiekty w powyższym przykładzie to:

• fn : funkcja void i zwracająca int ;
• ptr : wskaźnik do int ;
• fp : wskaźnik do funkcji przyjmującej int i zwracającej int ;
• arr : tablica o rozmiarze 10 tablica o rozmiarze 20 liczby int ;
• num : int .

Alternatywna interpretacja

Ponieważ deklaracje używają kopii lustrzanej, deklarację można również interpretować w kategoriach operatorów, które można zastosować do obiektu i końcowego wynikowego typu tego wyrażenia. Typ, który stoi po lewej stronie, to końcowy wynik uzyskany po zastosowaniu wszystkich operatorów.

/*
 * Subscripting "arr" and dereferencing it yields a "char" result.
 * Particularly: *arr[5] is of type "char".
 */
char *arr[20];

/*
 * Calling "fn" yields an "int" result.
 * Particularly: fn('b') is of type "int".
 */
int fn(char);

/*
 * Dereferencing "fp" and then calling it yields an "int" result.
 * Particularly: (*fp)() is of type "int".
 */
int (*fp)(void);

/*
 * Subscripting "strings" twice and dereferencing it yields a "char" result.
 * Particularly: *strings[5][15] is of type "char"
 */
char *strings[10][20];