Język C    

proceduralny język programowania

     koncepcje i rozwiązania podobne do stosowanych w języku Pascal

     Denis Richie 1972 dla systemu operacyjnego UNIX

     „język wewnętrzny” systemu operacyjnego UNIX

standard ANSI - 1989, standard C99 - 1999

     liczne kompilatory i zintegrowane systemy programowania   

rozszerzenia obiektowe C++ 1985 - rozszerzono również część nieobiektową

  przedmiotem wykładu będzie podzbiór języka C++ przeznaczony do programowania strukturalnego

  ostateczna definicja języka programowania kompilator

#include "stdio.h"

void main ( )

{

printf ( "Hello World!" );

}gcc.pdf, c99status.html, Arytma.ppt

Alfabet

Wszystkie znaki 8-bitowego kodu ASCII

litery: A B ... Z a b ... z _

cyfry: 0 1 ... 9

pozostałe

Kody 32 ... 126 : program

Kody 0 ... 31 i większe od 126 : dane tekstowe

Na żądanie UNICODE (UTF-8)

Identyfikatory

Ciągi znaków alfabetu zaczynające się od litery, dalej litery lub cyfry.

Standardowo początkowe 32 znaki, odróżniając duże i małe litery.

 

alfa Alfa AlfA ALFA Cena_Mleka KosztTransportu 

Słowa kluczowe - identyfikatory zastrzeżone.

Komentarze

 

/*

......................

bez zagnieżdżania

........................

*/

// .............................

Typy liczb całkowitych

char short int long long long

signed unsigned

typ signed unsigned bajty

char – 128 , + 127 0 , 255 1

short – 32 768 , + 32767 0 , 65535 2

int,

long

– 2 147 483 648 ,

+ 2 147 483 647

0 ,

4 294 967 295

4

long

long

– 9 223 372 036 854 775 808 ,

+ 9 223 372 036 854 775 807

0 ,

18 446 744 073 709 551 615

8

Typy zmiennopozycyjne 

float double long double

  typ zakres cyfry bajty

float 3.4*1038

7 4

double,long double

1.7*1030

8

15

8

IEEE 754

Liczby całkowite

12 154555 // dziesiętnie

012 03777453 // ósemkowo

0xAB 0x5c5d 0xfff45a // heksadecymalnie

 

Typ liczby :

na podstawie wartości (domyślny int)

  12 25467 // signed int

34760548093 // signed long long

wskazany w zapisie liczby

15L 077777l 0xFF4FFFL // signed long

254ll -457LL 0xAB56LL // signed long long

45211u 0xffau // unsigned int

3000000000ul 0xC56AFB44UL // unsigned long

-120ULL 78ull // unsigned long long

Liczby zmiennopozycyjne 

1.25 0.343 .5 2.

35.56E-12 0.34e2 5e3 17.18E+28

 

Typ liczby :   na podstawie wartości (domyślny double) wskazany w zapisie liczby 

12.545f // float

0.2345676543F // float

0.5e-3l // long double

0.9999998899E456L // long double

Znaki 

Liczby całkowite typu: char

 

 

'a' '5' '+' '.'

'A' '\071' '\x41' '\x5F'

'\n' '\t' '\r' '\\' '\”'

Łańcuchy 

"Programowanie w języku C"

"Wynik : "

"\tImię\tNazwisko\tMiejsce zamieszkania\n"

"\x16\x16\x02" // SYN SYN STX

"Spojrzał i powiedział: \"Nie mogę\"."

  

"ABC"

0x41 0x42 0x43 0x00

Zmienne < identyfikator , wartość >

Deklaracje zmiennych

char signed char

int signed signed int

short short int signed short int

long signed long long int signed

long long signed long long

unsigned char

unsigned int unsigned

unsigned short unsigned short int

unsigned long unsigned long int

unsigned long long

float

double

long double

Deklaracje zmiennych

int i;

char a, b, c;

unsigned long duza_odleglosc;

float KursDolara;

