sciaga z C, Administracja, Administracja, Administracja i samorząd, Polityka spoleczna, informatyka


Ś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



Wyszukiwarka

Podobne podstrony:
informatyka - ściąga1, Administracja, Administracja, Administracja i samorząd, Polityka spoleczna, i
projektowanie systemów informacyjnych-ściąga, Administracja, Administracja, Administracja i samorząd
Sciaga z Sieci Komputerowych, Administracja, Administracja, Administracja i samorząd, Polityka spole
baza danych sciaga, Administracja, Administracja, Administracja i samorząd, Polityka spoleczna, info
Systemy operacyjne - wykłady, Administracja, Administracja, Administracja i samorząd, Polityka spole
wprowadzenie do sztucznej inteligencji-wyk łady (10 str), Administracja, Administracja, Administracj
podstawy projektowania w C++ - wykład, Administracja, Administracja, Administracja i samorząd, Polit
Forma wykorzystywanej informacji zewnetrznej, Administracja, Administracja, Administracja i samorząd
programowanie liniowe-ćwiczenia, Administracja, Administracja, Administracja i samorząd, Polityka sp
Wykladp, Administracja, Administracja, Administracja i samorząd, Polityka spoleczna, informatyka
Egzamin z informatyki, Administracja, Administracja, Administracja i samorząd, Polityka spoleczna, i
projektowanie systemów informacyjnych (6 str), Administracja, Administracja, Administracja i samorzą
projektowanie systemów (17 str), Administracja, Administracja, Administracja i samorząd, Polityka sp
Informatyka-zagadnienia, Administracja, Administracja, Administracja i samorząd, Polityka spoleczna,
projekt sieci komputerowej (9 str), Administracja, Administracja, Administracja i samorząd, Polityka
Telepraca1, Administracja, Administracja, Administracja i samorząd, Polityka spoleczna, Ochrona srod

więcej podobnych podstron