/**********************************/
/* Funkcje z prostymi parametrami */
/**********************************/
#include <iostream>
using namespace std;
int abs(int x); // funkcja zdefiniowana we bibliotece standardowej jezyka C++, deklaracja ta wystepuje we pliku <cmath>
int sqr(int x); // deklaracje (prototypy) funkcji uzytkownika
int cub(int x);
int npow (int x, int n);
int max2 (int x, int y);
int max3 (int x, int y, int z);
void main()
{
int a;
int b;
int c;
int wynik;
cout << "a="; cin >> a;
cout << "b="; cin >> b;
cout << "c=" ; cin >> c;
wynik = abs(a); // wywolanie funkcji zdefiniowanej we bibliotece standardowej
cout << "wynik dla abs: " << wynik << endl;
wynik = sqr(a); // wywolanie funkcji uzytkownika
cout << "wynik dla sqr: " << wynik << endl;
wynik = cub(a);
cout << "wynik dla cub: " << wynik << endl;
wynik = npow(a,b);
cout << "wynik dla npow: " << wynik << endl;
wynik = max2(a,b);
cout << "wynik dla max2: " << wynik << endl;
wynik = max3(a,b,c);
cout << "wynik dla max3: " << wynik << endl;
}
int sqr(int x) // definicje funkcji uzytkownika
{ return x*x;
}
int cub(int x)
{ return x*sqr(x);
}
int npow(int x, int n)
{int p;
p=1;
for (int i=0; i<n; i++)
p*=x;
return p;
}
int max2 (int x, int y)
{int x,y;
if x>y
cout << x << "," << y <<endl
if x<y
cout << y << "," << x << endl
return ;
}
int max3(int x, int y, int z)
{
return
}
Lub
int max2 (int x, int y)
{return y>x ? y : x;
//
/*if (x<y)
return y;
if (x>y)
return x;*/
}
int max3(int x, int y, int z)
{/* int t=max2(x,y);
if (t>z);
return t;
if (t<z);
return z;*/
return max2(x,max2(y,z));
}
/****************************************/
/* Skojarzenie argumentow z parametrami */
/****************************************/
#include <iostream>
using namespace std;
int inc1(int x) // wartosc argumentu
{
int w = x+1; // odczytanie wartosci argumentu i jej modyfikacja
x = w; // zapisanie zmodyfikowanej wartosci jedynie do lokalnego parametru, wartosc argumentu pozostaje bez zmiany
return w; // stad przeslanie zmodyfikowanej wartosci jako rezultat wywolania funkcji
}
void inc2(int *x) // adres argumentu
{
int w = *x+1; // odczytanie wartosci argumentu i jej modyfikacja
*x = w; // modyfikacja argumentu poprzez adres - wartosc argumentu ulega zmianie !
}
void inc3(int &x) // alias argumentu
{
int w = x+1; // odczytanie wartosci argumentu i jej modyfikacja
x = w; // modyfikacja argumentu poprzez alias - wartosc argumentu ulega zmianie !
}
void main()
{
int a;
cout << "a="; cin >> a;
a = inc1(a); // skojarzenie argumentu z parametrem przez wartosc, zmodyfikowana wartosc moze byc zapisana do argumentu jedynie jako rezultat funkcji
cout << "wynik dla inc1: " << a << endl;
inc2(&a); // skojarzenie argumentu z parametrem przez adres, zmodyfikowana wartosc jest zapisana wprost do argumentu poprzez jego adres
cout << "wynik dla inc2: " << a << endl;
inc3(a); // skojarzenie argumentu z parametrem przez alias (referncje), zmodyfikowana wartosc jest zapisana wprost do argumentu poprzez jego alias
cout << "wynik dla inc3: " << a << endl;
}
/*************************/
/* Iteracja a rekurencja */
/*************************/
#include <iostream>
using namespace std;
int silnia1(int n) // wersja iteracyjna
{
int w=1; //zmienna do ktorej zapisujemy wynik
cout << "silnia1: i=1 , w=" << w << endl;
for (int i=2; i<=n; i++) { // od 2ch bo od 1 ns
w = w*i;
cout << "silnia1: i=" << i << " , w=" << w << endl;
}
return w; // wywolujemy w
}
int silnia2(int n) // wersja rekurencyjna
{
int w; // wynik zapisujemy do zmiennej w
if (n<2) w=1; // jesli n < 2 to wynik =1
else w=silnia2(n-1)*n; // w kazdym innym przypadku wynik rowna sie :
cout << "silnia2: n=" << n << " , w=" << w << endl;
return w; // zwraca w ;
}
void main()
{
int n; // odczytujemy n
cout << "n="; cin >> n;
int w1=silnia1(n);// przesylamy n do funkcji
int w2=silnia2(n);
cout << "silnia1: wynik=" << w1 << endl; // wyswietlamy wynik funkcji
cout << "silnia2: wynik=" << w2 << endl;
}
=---------------------==-----------------------------------==-----------------------------------==------------------------------=
/*************************/
/* Iteracja a rekurencja */
/*************************/
#include <iostream>
using namespace std;
int npow (int x, int n)
{
int w;
if (n==0) w=1 ;
if (n==1) w=x;
else w=x*npow(x,n-1);
return w;
}
void main()
{
int n,x; // odczytujemy n
cout << "x="; cin >> x;
cout << "n="; cin >> n;
int w=npow(x,n);// przesylamy n do funkcji
cout << "npow: wynik=" << w << endl; // wyswietlamy wynik funkcji
}
------------------------------===================-------------------==========-------------------------------
/***********************/
/* Argumenty tablicowe */
/***********************/
#include <climits>
#include <iostream>
using namespace std;
// biblioteka funkcji do przetwarzania tablic liczb calkowitych:
int odczytElementow(int tab[], int n); // tablica, rozmiar tablicy
int zapisElementow(int tab[], int n); //
int sumaElementow(int tab[], int n);
int iloczynElementow(int tab[], int n);
int maksymalnyElement(int tab[], int n);
int minimalnyElement(int tab[], int n);
int szukanieElementow(int tab[], int n, int x);
void main(void)
{
// przyklady uzycia biblioteki:
int A[20], n, x, wynik;
cout << "Podaj liczbe elementow (<=20): ";
cin >> n;
cout << endl << "Podaj elementy tablicy:" << endl;
wynik = odczytElementow(A,n);
cout << "(odczytano " << wynik << " elementow)" << endl;
cout << endl << "Podane elementy tablicy:" << endl;
wynik = zapisElementow(A,n);
cout << "(zapisano " << wynik << " elementow)" << endl;
cout << endl << "Operacje na tablicy:" << endl;
wynik = sumaElementow(A,n);
cout << "suma elementow wynosi " << wynik << endl;
wynik = iloczynElementow(A,n);
cout << "iloczyn elementow wynosi " << wynik << endl;
wynik = maksymalnyElement(A,n);
cout << "maksymalny element to " << wynik << endl;
wynik = minimalnyElement(A,n);
cout << "minimalny element to " << wynik << endl;
cout << "Podaj wartosc: ";
cin >> x;
wynik = szukanieElementow(A,n,x);
cout << "podana wartosc wystepuje " << wynik << " razy w tablicy" << endl;
cout << endl;
}
// definicje funkcji:
int odczytElementow(int tab[], int n)
{
int i;
for (i=0; i < n; i++)
cin >> tab[i];
return i;
}
int zapisElementow(int tab[], int n)
{
int i;
for (i=0; i <n; i++)
cout << tab[i] << " , ";
cout << endl;
return i;
}
int sumaElementow(int tab[], int n)
{
int suma = 0;
for (int i=0; i < n; i++)
suma += tab[i];
return suma;
}
int iloczynElementow(int tab[], int n)
{
int iloczyn = 1;
for (int i=0 ; i<n ; i++)
iloczyn *= tab[i] ;
return iloczyn;
}
int maksymalnyElement(int tab[], int n)
{
int max = INT_MIN;
for (int i=0; i<n; i++)
if (max < tab[i])
max = tab[i];
return max;
}
int minimalnyElement(int tab[], int n)
{
int min = INT_MAX;
for (int i=0; i<n ; i++)
if (min < tab[i])
min = tab[i];
return min;
}
int szukanieElementow(int tab[], int n, int x)
{
int krotnosc = 0;
for (int i=0; i<n ; i++)
if (tab[i]==x )
krotnosc++;
return krotnosc;
}
/*****************************************/
/* Funkcje o zmiennej liczbie argumentow */
/*****************************************/
#include <cstdio>
#include <cstdarg> // definiujemy zbior funkcji
using namespace std;
void printvec(int n,...) // ... => kropki , leastyczna funkcja mozna dac dowolna ilosc parametrow
{
int i;
va_list ap; //va list pomaga zainicjowac iterator , pomocniczy iterator
va_start(ap,n); // inicjuje iterator . drugi parametr jawny/ w nawiasie podajemy ostatni parametr jawny
printf("( ");
for (i=0; i<n; i++) {
double x=va_arg(ap,double); // va arg odczytuje bierzaca wartosc iteratora. poddajemy ja konwersji do typu double.
if (i>0) printf(", "); // wyswietlamy x na ekranie| vaarg przesuwa krok dalej parametr
printf("%lf",x);
}
printf(" )\n");
va_end(ap); // vaend = kasuje iterator z pamieci i zamyka przetwarzanie w pamieie
}
void main()
{
printvec(2,1.01,2.02);//ilosc jawnych parametrow (2). parametry drugie zawsze rzeczywiste np. 1.01
printvec(3,1.11,2.12,3.13);
printvec(5,1.11,2.22,3.33,4.44,5.55);
}
/**************************/
/* Funkcje strcpy, strcat */
/**************************/
#include <iostream>
using namespace std;
#pragma warning(disable:4996) // wylaczenie ostrzezenia dot. funkcji starego standardu, funkcje te sa zastapione przez nowe
extern "C" { // deklaracje funkcji dla jezyka C - pochodza z pliku <cstring>
char* strcat(char s1[],const char s2[]);
}
void strcpy1(char s1[],const char s2[]);
void main(void)
{
char napis[80], wynik[80];
cout << "napis = ";
cin.getline(napis,sizeof napis);
strcpy1 (wynik, napis ); /* wynik=napis */
strcat (wynik, napis ); /* wynik=wynik+napis */
strcat (wynik,"the end") ;
cout << "wynik = " << wynik << endl;
}
void strcpy1(char s1[],const char s2[])
{
int i;
for (i=0; s2[i]!='\0'; i++)
s1[i]=s2[i];
s1[i]='\0';
}