double masa, gestosc;

Definicje zmiennych

int licznik = 125, suma = 0;

float dokladnosc = 0.0005,

uchyb = 0.001;

double moc = 15e6, straty = 1500;

//

double alfa = 3.34, beta, jota = 15.15, kappa;

Stałe  

const int dni = 7, tygodnie = 52;

const float pi = 3.14159, e = 2.71828;

const double Avogadro = 6.022E23;

  Operator przypisania 

int i, j, k;

i = 1; //zmienna i przyjmuje wartość 1

j = i; //zmienna j przyjmuje wartość zmiennej i

k = dni; //zmienna k przyjmuje wartość stałej dni

Notacja Węgierska

Przedrostek Typ danych Przykład

b bool bJeszczeRaz

c char cKodPolecenia

l long lDuzyKaliber

n int nLicznikPierwszy

p wskaźnik pAdresNowejCeny

a tablica anDaneTestowe

s łańcuch znaków sStosownyNapis

Wskaźniki

- lokalizacja

- typ  

Zmienne wskaźnikowe : deklaracje

 

int *pt_i, *pt_j;

double *wsk1, *wsk2;

float moc1, moc2, *wsk_mocy;

void *dowolny, *kazdy;

25.7

wsk_mocy moc1

Operator wyznaczania wskaźnika &

int lampy, widelce;

int *wsk_towaru;

wsk_towaru = & lampy;

................

wsk_towaru = & widelce;

float Korzysc = 2.54;

float *wsk_f;

long *wsk_l;

void *wsk_v;

wsk_f = & Korzysc; // poprawnie

wsk_l = & Korzysc; // błąd

wsk_v = & Korzysc; // poprawnie

int cena = 25, *wsk_cena, **wsk_wsk_cena;

wsk_cena = & cena;

wsk_wsk_cena = & wsk_cena;

 

 

25

wsk_wsk_cena wsk_cena cena

Zmienne wskaźnikowe : definicje

 

int i = 5, j = 7;

int *pt = & i, *pk = & j;

double droga, czas = 100, *wsk1, *wsk_param = & droga;

char *poczatek = "Początek obliczeń\n",

*koniec = "Koniec obliczeń\n",

*napis;

napis = poczatek;

/* wyświetlenie napisu i wykonanie obliczeń */

napis = koniec;

/* wyświetlenie napisu i koniec programu */

Operator dostępu pośredniego *

 

int i = 5, j;

int *wsk = & i;

j = *wsk; // równoważne j = i;

wsk 5 i

float x = 1.5, y, *wx = & x, **wwx = & wx;

y = **wwx; // równoważne y = x;

// 

const double dbK7 = 12e5;

double *wk = & dbK7; // błąd

Wskaźnik do stałej

 

const long *ws_st; //wskaźnik do stałej

const long dystans = 5786;

ws_st = & dystans;

long odleglosc = *ws_st; // poprawnie

// odległość == dystans

*ws_st = 1298; // błąd

 

long war = 10, ukrop;

ws_st = & war;

war = 150; // poprawnie

ukrop = *ws_st; // poprawnie, ukrop = 150

*ws_st = 150; // błąd

Stała wskaźnikowa

 

float cena = 12.5, netto;

float *const swx = & cena;

// stała wskaźnikowa, wartość początkowa konieczna

cena = 15.8; // poprawnie

*swx = 15.8; // poprawnie

swx = &netto; // błąd

swx cena

Referencje 

Każda operacja wykonywana na referencji jest identyczna z operacją wykonaną bezpośrednio na reprezentowanej przez tę referencję zmiennej czy strukturze danych.

 

int kwota;

int &ref_k = kwota;

ref_k = 1254; // równoważne kwota = 1254;

// 

long a, b, &ref_a = a;

ref_a = 12; // równoważne a = 12;

b = ref_a; // równoważne b = a;

float moc_x, &ref_x = moc_x, *wsk_x;

