Ściąga z języka C
Opis języka programowania C i C++ stworzony przez Piotra Różnickiego na podstawie pliku cquickref.txt autorstwa Bruce M. Simpson'a, materiałów z ćwiczeń oraz własnych informacji i innych opracowań
--------------------------------------------------------------------------------
"Opis jezyka programowania C i C++ - Indeks"
--------------------------------------------------------------------------------
"O tym opisie"
"Indeks alfabetyczny"
"Instrukcje sterujące"
"Typy danych(podstawowe i pochodne)"
"Słowa kluczowe"
"operatory"
"Wyrażenia i konstrukcje języka"
"Funkcje odnoszące się do znaków"
"Funkcje matematyczne"
"Funkcje odnoszące się do ciągów"
"Komendy formatujące funkcji scanf()"
"Komendy formatujące funkcji printf() "
"Przykłady użycia funkcji printf()"
"Stałe reprezentujące znaki specjalne w ciągach"M
"Komendy preprocesora"
"Struktury i wskaźniki"
Powrót na początek strony
--------------------------------------------------------------------------------
"Indeks alfabetyczny"
"O tym przewodniku"
"Asocjacja operatorów i kolejność"
"Bitowe operatory"
"Deklaracja unii"
"Funkcje"
"Funkcje standardowe biblioteki math"
"Funkcje znakowe"
"Index alfabetyczny"
"Inicjacja"
"Komendy formatujące dla printf()"
"Komendy formatujące scanf()"
"Operator przecinkowy"
"Operator warunkowy"
"Operatory arytmetyczne"
"Operatory logiczne"
"Operatory porównania"
"Operatory"
"Operatory unarne"
"Opis jezyka programowania C - Indeks"
"Pascal a C - reprezentacja zmiennych"
"Podstawowe typy zmiennych"
"Przykłady użycia printf()"
"Relatywny koszt operacji"
"Składnia definicji typu"
"Składnia deklaracji struktury"
"Składnia konstrukcji C"
"Składnia wyliczeniowej deklaracji typu"
"Składnia wyrażenia 'do..while' "
"Składnia wyrażenia 'for' "
"Składnia wyrażenia IF"
"Składnia wyrażenia 'switch'"
"Składnia wyrażenia 'while' "
"Słowa zarezerwowane"
"Standardowe funkcje dla ciągów"
"Standardowe komendy preprocessora ANSI"
"Struktury i relacje wskaźników"
"Wywoływanie funkcji, operatory selekcji"
"Złożone operatory przypisania"
" Znakowe stałe"
Powrót na początek strony
--------------------------------------------------------------------------------
"O tym przewodniku"
Ten przewodnik po strukturze języka C nie jest dokładnym opisem ani definicją standardu.
Ma on służyć jako szybka pomoc w trakcie programowania z użyciem języka C lub C++.
Przewodnik może być używany bez żadnej opłaty.
Autor nie udziela żadnych gwarancji dotyczących niezawodności , aktualności oraz prawdziwości informacji tu zamieszczonych.
Autor nie gwarantuje, że opis spełni wymagania użytkownika i jego używanie nie uszkodzi komputera użytkownika .
Opis można uzywać za darmo w dowolnej ilości kopii.
Rozpowszechnianie opisu jest dozwolone jednak powinno się o tym fakcie powiadomić autora.
Wszelkie dodatkowe informacje dostępne są pod emailowym adresem :
roznicki@figaro.ae.katowice.pl
Tekst powstał na podstawie tekstu Bruce M. Simpsona dostępnego pod adresem email bsimpson@touchdwn.demon.co.uk
Tekst pierwotny został prztłumaczony oraz wzbogacony w istotnych (dla autora) miejscach.
Jeśli autor otrzyma takie prośby i wsparcie tekst może zostać znacznie rozszeżony...
Więc najlepiej dodaj tę stronę do bookmarków i często tu zaglądaj!
Powrót na początek strony
--------------------------------------------------------------------------------
"Podstawowe typy zmiennych"
Typ Rozmiar (bity) Opis
int 32 całkowite
char 8 znakowe
short 16 krótkie całkowite
long 32 długie całkowite
float 32 zmiennoprzeinkowe pojedynczej precyzji
double 64 zmiennoprzeinkowe pojedwójnej precyzji
void ?? typ pusty
(Rozmiary podane zostały dla kompilatorów 32 bitowych)
W zależności od kompilatora rozmiary te mogą się różnić lub może być ich więcej
Przykład dla Borland C++ Builder
Typ Rozmiar (bitów) Zakres
unsigned char 8 bitów 0 do 255
char 8 bitów -128 do 127
short int 16 bitów -32,768 do 32,767
unsigned int 32 bitów 0 do 4,294,967,295
int 32 bity -2,147,483,648 do 2,147,483,647
unsigned long 32 bity 0 do 4,294,967,295
enum 16 bitów -2,147,483,648 do 2,147,483,647
long 32 bity -2,147,483,648 do 2,147,483,647
float 32 bity 3.4 x 10-38 do 3.4 x 10+38
double 64 bitów 1.7 x 10-308 do 1.7 x 10+308
long double 80 bitów 3.4 x 10-4932 do 1.1 x 10+4932
Typy stałych oznaczamy słowem kluczowym const, np.:
const float pi=3.14;
Pochodne typy zmiennych:
"Tablice"
"Definicja typu"
"Struktury"
"Unie"
"Składnia wyliczeniowej deklaracji typu(enum)"
Powrót na początek strony
--------------------------------------------------------------------------------
"Operatory"
Całkowite i arytmetyczne operatory zachowują się tak jak zwykle np.:
(2 + 2)*2 da wynik 8 a 2 + 2 *2 da wynik 6 . Reszta regół jest analogiczna z matematycznymi
"Porządek pierwszeństwa"
"Koszt relatywny operatorów"
"Arytmetyczne operatory"
"Bitowe operatory"
"przecinkowy operator"
"Operatory porównania"
"Operatory złożonego przydziału"
"Operator warunkowy"
"Wywoływanie funkcji, operatory selekcji"
"Operatory logiczne"
"Operatory unarne"
"Operator zasięgu"
Powrót na początek strony
--------------------------------------------------------------------------------
"Wywoływanie funkcji, operatory selekcji"
Operator Składnia Opis
() funcname() Wywołanie funkcji
[] arrayptr[] Wywołanie tablicy
. struct.member Bezpośrednia selekcja członka
-> structptr-> Pośrednia selekcja członka
Powrót na początek strony
--------------------------------------------------------------------------------
"Operatory unarne"
operator Operacja Operatory Typ rezultatu
* wskazywanie wskaźnik do dowolnego typu typ bazowy
& adres zmienna dowolnego typu wskaźnik do typu
- negacja arytmetyczny arytmetyczny
! logiczna negacja arytmetyczny albo wskaźnik całkowity
~ uzupełnienie liczba całkowita int, long lub unsigned
++ inkrementacja arytmetyczny albo ptr arytmetyczny
-- dekrementacja arytmetyczny albo ptr arytmetyczny
(type) zmiana typu dowolny typ określony typ
sizeof() rozmiar wyrażenie albo typ unsigned
Uwaga: zmienne arytmetyczne są zwiększane o 1 a zmienne typu wskaźnikowego o ilość bajtów odpowiadającą wielkości obiektu wskazywanego przez wskaźnik.
Ważne jest miejsce operatora : ++cos najpierw zwiększy a cos++ zwiększy potem.;-)
Powrót na początek strony
--------------------------------------------------------------------------------
"Operatory arytmetyczne"
Operator Operacja Operand Typ rezultatu
* mnożenie arytmetyczny arytmetyczny
/ dzielenie arytmetyczny arytmetyczny
% modulo liczba całkowita liczba całkowita
+ dodawanie arytmetyczny lub ptr liczba całkowita lub ptr
- odejmowanie aritmetyczny lub ptr liczba całkowita lub ptr
Powrót na początek strony
--------------------------------------------------------------------------------
"Bitowe operatory"
Operator Operacja Operatory Typ rezultatu
<< przesunięcie w lewo liczba całkowita taki sam jak operand
>> przesunięcie w prawo liczba całkowita taki sam jak operand
& bitowe and liczba całkowita liczba całkowita
^ bitowe xor liczba całkowita liczba całkowita
| bitowe or liczba całkowita liczba całkowita
Uwaga: 0 jest wstawiane do nowych bitów ( po przesunięciu) chyba ,że przesunięcie w prawo i liczba ze znakiem (SIGNED) - wtedy znak kopiuje się na nowe miejsce.
Powrót na początek strony
--------------------------------------------------------------------------------
"Operatory porównania"
Operator Operacja Operatory Typ rezultatu
< miejszy niż arytmetyczny lub ptr liczba całkowita
> większy niż arytmetyczny lub ptr liczba całkowita
<= miejszy lub równy arytmetyczny lub ptr liczba całkowita
>= większy lub równy arytmetyczny lub ptr liczba całkowita
== równy arytmetyczny lub ptr liczba całkowita
!= różny od arytmetyczny lub ptr liczba całkowita
Powrót na początek strony
--------------------------------------------------------------------------------
"Operatory logiczne"
Operator Operacja Operatory Typ rezultatu
&& logiczne and arytmetyczny lub ptr liczba całkowita
|| logiczne or arytmetyczny lub ptr liczba całkowita
Drugi operand operatora logicznego jest liczony tylko jeśli to konieczne.
Powrót na początek strony
--------------------------------------------------------------------------------
"Operator warunkowy"
Składnia
wyrażenie ? jeśli_true : jeśli_false
Uwagi
Wartość tego wyrażenia jest równa jeśli_true jeśli wyrażenie jest prawdą - w przeciwnym wypadku wartośc to jeśli_false.
Powrót na początek strony
--------------------------------------------------------------------------------
"Złożone operatory przypisania"
Te operatory służą do skrócenia zapisu operacji np.:
a +=2 jest równoznaczne a = a +2
Operator Operacja Operatory
+= dodawanie arytmetyczny
-= odejmowanie arytmetyczny
*= mnożenie arytmetyczny
/= dzielenie arytmetyczny
%= modulo liczba całkowita
>>= przesunięcie bitów w prawo liczba całkowita
<<= przesunięcie bitów w lewo liczba całkowita
&= bitowe AND liczba całkowita
^= bitowe XOR liczba całkowita
|= bitowe lub liczba całkowita
Powrót na początek strony
--------------------------------------------------------------------------------
"Operator przecinkowy"
Składnia
wyrażenie1, wyrażenie2
Uwaga:
Mie mylić z przecinkami używanymi w funkcjach ,definicjach i deklaracjach!
Wyrażenie1 jest obliczane pierwsze a typ wyniku jest jak typ wyrażenia2
Przykład:
z = (x=2,y=3,y++);
Wynikiem beda tu wartości x równe 2,y równe 4 oraz z równe 3(wartość z nie będzie równa 4 bo użyto y++ a nie ++y)
Powrót na początek strony
--------------------------------------------------------------------------------
"Asocjacja operatorów i kolejność"
Operatory są wypisane w malejącym porządku.
LR oznacza operator obliczany od lewej do prawej a RL od prawej do lewej Kierunek wykonywania Operatory
LR () [] -> .
RL ! ~ ++ -- - * & (type) sizeof
LR * / %
LR + -
LR << >>
LR < <= > >=
LR == !=
LR &
LR ^
LR |
LR &&
LR ||
RL ?
RL = += -= *= /= %= &= ^= |= <<= >>=
LR ,
Powrót na początek strony
--------------------------------------------------------------------------------
"Relatywny koszt operacji"
Operacja Relatywny koszt
Standardowe IO (printf..) 1000
Trygonometryczne funkcje 500
Zmiennoprzecinkowe 100
Dzielenie liczby całkowitej 30
Mnożenie liczby całkowitej 20
Wywołanie funkcji 10
Odwołanie do tablicy 6
Bitowe przesunięcie 5
Dodawanie ,odejmowanie 5
Operacje ze wskaźnikiem 2
Bitowe AND / lub / NOT 1
Logiczne AND / lub / NOT 1
Powrót na początek strony
--------------------------------------------------------------------------------
"Operator zasięgu"
Pozwala na użycie wartości zmiennej globalnej przesłoniętej przez zmienną lokalną.
Postać : ::nazwa_zmiennej
Obecny tylko w C++
Powrót na początek strony
--------------------------------------------------------------------------------
"Struktury i relacje wskaźników"
structure.item = (*structure_ptr).item = structure_ptr->item
*(znakowe_ptr) = znakowe_ptr[0]
*(znakowe_ptr + n) = znakowe_ptr[n]
*a[i] = wskazanie do i-tego obiektu a.
(*b)[i] = i-ty element tablicy wskazywanej przez b.
Przykład używania wskaźników i adresów :
int i = 1; j = 10;
int* wski; // deklaracja zmiennej wski typu int*
wski = &i; // teraz wski wskazuje na i. *wski==1
j = *wski; // teraz j==1
Powrót na początek strony
--------------------------------------------------------------------------------
"Składnia konstrukcji C"
"Wyliczanie"
"Funkcje"
"Inicjacja"
"Struktury"
Instrukcje sterujące
"if"
"switch"
"for"
"while"
"do..while"
"Definicja typu"
"Unie"
Powrót na początek strony
--------------------------------------------------------------------------------
"Składnia wyrażenia IF"
if (wyrazenie_spr) wyrazenie1;<else wyrazenie2;>
<else wyrazenie;> jest opcjonalne.
Wartość wyrazenia_spr może być 0 (fałsz) jub <>0 (prawda), jeśli jest <>0 to wykonywane jest wyrażenie1 w przeciwnym wypadku wyrażenie2
Przykład : if(ocena>2) cout<< "zaliczyłeś przedmiot\n";
Powrót na początek strony
--------------------------------------------------------------------------------
"Składnia wyrażenia 'switch'"
etykieta to możliwy wynik wyrażenia
switch (wyrażenie)
{
case etykieta1: wyrażenia-1
case etykieta2: wyrażenia-2
case etykietan: wyrażenia-n
default : wyrażenia-defaultowe
}
Przykład:
int ocena;
switch(ocena)
{
case 5 :
cout << "Dostałeś piątkę \n";
break;
case 4 :
cout << "Dobra ocena \n";
break;
case 3 :
cout << "Oj cos slabo \n";
break;
default :
cout << "Hmm cos musisz zmienic " << ocena
<< " - nie pozwala na zaliczenie roku !";
break;
}
Powrót na początek strony
--------------------------------------------------------------------------------
"Składnia wyrażenia 'for' "
for (inicjacja wartości; warunek nie przerwania pętli; następna wartość) wyrażenie;
Przykład : for (int i=0;i<10;i++) cout << i;//wyświetli cyfry niczym nie oddzielone od 0 do 9
Powrót na początek strony
--------------------------------------------------------------------------------
"Składnia wyrażenia 'while' "
while ( wyrażenie-sprawdzane ) wyrażenie;
Przykłąd: while(i<10) cout << i;
Powrót na początek strony
--------------------------------------------------------------------------------
"Składnia wyrażenia 'do..while' "
do wyrażenie while (wyrażenie-sprawdzane);
Uwaga
W tym przypadku wyrażenie jest obliczane po wykonaniu pętli.
Powrót na początek strony
--------------------------------------------------------------------------------
"Składnia definicji typu"
typedef <type> <type-name>
Powrót na początek strony
--------------------------------------------------------------------------------
"Składnia wyliczeniowej deklaracji typu"
enum <tag>
{
nazwa1 [=wyrażenie stałe1],
nazwa2 [=wyrażenie stałe2],
...
nazwaN [=wyrażenie stałen]
};
Powrót na początek strony
--------------------------------------------------------------------------------
"Tablice"
Deklaracja tablicy
typ_elementu nazwa_tablicy[wymiar_1][wymiar_2] . . . [wymiar_N] ;
Przykład: float macierz[3][3];//dwuwymiarowa tablica: 3 wiersze po 3 kolumny
UWAGA
w języku C tablice są zawsze indeksowane od zera!
w języku C nie jest sprawdzana zgodność indeksu z wymiarami tablicy !
Powrót na początek strony
--------------------------------------------------------------------------------
"Składnia deklaracji struktury"
Deklaracja struktury
struct <tag>
{
typ1 nazwa1;
typ2 nazwa2;
...
typN nazwaN;
};
Definicja struktury
struct [tag] |
[{ typ-1 nazwa-1;
typ-2 nazwa-2;
... ...
typ-n nazwa-n;
}]
;
Powrót na początek strony
--------------------------------------------------------------------------------
"Deklaracja unii"
union <tag>
{
komponent-1;
komponent-2;
...
komponent-n;
}
Powrót na początek strony
--------------------------------------------------------------------------------
"Inicjacja"
var = <wartość początkowa>
var = { <wartość początkowa-lista> }
var = { <wartość początkowa-lista>, }
var = "<sekwencja znaków>"
Powrót na początek strony
--------------------------------------------------------------------------------
"Funkcje"
Definicja funkcji
<typ rezultatu> <nazwa funkcji>()
{
<deklaracja typów,definicja zmiennych, deklaracje>
<wyrażenia>
}
Deklaracja funkcji
<typ rezultatu> <nazwa funkcji>(<definicja parametrów>);
Wywołanie funkcji
<nazwa funcji>(<argumenty>)
Powrót na początek strony
--------------------------------------------------------------------------------
" Znakowe stałe"
Stała ASCII Opis
\n LF linefeed
\t HT horizontal tab
\v VT vertical tab
\b BS backspace
\r CR carriage return
\f FF formfeed
\a BEL alert
\\ \ backslash
\? ? question mark
\' ' single quote
\" " double quote
\ooo ooo octal number
\xhh xhh hexadecimal number
\0 NUL NUL znakowe
Powrót na początek strony
--------------------------------------------------------------------------------
"Standardowe komendy preprocessora ANSI"
komenda Składnia Opis
#define identifier token string definiuje identyfikator
#define id (id, ...) token string definiuje makro
#undef identifier kasuje definicje identyfikatora lub makra
#include "filename" włączenie pliku z aktualnego katalogu
#include <filename> włączenie pliku z katalogów włączeń(definiowanych)
#include token-sequence include ?
#if constant-wyrażenie if wyrażenie is true...
#ifdef identifier if identyfikator jest zdefiniowany...
#ifndef identifier if identyfikator nie jest zdefiniowany....
#elif constant-wyrażenie else if wyrażenie is true...
#else else...
#endif kończy wyrażenie warunkowe
#line constant "filename" zmien licznik linii w pliku
#line constant zmien licznik linii **
#error token-sequence(opt) spowoduj błąd
#pragma token-sequence(opt) specyficzne dla kompilatora
# nic nie rób
Powrót na początek strony
--------------------------------------------------------------------------------
"Słowa zarezerwowane"
auto double int struct
break else long switch
case enum register typedef
char extern return union
const float short unsigned
continue for signed void
default goto sizeof volatile
do if static while
Powrót na początek strony
--------------------------------------------------------------------------------
"Komendy formatujące scanf()"
Komenda Opis Typ operanda
%d dziesiętna liczba całkowita int *
%i liczba całkowita int *
%o ósemkowa liczba całkowita int *
%u dziesiętna liczba całkowita bez znaku unsigned int *
%x szesnastkowa liczba całkowita int *
%c znak char *
%s ciąg char[] lub char *
%e,f,g liczba zmiennoprzecinkowa float *
%p wskaźnik void *
%% znak % n/a.
Uwaga: '%p' nie jest uwzględnione w standardzie ANSI.
Przykład programu:
#include
void main(void)
{
int x;
double y;
char znak;
printf( "Podaj jedna liczbe calkowita: " );
scanf ( "%d" , &x );
printf( "Podaj jedna liczbe rzeczywista i jeden znak: ");
scanf ( "%lf %c" , &y , &znak );
}
Powrót na początek strony
--------------------------------------------------------------------------------
"Komendy formatujące dla printf()"
Komenda Opis Typ operanda
%d,i dziesiętna notacja int
%ld długa liczba całkowita dziesiętna int
%o ósemkowa bez znaku int
%x,X szesnastkowa bez znaku int
%u dziesiętna bez znaku unsigned int
%c znak int lub char
%s ciąg char[] char *
%f dziesiętna notacja double lub float
%e,E notacja naukowa double lub float
%g,G krótkie %e lub %f double lub float
%p wskaźnik void *
%% znak % n/a
Powrót na początek strony
--------------------------------------------------------------------------------
"Przykłady użycia printf()"
%3d wyświetli 3 cyfry wyrównane do prawej
%3.0f nie wyświetli przecinka i liczby po nim
%3.1f wyświetli jedną cyfrę po przecinku
%.1f wyświetli tylko cyfrę po przecinku
Formatowanie:
:%10s: :hello, world:
:%-10s: :hello, world:
:%20s: : hello, world:
:%-20s: :hello, world :
:%20.10s: : hello, wor:
:%-20.10s: :hello, wor :
:%.10s: :hello, wor:
Przykład programu:
#include
void main(void)
{
int x = 10;
long y = 20;
double s;
s = x + y;
printf ( "%s obliczen %d + %ld = %f" , "Wynik" , x , y , s );
}
Powrót na początek strony
--------------------------------------------------------------------------------
"Funkcje standardowe biblioteki math"
Funkcja Opis
sin(x) sinus
cos(x) kosinus
tan(x) tangens
asin(x) arcussinus
acos(x) arcuscosinus
atan(x) arcustangens
atan2(y,x) arcustangens (x / y)
sinh(x) sinus hiperboliczny
cosh(x) kosinus hiperboliczny
tanh(x) tangens hiperboliczny
exp(x) funkcja wykładnicza
log(x) logarytm naturalny
log10(x) logarytm dziesiętny
pow(x,y) x do potęgi y
sqrt(x) pierwiastek kwadratowy z x
ceil(x) najmniejsza liczba całkowita nie mniejsza niż x
floor(x) największa liczba całkowita nie większa niż x
fabs(x) wartość bazwzględna
fmod(x,y) reszta z dzielenia x/y
Powrót na początek strony
--------------------------------------------------------------------------------
"Standardowe funkcje dla ciągów"
Funkcja Opis
strcat(s,t) dopisz t do końca s
strncat(s,t,n) dopisz n znakow t do końca s
strcmp(s,t) <0 if(s<t), 0 if(s==t), >0 if(s>t)
strncmp(s,t,n) porównuje tylko n pierwszych znaków
strcpy(s,t) kopiuje t do s
strncpy(s,t,n) kopiuje n znaków z t do s
strlen(s) zwraca długość s
strchr(s,c) zwraca wskaźnik do pierwszego c w s, albo NULL
strrchr(s,c) zwraca wskaźnik do ostatniego c w s, albo NULL
Powrót na początek strony
--------------------------------------------------------------------------------
"Funkcje znakowe"
Funkcja / Makro Opis
isalpha(c) czy c jest znakiem z alfabetu ?
isupper(c) czy C jest duże ?
islower(c) czy C jest małe ?
isdigit(c) czy c jest cfrą [0..9] ?
isalnum(c) czy c jest znakiem alfanumerycznym ?
isspace(c) czy c jest separatorem (spacja, TAB, LF, FF, VT lub CR) ?
toupper(c) zwraca c duże
tolower(c) zwraca c małe
Powrót na początek strony
--------------------------------------------------------------------------------
"Pascal a C - reprezentacja zmiennych"
Typ Pascalowy Typ C
liczba całkowita int
LONGINT long
CHAR int
BOOLEAN char
Byte Byte(struct), int(passed)
VAR Byte int *
Handle Handle
VAR Handle Handle *
Ptr Ptr
VAR Ptr Ptr *
OSType, ResType long
PACKED ARRAY[] long
String255 Str255 lub char *
VAR String255 Str255 lub char *
StringPtr StrPtr lub char *
VAR StringPtr StrPtr * lub char *
Rect Rect *
VAR Rect Rect *
Point Point
VAR Point Point *
Powrót na początek strony
--------------------------------------------------------------------------------
Praca pochodzi z serwisu www.e-sciagi.pl