Podstawy Programowania – Wykład 2
OGÓLNA STRUKTURA PROGRAMU
/* NAGŁÓWEK PROGRAMU
Nazwa programu, krótkie dane o autorze (względnie firmie), notatka odnośnie praw autorskich, przeznaczenie programu, data ostatniej aktualizacji, nazwa kompilatora oraz ewentualne uwagi odnośnie kompilowania, konsolidowania („linkowania”), a także wykonania. */
#include (włączenia tekstowe) /* specyfikacje włączanych plików bibliotecznych (standardowych) oraz własnych (niestandardowych); mogą w zasadzie wystąpić w dowolnym miejscu programu */
#define stałe, makroinstrukcje
/* definicje dotyczące całego
tekstu programu */
ZMIENNE GLOBALNE
PROTOTYPY FUNKCJI
/* muszą wystąpić przed „ciałami” (kodem) funkcji, aby w dalszej części programu nie było odwołań do obiektów nieznanych kompilatorowi */
FUNKCJA main()
/* funkcja wykonywana jako pierwsza, do której system operacyjny przekazuje sterowanie po wywołaniu programu użytkownika */
FUNKCJE (ich kod!) POZOSTAŁE
Zaleca się, aby dłuższe funkcje lub grupy funkcji umieszczane były w osobnych plikach. Istnieje wówczas możliwość włączania tych funkcji przez inne programy.
Zaleca się parametryzację i „uniwersalizację” opracowywanych modułów (funkcji i makroinstrukcji)
W2 - 1
Podstawy Programowania – Wykład 2
PRZYGOTOWYWANIE I URUCHAMIANIE PROGRAMU
FAZA BEZ KOMPUTERA
• Rozpoznanie problemu
• Znalezienie odpowiedniej metody rozwiązania
• Opracowanie projektu programu (opis metod, algorytmy, schematy blokowe, struktury danych, specyfikacje, itd.)
• Sporządzenie dokumentacji projektowej (funkcjonalnej) FAZA Z KOMPUTEREM (praca ze sprzętem, faza uruchamiania)
• Zakodowanie programu
• Kompilacja
• Testowanie
• Diagnostyka błędów
• Dokumentacja dla użytkownika (strukturalna)
KONSTRUKCJE STERUJĄCE
1. STRUKTURA PROSTEGO PROGRAMU w C
void main(void)
{
instrukcja; ....
instrukcja;
}
.
#include<stdio.h>
void main(void)
{
printf(“\nMoja pierwsza proba\n”);
}
W2 - 2
Podstawy Programowania – Wykład 2
2. PĘTLA for
.
for(j=0; j<10; j++)
/*pętla z jedną instrukcją*/
instrukcja;
.
for(j=0; j<10; j++)
/*pętla z wieloma instrukcjami*/
{
instrukcja; ....
instrukcja;
}
.
for(j=0, inny=0; j<10; j++, inny++)
/* wiele instrukcji inicjujących i inkrementujących */
.
3. PĘTLA while
.
while(ch != ‘x’)
/* pętla z jedną instrukcją*/
instrukcja;
.
while(y < 10)
/* pętla z wieloma instrukcjami*/
{
instrukcja; ....
instrukcja;
}
.
while(getchar()!=‘x’)
instrukcja;
/*zamiast zmiennej - funkcja (!)*/
.
W2 - 3
Podstawy Programowania – Wykład 2
while((ch=getchar())!=‘x’)
/* instrukcja przypisania */
{
/* w miejscu zmiennej (!!)*/
instrukcja; ....
instrukcja;
}
.
4. PETLA do while
.
do
/* pętla z jedną instrukcją*/
instrukcja;
while(ch != ‘x’);
.
do
/*pętla z wieloma instrukcjami*/
{
instrukcja; ....
instrukcja;
}
while(x <= 42);
.
5. INSTRUKCJA if i if ... else
.
if (x==42)
/* if z jedną instrukcją*/
instrukcja;
.
if (x<19)
/* if z wieloma instrukcjami*/
{
instrukcja; ....
instrukcja;
}
.
W2 - 4
Podstawy Programowania – Wykład 2
if (ch==‘a’)
/* if - else*/
instrukcja;
else
instrukcja;
.
if (ch==‘a’)
/*konstrukcja else - if*/
instrukcja;
else if (ch==‘b’);
instrukcja;
else if (ch==‘c’);
instrukcja;
.
if (x<10)
/*zagnieżdżone instrukcje if*/
if (y>5)
instrukcja;
.
if (x>5)
/* else skojarzone z drugą */
if (y<10)
/* spośród 2 instrukcji if*/
instrukcja;
else
instrukcja;
.
if (x>5)
/*else skojarzone z pierwszą*/
{
if (y<10)
/*spośród 2 instrukcji if*/
instrukcja;
}
/*konieczne nawiasy klamrowe*/
else
instrukcja;
.
W2 - 5
Podstawy Programowania – Wykład 2
6. INSTRUKCJA break
.
while(ch!=‘x’)
/* if z jedną instrukcją*/
{if (count>MAX)
break;
/* powoduje wyjście z pętli*/
instrukcja;
}
.
7. INSTRUKCJA continue
.
while(ch!=‘x’)
{
if (ch==SPACE)
continue;
/* pomiń kolejne instrukcje*/
instrukcja;
/*przejdź do początku pętli*/
}
.
8. INSTRUKCJA switch
.
switch(j)
/*wybór wartości całkowitej*/
{
case 1:
printf(“j jest 1.\n”);
break;
case 2:
printf(“j jest 2.\n”);
instrukcja;
break;
default:
printf(“j jest czymkolwiek innym.\n”);
break;
}
W2 - 6
Podstawy Programowania – Wykład 2
.
switch(ch)
/*wybór wartości znakowej*/
{
case ‘a’:
case ‘b’:
printf(“ch jest \‘a\’ lub \‘b\’.\n”);
break;
case ‘c’:
printf(“ch jest \‘c\’.\n”);
break;
default:
printf(“ch jest czymkolwiek innym.\n”);
break;
}
.
FORMATY FUNKCJI
1. FUNKCJA PROSTA
.
/*funkcja prosta; przyklad W2P1*/
void fun1(void);
/*prototyp funkcji fun1()*/
void main(void)
/*definicja funkcji main()*/
{
puts(“Program glowny\n”);
fun1();
/*wywołanie funkcji fun1()*/
}
void fun1(void)
/*definicja funkcji fun1()*/
{
puts(“Funkcja”);
/*ciało funkcji fun1()*/
}
.
W2 - 7
Podstawy Programowania – Wykład 2
2. ZWRACANIE WARTOŚCI Z FUNKCJI
.
/*zwracanie wartosci z funkcji; przyklad W2P2*/
int zawsze7(void);
/*prototyp funkcji zawsze7()*/
void main(void)
/*definicja funkcji main()*/
{
printf(“Wartosc zwracana to %d\n”,zawsze7());
}
/*wywoł.zawsze7() w printf()*/
int zawsze7(void)
/*defin. funkcji zawsze7()*/
{
return(7);
/*ciało funkcji zawsze7()*/
}
/*return zwraca wartość*/
.
3. PRZEKAZYWANIE ARGUMENTÓW DO FUNKCJI
.
/*przekazywanie argumentów do funkcji; przyklad W2P3*/
int sum(int, int);
/*prototyp funkcji sum()*/
void main(void)
/*definicja funkcji main()*/
{
int x=2, y=3;
printf(“Suma x i y to %d\n”,sum(x,y));
}
/*wywołanie sum() w printf()*/
int sum(int xf, int yf)
/*definicja funkcji sum()*/
{
return(xf+yf);
/*ciało funkcji sum()*/
}
.
W2 - 8
Podstawy Programowania – Wykład 2
4. PRZEKAZYWANIE ARGUMENTÓW ZA POMOCĄ WSKAŹNIKÓW
.
/*przyklad W2P4*/
int sumarray(int*);
/*prototyp funkc. sumarray()*/
void main(void)
/*definicja funkcji main()*/
{
static int list[3]={25,36,42};
/*dekl. tablicy*/
printf(“Suma=%d\n”,sumarray(list));
}
/*przekazanie adresu tab.*/
int sumarray(int* ptr)
/*defin. funkcji sumarray()*/
{
return(*(ptr)+*(ptr+1)+*(ptr+2)); /*ciało funkcji*/
}
.
KONSTRUKCJE DANYCH
1. TABLICA
.
/*definiowanie tablic*/
void main(void)
{
int list[3];
/*1-wymiarowa, 3-elementowa*/
char table[4][3];
/*2-wym, 4 wiersze, 3 kolum.*/
list[2]=333;
/*przypisanie wartości elem.*/
table[1][2]=‘c’;
/*‘c’=> 6-ty element tablicy*/
}
.
W2 - 9
Podstawy Programowania – Wykład 2
/*inicjowanie tablic*/
int lista[3]={23,34,45};
/*inic. tabl. zewnętrznej*/
void main(void)
{
int listb[2][3]=
/*inic. tabl. 2-wymiarowej*/
{ {2,4,6},
{3,5,7}
};
}
.
2. ŁAŃCUCHY
.
char name[3];
/*łańcuch=tablica znaków*/
char salute[]=“Pozdrowienia!”;/*inicjowanie łańcucha*/
char *salute=“Pozdrowienia!”; /*inicjowanie łańcucha*/
char names[3][30]=
/*tablica łańcuchów*/
{“Katarzyna”,“Piotr”,“Robert”};
char *names[3]=
/*tablica łańcuchów*/
{“Jan”,“Agata”,“Teresa”};
puts(salute);
/*odwołanie do łańcucha*/
ch=(salute[2]==‘z’)?‘t’:‘n’; /*porównanie: 3 znak==‘z’*/
puts(&names[2][0]);
/*odwoł. do łańcucha w tab.*/
.
3. WSKAŹNIKI
.
/*inicjowanie wskaźników*/
int *ptr;
/*wskaźnik do int (tab.L.C.)*/
char *charptr;
/*wsk. do char (tabl. znak.*/
int numb;
/*zmienna całkowita*/
W2 - 10
Podstawy Programowania – Wykład 2
int table[3]={5,6,7};
/*tablica*/
ptr=&numb;
/*przypisanie adresu wskaź.*/
*ptr=8;
/*przyp. zmien. numb wart. 8*/
ptr=table;
/*przyp. wskaź. adr. tablicy*/
printf(“%d\n”,*ptr);
/*wypisz 1-szy elem. tablicy*/
printf(“%d\n”,*(ptr+1));
/*wypisz 2-gi elem. tablicy*/
printf(“%d\n”,*(ptr+2));
/*wypisz 3-ci elem. tablicy*/
.
4. STRUKTURY
.
struct pracownik
/*dekl. str. typu pracownik*/
{
/*elementy skład. struktury*/
int numerprac;
/*składowa całkowita*/
float zarobki;
/*składowa rzeczywista*/
char nazwisko[40];
/*składowa = łańcuch znaków*/
}
struct pracownik sprzedawcy; /*zm. typu str. pracownik*/
struct pracownik zaloga;
/*inna zm. typu st.pracownik*/
/*odwołania do elementów (pól) struktury*/
printf(“Numer sprzedawcy to %d\n”,sprzedawcy.numerprac); printf(“Pensja sprzedawcy to %f\n”,sprzedawcy.zarobki);
struct
/*defin. typu strukturalnego*/
{
/*bez podawania nazwy*/
int numerprac;
/*składowa całkowita*/
float zarobki;
/*składowa rzeczywista*/
char nazwisko[40];
/*składowa = łańcuch znaków*/
} kasjer;
/*zmienna typu strukturaln.*/
.
W2 - 11
Podstawy Programowania – Wykład 2
5. UNIE
.
union intflo
/*deklaracja unii*/
{
/*elementy składowe unii*/
int intnum;
/*składowa całkowita*/
float fltnum;
/*składowa rzeczywista*/
} unionex;
/*definicja zmiennej*/
unionex.intnum;
/*odwołan. do n-bajtowej zm.*/
unionex.fltnum;
/*odwołan. do m-bajtowej zm.*/
.
OPERATORY
1. OPERATORY ARYTMETYCZNE
.
Symbol
Operator
Przykład
+
Dodawanie
a+b
-
Odejmowanie
a-b
*
Mnożenie
a*b
/
Dzielenie
a/b
%
Reszta z dzielenia
a%b
2. OPERATORY INKREMENTACJI I DEKREMENTACJI
.
Symbol
Operator
Przykład
++
Zwiększanie
a++; ++a;
--
Zmniejszanie
a--; --a;
W2 - 12
Podstawy Programowania – Wykład 2
3. OPERATORY RELACYJNE
.
Symbol
Operator
Przykład
<
Mniejsze od
a<b
>
Większe od
a>b
<=
Mniejsze lub równe
a<=b
>=
Większe lub równe
a>=b
==
Równe
a==b
!=
Różne
a!=b
4. OPERATORY LOGICZNE
.
Symbol
Operator
Przykład
&&
I
a<b && c>d
||
LUB
a<b || c>d
!
NIE
!(a<b)
5. OPERATOR WARUNKOWY
.
wynik=(wyrażenie)?wartosc1:wartosc2
max = (a>b)? a:b;
/*max = większa z liczb*/
W2 - 13
Podstawy Programowania – Wykład 2
6. OPERATORY BITOWE
.
Symbol
Operator
Przykład
&
I
a&b
|
LUB
a|b
^
Rozłączne LUB
a^
~
Dopełnienie
~a
>>
Przesunięcie w prawo
a>>2
<<
Przesunięcie w lewo
b<<3
7. OPERATORY PRZYPISANIA
.
Symbol
Operator
Przykład
=
Przypisanie wartości
a=b
+=
Przypisanie sumy
a+=b (a=a+b)
-=
Przypisanie różnicy
a-=b (a=a-b)
*=
Przypisanie iloczynu
a*=b (a=a*b)
/=
Przypisanie ilorazu
a/=b (a=a/b)
%=
Przypisanie reszty
a%=b (a=a%b)
&=
Przypisanie wyniku I
a&=b (a=a&b)
|=
Przypisanie wyniku LUB
a|=b (a=a|b)
^=
Przypisanie wyniku rozłącznego LUB
a^=b (a=a^b)
<<=
Przypisanie przesunięcia w lewo
a<<=b (a=a<<b)
>>=
Przypisanie przesunięcia w prawo
a>>=b (a=a>>b)
W2 - 14
Podstawy Programowania – Wykład 2
8. PRIORYTETY I ŁĄCZNOŚĆ OPERATORÓW
.
Operatory
Typ
Łączność
() [] . ->
Grupy, elementy
od L do P
- ~ ! * &
Jednoargumentowe
od P do L
++ -- sizeof rzutowanie
Jednoargumentowe
od P do L
* / %
Multiplikatywne
od L do P
+ -
Addytywne
od L do P
<< >>
Przesunięcia
od L do P
< > <= >=
Relacyjne
od L do P
== !=
Równości
od L do P
&
Bitowe I
od L do P
^
Bitowe rozłączne LUB
od L do P
|
Bitowe LUB
od L do P
&&
Logiczne I
od L do P
||
Logiczne LUB
od L do P
?:
Warunkowy
od P do L
= *= /= %= += -= <<= >>= |=
Przypisania
od P do L
,
Przecinek (seria)
od L do P
Referencje
http://pl.wikibooks.org/wiki/C/Sk%C5%82adnia
http://pl.wikibooks.org/wiki/C
http://pl.wikipedia.org/wiki/C_(j%C4%99zyk_programowania)
http://ryciu.w.interia.pl/cwiczenia/skrypt_C.pdf
W2 - 15