wsk_x = & ref_x; // równoważne wsk_x = & moc_x;

wsk_x = ref_x; // błąd, podobnie jak wsk_x = moc_x; 

double &ref_dok = 1.15E-5; // realizacja :

XX = 1.15E-5; // pomocnicza zmienna wewnętrzna

double &ref_dok = XX; 

unsigned int bin = 0xCFCF;

int &ref_b = bin; // realizacja :

int YY = (int) bin; // unsigned int int

int &ref_b = YY;

ref_b = 15; // nie zmienia wartości // zmiennej bin

Typy wyliczeniowe

enum id_typu { lista_stałych } id_zmiennej ;

 enum dni {ni, po, wt, sr, cz, pi, so}; /* ni == 0, po == 1, ... , so == 6 */ enum dni {ni=1, po, wt, sr, cz, pi, so}; /* ni == 1, po == 2, ... , so == 7 */dni Egzamin, Dobry = cz;Egzamin = Dobry;//enum TW1 {t1, t2, t3 = 0, t4, t5, t6 = 1, t7}; /* t4 == 1, t5 == 2, t7 == 2 *///enum {A = 0x41, B, C, X = 0x58} znak;

// zmienna typu wyliczeniowegoznak = C; // poprawnieznak = 0x41; // błąd Enum

Typ logiczny

bool stan, obecnosc = true;

stan = true;

obecnosc = false;

// 

enum BOOL {FALSE, TRUE}; // 0 , 1

BOOL flaga, status = TRUE;

flaga = FALSE;

status = flaga;

Nazywanie typów danych 

typedef typ nowy_identyfikator

 

typedef char* string;

string S1, S2, S3 = "napis";

 

typedef int num;

num k;

int l = 5;

k = l; // typ num jest równoważny z typem int

 

typedef long BIG;

unsigned BIG ww; // błąd

Wprowadzanie danych 

getch

D. int getch ( );

B. conio.h

F. Kolejny opis klawisza z klawiatury ( oczekiwanie ), bez echa

W. Kod ASCII lub 0

P.

char nowy;

nowy = getch();

//

getche

Jak getch + echo

scanf

 

D. int scanf ( const char *format, wskaźnik, wskaźnik, ... );

B. stdio.h

F. Wczytuje kolejne pola (ciągi znaków do SP lub NL)

ze stdin z echem (BS).

Format - tekst będący ciągiem wzorców konwersji.

Wzorzec konwersji: 

% [ * ] [ szerokość ] [ prefiks ] znak_konwersji

 

W. Liczba wczytanych pól znaków

P.

int liczba_sztuk;

scanf ( "%d", &liczba_sztuk );

double szerokosc;

scanf( "%lf", &szerokosc );

scanf( "%lf%d", &szerokosc, &liczba_sztuk );

int lampy, krzesla, *wsk = &krzesla;

float temp;

double cena;

char opcja;

//

scanf( "%d%d%f%lf", &lampy, wsk, &temp, &cena );

// 1 5 SP 3 4 7 Enter - 2 5 . 4 Enter // 3 . 9 9 Enter

// lampy == 15 krzesla == 347

// temp == -25.4 cena == 3.99

// wczytywanie pojedynczych znaków

fflush(stdin); // oczyszczenie bufora klawiatury

scanf( "%c", &opcja );

// A Enter

// opcja == 'A'

// wczytywanie tekstów

char Tekst[16]; // tablica 16 elementowa

scanf ( "%15s", Tekst );

// A l f a Enter

// Tekst == "Alfa"

scanf ( "%15[ -~]", Tekst );

// A l a SP m a SP k o t a . Enter

// Tekst == "Ala ma kota."

In

gets_s

 

D. char* gets_s ( char *tekst, int rozmiar ) ;

B. stdio.h

F. Odczytuje ze stdin ciąg znaków (z SP, HT) z echem do NL,

liczba znaków ograniczona przez rozmiar

W. Tekst lub NULL

P.

gets_s( Tekst );

