/* funkcje*/
#include<stdio.h>
#define PI 3.1415926
#define P 3.3
#define H 44.4
main()
{
float promien=P,wysokosc=H,objetosc;
float objetosc_walca(float promien, float wysokosc);
objetosc = objetosc_walca(promien,wysokosc);
printf(”\nObjetosc walca = %f”, objetosc);
}
/* funkcja obliczajaca objetosc walca */
float objetosc_walca(float promien, float wysokosc)
{
return (PI*promien*promien*wysokosc);
}
Efekt:
Objetosc walca =1519.010254
definicja funkcji:
typ funkcji nazwa funkcji (lista parametrów formalnych)
{
definicje i deklaracje lokalne
instrukcje
}
void funkcja_a(void)
{
int i;
printf(”\n”);
for (i=1; i<20; i++)
printf(”.-”);
}
void funkcja_b(float a)
{
if (a>0)
printf(”\n a jest dodatnie”);
else
printf(”\n a nie jest dodatnie”);
}
int funkcja_c(void)
{
int i=55;
return (i-'5');
}
int funkcja_d(int a, int b, float c)
#define CG 15.51
{
if (c>CG)
return (b + 2);
else
return (a - b);
}
Wywołanie funkcji:
#include<stdio.h>
main()
{
/*prototypy*/
void funkcja_a(void);
void funkcja_b (float(a);
int funkcja_c(void);
int funkcja_d(int a, int b, float c);
/*inne deklaracje*/
float x=4.44, y=13.13;
int k=2, m=3;
/*przyklady wywolan funkcji*/
funkcja_a();
funkcja_b(y);
m+=funkcja_c() + k;
printf(”\n m = %d”, m);
k=funkcja_d(k,m,x);
printf(”\n k = %d”, k);
k=funkcja_d(5,6,17.33);
printf(”\n k = %d”, k);
funkcja_a();
}
/*definicje funkcji*/
.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-
a jest dodatnie
m = 7
k = -5
k = 8
.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-
/*Funkcje*/
#include<stdio.h>
#include<ctype.h>
main()
{
unsigned int wyszuk(char znak,char t[]);
void podkr (char znak, int n);
char s[]=”abcdefghijklmnopqrst...abcdefghij...”;
char v[]=”1234567890...abcdefgh...fghijk”;
int i;
podkr(`+`,55);
printf(s);
i=wyszuk(`n',s);
printf(”\ni=%i\n”,i);
printf(s);
podkr(`-`,53);
prinf(v);
i=wyszuk(`h`,v);
printf(”\ni=%i\n”,i);
printf(v);
podkr(`.`,50);
i=wyszuk(`#`,v);
printf(”\ni=%i\n”,i);
printf(v);
podkr(`+`,55);
}
/*funkcja wyszukiwania znaku w tablicy, gdy litera to zamiana na duże*/
unsigned int wyszuk(char znak,char t[])
{
int i=0;
while (t[i]!=`\0`)
{
if(t[i]==znak)
{
t[i]=toupper(znak);
return (i);
}
else
i++;
}
podkr(`?`,3);
return (-1);
}
/*funkcja linia podkreślająca*/
void podkr (char znak, int n)
{
int i;
printf(”\n”);
for(i=1;i<=n;i++)
putchar(znak);
printf(”\n”);
}
+++++++++++++++++++++++++++++++++++++++++++++++++++++++
abcdefghijklmnopqrst...abcdefghij...
i=13
abcdefghijklmNopqrst...abcdefghij...
-----------------------------------------------------
1234567890...abcdefgh...fghijk
i=20
1234567890...abcdefgH...fghijk
..................................................
???
i=-1
1234567890...abcdefgH...fghijk
+++++++++++++++++++++++++++++++++++++++++++++++++++++++
/*rekurencja*/
/*obliczanie silni*/
#include<stdio.h>
main()
{
int n;
long int silnia(int n);
for(n=1; n<=12;n++)
printf(”\n n=%2d n!=%9ld”, n, silnia(n));
}
/*funkcja rekurencyjna obliczania silni*/
long int silnia(int n)
{
if(n<=1)
return (1);
else
return (n*silnia(n-1));
}
n= 1 n!= 1
n= 2 n!= 2
n= 3 n!= 6
n= 4 n!= 24
n= 5 n!= 120
n= 6 n!= 720
n= 7 n!= 5040
n= 8 n!= 40320
n= 9 n!= 362880
n=10 n!= 3628800
n=11 n!= 39916800
n=12 n!= 479001600
/*funkcja iteracyjna obliczania silni*/
long int silnia(int n)
{
int i;
long int wynik=1;
if(n>1)
for(i=2;i<=n;++i)
wynik*=i;
return (wynik);
}
putchar(c);
c - stała, zmienna znakowa
/*putchar*/
#include<stdio.h>
#define SPACJA 32
main()
{
char napis[] = ”ABCDEFGHIJKLMNOPQRS...”;
int znak = 73;
/*wyprowadzenie pojedynczych znakow przy pomocy funkcji putchar*/
putchar('\n'); putchar(znak); putchar(SPACJA);
putchar(55); putchar(SPACJA); putchar('Z');
putchar(SPACJA); putchar('\066'); putchar(SPACJA);
putchar('\x3a'); putchar('\n'); putchar(napis[0]);
putchar(SPACJA); putchar(napis[4]); putchar(SPACJA);
putchar(znak +'\066' -52); putchar('\n');
}
Wynik
I 7 Z 6 :
A E K
puts(string);
string - stała, zmienna łańcuchowa
/*puts*/
#include<stdio.h>
#define N_L putchar('\n');
main()
{
char napis[] = ”ABCDEFGHIJKLMNOPQRS...”;
/*wyprowadzenie pojedynczej linii tekstu przy pomocy funkcji puts*/
N_L; puts (napis); N_L;
puts(”To jest praktyczna funkcja”):
puts(”\066\067\x2b\x2a itd.”);
}
Wynik
ABCDEFGHIJKLMNOPQRS...
To jest praktyczna funkcja
67+* itd.
printf(łańcuch formatu, lista argumentów);
/*printf*/
#include(stdio.h>
main()
{
int k=21101;
printf(”\nk(_10) = %i k(_8) = %o k(_16) = %X”,k, k, k);
}
k(-10) = 21101 k(_8) = 51155 k(_16) = 526D
Formaty realizowane przez funkcję printf
Typ danych |
Argument |
Format wyjściowy |
Liczba |
||
%d |
int |
liczba całkowita |
%i |
int |
liczba całkowita |
%u |
unsigned int |
liczba całkowita bez znaku |
%o |
int |
liczba całkowita w postaci ósemkowej |
%x |
unsigned int |
liczba całkowita w postaci szesnastkowej |
%X |
unsigned int |
liczba całkowita w postaci szesnastkowej |
%f |
float/double |
liczba zmiennoprzecinkowa [-]nn.mmmm |
%e |
float/double |
liczba zmiennoprzecinkowa [-]n.mme[+-]xx |
%E |
float/double |
liczba zmiennoprzecinkowa [-]n.mmE[+-]xx |
%g |
float/double |
jak %e lub %f bez 0 nieznaczących |
%G |
float/double |
jak %E lub %f bez 0 nieznaczących |
Znak lub łańcuch |
||
%c |
char |
pojedynczy znak |
%s |
char* |
łańcuch znaków |
Wskaźnik |
||
%n |
int* |
limitowana liczba znaków |
%p |
pointer |
liczba szesnastkowa |
Pełny zapis instrukcji format
%[pole znaku][szerokość][.dokładność][modyfikator]
typ danych
Pole znaku +, -, #, spacja, 0
Szerokość całkowita pola przeznaczonego na postać zewnętrzną liczby
Dokładność liczba miejsc po kropce dziesiętnej lub długość łańcucha
Modyfikator F, N, h, l, L
/*Wybrane formaty*/
#include <stdio.h>
main()
{
double a=153.67789, b=153.;
int k=22799;
int m=-500;
int *p;
p=&k;
printf(”\nFormat %%#-+8d %#-+8d”,k);
printf(”\nFormat %%#-+8i %#-+8i”,m);
printf(”\nFormat %%#-+8o %#-+8o”,k);
printf(”\nFormat %%#-+8X %#-+8X”,k);
printf(”\nFormat %%#020.8f %#020.8f”,a);
printf(”\nFormat %%+20.8e %+20.8e”,b);
printf(”\nFormat %%#+20.8G %#+20.8G”,a);
printf(”\nFormat %%24p %24p”,p);
m=printf(”\n\n123456789 \n”);
printf(”\nm=%i”,m);
}
Wynik:
Format %#-+8d +22799
Format %#-+8i -500
Format %#-+8o 054417
Format %#-+8X 0X590F
Format %#020.8f 00000000153.67789000
Format %+20.8e +1.5300000e+02
Format %+20.8G +153.67789
Format %24p 100D:590F
123456789
m=13
Dynamiczny format
#include <stdio.h>
main()
{
double a=153.22;
char napis[]=”Wszystko dobre co się dobrze konczy”;
int i,j;
printf(”\n%.9s”,napis);
printf(”\n%.*s”,9,napis);
i=9; printf(”\n%.*s”,i,napis);
i=21; printf(”\n%.*s”,i,napis);
printf(”\na=%#09.3f”,a);
printf(”\na=%#0*.3f”,9,a);
printf(”\na=%#0*.*f”,9,3,a);
i=9; j=3;
printf(”\na=%#0*.*f”,i,j,a);
i=20; j=8;
printf(”\na=%#0*.*f”,i,j,a);
}
Wynik:
Wszystko
Wszystko
Wszystko
Wszystko dobre co się
a=00153.220
a=00153.220
a=00153.220
a=00000000153.22000000
c=getchar();
#include <stdio.h>
main()
{
/*Wprowadzenie i wyprowadzenie 1 znaku*/
char znak;
znak=getchar();
putchar(znak);
}
gets(string);
#include <stdio.h>
main()
{
/*Wprowadzenie i wyprowadzenie 1 linii*/
char linia[80];
gets(linia);
puts(linia);
}
scanf(łańcuch formatu, lista argumentów);
#include <stdio.h>
#define PI 3.1415926
main()
{
float promien, wysokosc;
printf(”\nPodaj dane wejsciowe:”);
printf(”\nPromien =”);
scanf(”%f”,&promien);
printf(”Wysokosc =”);
scanf(”%f”,&wysokosc);
printf(”\nObjetosc walca=%f”,PI*promien*promien*wysokosc);
}
Wynik:
Dane wejsciowe
Promien =3.3
Wysokosc =44.4
Objetosc walca =1519.010296
Instrukcja formatu
%[*][Szerokość][Modyfikator1][Modyfikator2]Typ danych
* zignorowanie pola wejściowego
Szerokość maksymalna liczba wczytanych znaków
Modyfikator1 F,N
Modyfikator2 h, l, L
Formaty realizowane przez funkcję scanf
Typ danych |
Argument |
Format wyjściowy |
Liczba |
||
%d |
int* |
liczba całkowita |
%i |
int* |
liczba całkowita |
%D |
long* |
liczba całkowita |
%l |
long* |
liczba całkowita |
%u |
unsigned * |
liczba całkowita bez znaku |
%U |
unsigned long * |
liczba całkowita bez znaku |
%o |
int * |
liczba ósemkowa |
%O |
long * |
liczba ósemkowa |
%x |
int * |
liczba szesnastkowa |
%X |
long * |
liczba szesnastkowa |
%f |
float * |
liczba zmiennoprzecinkowa |
%e |
float * |
liczba zmiennoprzecinkowa |
%E |
float * |
liczba zmiennoprzecinkowa |
Znak lub łańcuch |
||
%c |
char* |
pojedynczy znak |
%s |
char tab[n] |
łańcuch znaków |
Wskaźnik |
||
%n |
brak |
liczba znaków zapamiętana w (int*) |
%p |
far * / near * |
wskaźnik do dowolnego objektu |
Wczytanie i wyprowadzenie znaku, łańcucha
#include <stdio.h>
main()
{
char znak, linia[80];
scanf(”%c”,&znak);
printf(”%c\n”,znak);
scanf(”%s”,linia);
printf(”%s”,linia);
}
Filtr
#include <stdio.h>
main()
{
char linia[80];
scanf(”%[a-zABC]”,linia);
printf(”%s”,linia);
}
Wynik
aabbzzABCDzz
aabbzzABC
Używane filtry
%[A-Z] - duże litery dozwolone
%[^A-Z] - duże litery wykluczone
%[AaBb+-.:K] - wybrane znaki dozwolone
%[^XYZxyz] - wybrane znaki wykluczone
Funkcje biblioteczne
math.h
Nagłówek funkcji |
Przeznaczenie |
int abs (int i) |
Wartość bezwzględna z int |
double fabs (double x) |
Wartość bezwzględna z float |
long labs (long x) |
Wartość bezwzględna z long |
double cos (double x) |
Wyznaczanie cosinusa |
double sin (double x) |
Wyznaczanie sinusa |
double log (double x) |
Wyznaczanie logarytmu naturalnego |
double log10 (double x) |
Wyznaczanie logarytmu dziesiętnego |
double pow (double x, double y) |
Wyznaczanie potęgi xy |
double sqrt (double x) |
Wyznaczanie pierwiastka kwadratowego |
stdlib.h
Nagłówek funkcji |
Przeznaczenie |
int atoi (char *s) |
Przekształcenie tekstu w liczbę int |
double atof (char *s) |
Przekształcenie tekstu w liczbę double |
char* itoa (int n, char* s, int p) |
Przekształcenie liczby n w tekst |
char* gcvt (double x, int ndec, char* s) |
Przekształcenie liczby rzeczywistej w tekst |
string.h
Nagłówek funkcji |
Przeznaczenie |
char* strcpy (char* s1, char* s2) |
Kopiuje łańcuch s2 do s1 |
char* strcat (char* s1, char* s2) |
Dołącza łańcuch s2 do końca s1 |
int strcmp (char* s1, char* s2) |
Porównuje dwa łańcuchy. 0 - identyczne |
unsigned int strlen (char* s) |
Zwraca długość łańcucha (bez znaku NULL) |
char* strupr (char* s) |
Zamienia wszystkie litery na duże |
char* strlwr (char* s) |
Zamienia wszystkie litery na małe |
conio.h
Nagłówek funkcji |
Przeznaczenie |
int getch (void) |
Zwraca wartość znaku z konsoli (nie wyświetla) |
int getche (void) |
Zwraca wartość znaku z konsoli (wyświetla znak) |
int kbhit (void) |
Zwraca 0 - bufor klawiatury pusty |
void clrscr (void) |
Czyści ekran monitora |
int wherex (void) |
Zwraca pozycję x kursora |
int wherey (void) |
Zwraca pozycję y kursora |
void gotoxy (int x, int y) |
Przenosi kursor do punktu o współrzędnych (x, y) |
void highvideo (void) |
Znaki rozjaśnione |
void lowvideo (void) |
Znaki przygaszone |
void normalvideo (void) |
Znaki normalne |
void textcolor (int i) |
Ustala kolor znaków |
void textbackground (int i) |
Ustala kolor tła |
void textattr (int i) |
Ustala atrybut znaku |
ctype.h
Nagłówek funkcji |
Przeznaczenie |
int isalpha (int c) |
Czy znak c jest literą |
int isdigit (int c) |
Czy znak c jest cyfrą |
int isspace (int c) |
Czy znak c jest odstępem |
int islower (int c) |
Czy znak c jest małą literą |
funkcje zwracają 0 jeśli nie lub 1 jeśli tak
Deklaracje stałych
np. z modułu math
#define M_E 2.71828182845904523536
#define M_PI 3,14159265358979323846
#define M_PI_2 1.57079632679489661923
#define M_PI_4 0.785398163397448309116
#define M_1_PI 0.318309886183790671538
#include<stdio.h>
#define KWADR(X) X*X
#define PR(X) printf(”\nWynik wynosi %d”, X)
int main(void)
{
int x = 4;
int z;
z = KWADR(x);
PR(z);
z = KWADR(2);
PR(z);
PR(KWADR(x +2));
PR(100/KWADR(2));
printf(”\nx wynosi %d”, x);
PR(KWADR(++x));
printf(”\nPo zwiekszeniu X wynosi %d”, x);
return 0;
}
Wynik wynosi 16
Wynik wynosi 4
Wynik wynosi 14
Wynik wynosi 100
x wynosi 4
Wynik wynosi 30
Po zwiekszeniu x wynosi 6
/* makrodefinicja */
#include <stdio.h>
#define NL printf(”\n”)
#define LINIA_PODKR(n, z) NL; \
for (i=1; i<=(n); i++) \
putchar(z); \
NL;
main()
{
int i;
LINIA_PODKR (16,'*') /*makrowywolanie*/
LINIA_PODKR (38,'#') /*makrowywolanie*/
}
Wynik:
****************
######################################