Wyprowadzanie danychputchar

 

D. int putchar ( int c ) ;

B. stdio.h

F. Znak do stdout

W. Argument c lub EOF

P.

char cc = 'R';

putchar ( cc );

// 'R' na ekran

puts

 

D. int puts ( char *napis );

B. stdio.h

F. Do stdout ciąg znaków + NL

W. !0 lub EOF

P.

 

#include <stdio.h>

void main( )

{

char *nn = "Napis ćwiczebny.";

puts(nn);

}

printf 

D. int printf ( const char *format, wyrażenie, wyrażenie, ... );

B. stdio.h

F. Do stdout ciągi znaków reprezentujących wartości wyrażeń

Format :

  - znaki przesyłane bezpośrednio do stdout

   - wzorce konwersji

P.

int liczba_kolorow = 256;

printf( "%d", liczba_kolorow );

double odjetosc = 15.72;

printf( "%lf", objetosc );

char *Tekst = "Dokumentacja.";

printf ( "%s", Tekst);

Wzorzec konwersji :

% [ opis ] [ szerokość ] [ precyzja ] [ prefiks ] znak_konwersji

opis :

- uzupełnianie znakami spacji z prawej strony

+ wyprowadzanie znaku liczby

SP znak spacji zamiast znaku plus

 

szerokość :

- minimalna liczba znaków dla liczb

- maksymalna liczba znaków dla ciągów znaków

precyzja :

. liczba_miejsc_po_kropce

int Alfa = 5;

float Beta = 12.45;

printf ( "Wynik: \n Alfa = %d,\t Beta = %f\n",

Alfa, Beta + 500);

// Wynik:

// Alfa = 5, Beta = 512.450000

char opcja = 'X';

char *Napis = "Opis programu.";

printf("Wybrano opcję %c : %31s", opcja, Napis );

// Wybrano opcję X : Opis programu.

int koty = 2, *wsk_k = &koty;

float test = 23.345678;

double wynik = -0.01234567;

//

printf("Liczba kotów : %d", *wsk_k );

printf("\nWynik testu = %12.3f\n"

"Razem = %.5lf\n", test + 5, wynik );

// Liczba kotów : 2

// Wynik testu = 28.345

// Razem = -0.01234

Out

Wyrażenia 

Wyrażenia elementarne : liczby, znaki, zmienne, stałe, wywołania funkcji

Operatory : jedno- dwu- lub trójargumentowe o ustalonych priorytetach

Nawiasy okrągłe dla ustalenia kolejności obliczeń.

operator przypisania =

operator dostępu pośredniego *

operator wyznaczania wskaźnika &

 

Konwersja wartości

lewy Ø prawy typ ( lewy ) == typ ( prawy )

 

Konwersja rozszerzająca zwiększenie liczby bajtów

Konwersja zawężająca zmniejszenie liczby bajtów

int li32 = 21212345;

long long li64 = li32; // konwersja rozszerzająca

short li16 = li32; // konwersja zawężająca

// strata danych li16 == -21319

Dla operatora = konwersja na typ lewej strony ( możliwa strata informacji )

char c;

c = 258; // c == ?

Konwersja typu na życzenie programisty rzutowanie 

typ ( wyrażenie )( typ ) wyrażenie

 int ile = 27;float tyle = 1.4; ile = ile + tyle;

/* konwersja 27 na 27.0, dodawanie zmiennopozycyjne,

konwersja 28.4 na 28, przypisanie */ ile = ile + (int) tyle;

/* konwersja 1.4 na 1, dodawanie całkowitoliczbowe,

przypisanie */

int i, *wsk_i = & i;float *wsk_f;wsk_f = ( float* ) & i;wsk_f = ( float* ) wsk_i;

Operatory arytmetyczne 

* / + – % 

int liczba, nieparzystosc;

nieparzystosc = liczba % 2; // 0 - p, 1 - np

 

(3 * x * x + 5 * x - 1) /

(7 * x * ((2 * x + 3) * (1 - x) + 5) + 3)

int a = 1700000000, b = 1900000000, suma;

suma = a + b; // nadmiar stałopozycyjny

float x = 0.5e35, y = 0.2e5, z;z = x * y; // nadmiar zmiennopozycyjny 

3]5)1)(32[(7

153 2

xxx

xx

OverHole, Wielkanoc

Operatory zmniejszania i zwiększania 

++ –– 

++alfa ––beta // przed obliczeniem wyrażenia

alfa++ beta–– // po obliczeniu wyrażenia

 

float x = 2.5, y;

x ++ ; // równoważne x = x + 1;

++ x ; // równoważne x = x + 1;

x -- ; // równoważne x = x - 1;

-- x ; // równoważne x = x - 1;

y = ++(2 * x); // błąd

 

int i = 3, j = 4, s;

s = j++ + i; // s == 7 j == 5

j = 4;

s = ++j + i; // s == 8 j == 5

Operatory relacyjne0 : false

nie 0 : true 

< <= == != >= > 

bool mniejsze, rowne, nierowne, wiekszerowne;

int i = 5; float x = 12.3;

mniejsze = i < x; // true

rowne = i == x; // false

nierowne = i != x; // true

wiekszerowne = i >= x; // false

 

double x = 1.5E-5, y = x;

double *wsk_x = & x, *wsk_y = & y;

rowne = wsk_x == wsk_y; // false

wsk_x = & y;

rowne = wsk_x == wsk_y; // true

Operatory logiczne 

! && ||

int a, b, c;

bool z;

z = a < b && b < c; // a < b < c 

int rok = 2000;

bool przestepny;

przestepny = !(rok % 4) && rok % 100 ||

!(rok % 400);

( a > b ) && ( k <= f++ ) // optymalizacja

( k > 5 ) || (c < ( b = 7 ) )

Operatory bitowe 

Wi = Ai Bi 

~ & | ^ << >> 

int i = 35, przeciwna, parzystosc, r, s;

przeciwna = ~ i + 1; // równoważne - i;

nieparzystosc = i & 1;

r = i << 2; // równoważne r = i * 4;

s = i >> 3; // równoważne s = i / 8; 

char a = 'r', b = 8;

a = a & 0x5F; // zamiana małych liter ASCII na duże

b = b | 0x30; // zamiana wartości binarnej 0-9 // na kod znaku ASCII

Złożone operatory przypisania 

*= /= %= += –= <<= >>= &= ^= |=

 

double kurs, zwyzka;

kurs += zwyzka; // kurs = kurs + zwyzka;

 

int x = 10;

x -= 5 – 2 ; // ?

 

int i, j, k;

i = (j = 5) + 1; // równ. j = 5; i = j + 1;

i = j = k = 0; // równ. i = 0; j = 0; k = 0;

Operator warunkowy 

wyrażenie_1 ? wyrażenie_2 : wyrażenie_3

  

float x, y, max;

max = x > y ? x : y;

 

Operator rozmiaru

long liczba_1;

dlugosc_1 = sizeof liczba_1; // == 4

dlugosc_1 = sizeof long; // == 4

Operator wyliczenia 

long a1, a2, a3, s;

s = ( a1 = 52700, a2 = 31300, a3 = a1 + a2 );

// a3 == 84000 s == 84000

s = a1 = 52700, a2 = 31300, a3 = a1 + a2;

// s = ?

float x, y ,z;

z = ( x = 5.3, y = 2.5, y++ );

// y == 3.5 z == 2.5

Priorytety i łączność operatorów

// lewostronnie łączny 

// prawostronnie łączny

char a,b,c,d,e;

a + b - c - d + e;

/* lewostronnie łączne czyli

(((a + b) - c) - d) + e; */ 

a ? b : c ? d : e;

/* prawostronnie łączny czyli

a ? b : (c ? d : e); */

A B C (( ) )A B C ( ( ))A B C

P1, P2, P3, P4