przekatna

#include <iostream>
#include <math.h>

using namespace std;
double pole(double a, double &przekatna);
int main(){
double przekatna;
cout<<pole(5.0,przekatna)<<"\n";
cout<<przekatna<<"\n";

}

double pole(double a, double &przekatna){
double b;
b=2;
przekatna=a*sqrt(b);
return(a*a);

}

//////////////

#include <iostream>

using namespace std;

//Przekazywanie tablicy do funkcji
void wyswietlTablice1d(float t[]);
//Przekazywanie tablic wielowymiarowych do funkcji
void wyswietlTablice2d(int t[][2]);
/*
    Aby funkcja mogła łatwo obliczyć, gdzie w pamięci jest określony element tablicy, musi znać liczbę kolumn tej tablicy
    Dlatego ZAWSZE! wszystkie oprócz lewego skrajnego rozmiaru tablicy, trzeba deklarować na liście parametrów funkcji
    void fff(long m[][][]);  <- BŁĄD!!!
*/


int main()
{

//PRZYKŁADY
    char zdanie[80]; //zdanie jest tablicą 80 elementów typu char

    float numer[9];  //numer jest tablicą 9 elementów typu float

    unsigned long kanal[8192];  //kanal jest tablicą 8192 elementów typu unsigned long

    int *wskaz[20];  //wskaz jest tablicą 20 elementów będących wskaźnikami(adresami) jakichś obiektów typu int

    /*
        Numeracja elementów tablicy zaczyna się od zera!!!!!!!!!!!
        zdanie[0] <- to pierwszy element w tablicy
    */

//INICJALIZACJA TABLIC

    int t[4] = {17, 5, 4, 200};

    /*
        t[0]  ma wartość 17
        t[1]  ma wartość 5
        t[2]  ma wartość 4
        t[3]  ma wartość 200
    */

    int tab2[4] = {17, 5};
    //Tylko elementom 0 i 1 przypisaliśmy wartości (2 z 4), pozostałe będą zerami

    int r[] = {2, 10, 15, 16, 3};
    //Nie ma konieczności podawania rozmiaru tablicy przy powyższej inicjalizacji

//TABLICE WIELOWYMIAROWE

    int ddd[4][2]; //macierz - 4 wiersze, 2 kolumny
    int dddd[2][2][2]; //szescian

    int tab2d[3][2] = {{1, 2},{3, 4},{5, 6}}; //inicjalizacja tablicy wielowymiarowej

    cout<<tab2d[1][1]; //2 wiersz, 2 kolumna - indeksy numerujemy od 0 !!!!

    char wyrazenie[] = { "Ala ma kota" };
    char literki[] = { 'a', 'b', 'c', 'd', 'e'};

    cout<<wyrazenie<<endl;
    cout<<wyrazenie[0]<<endl;
    cout<<literki[0]<<endl;

//Przekazywanie tablic do funkcji
    float tablica[] = {12, 3.4, 2, 3.14};
    wyswietlTablice1d(tablica);

    /*
        NAZWA TABLICY jest równocześnie ADRESEM JEJ PIERWSZEGO ELEMENTU!!!!!
    */

}

void wyswietlTablice1d(float t[])
{
    for(int i = 0; i < 4; i++)
        cout<<t[i]<<" ";
}

void wyswietlTablice2d(int t[][2])
{

}

////////////////////
obliczenia



using namespace std;

double obliczenia (double a, double b,char dzialanie);

int main()
{
    cout<<obliczenia(3,4,'+');


}


double obliczenia (double a, double b, char dzialanie)
{
    if (dzialanie = '+')
        return a+b;
    else if (dzialanie = '-')
        return a-b;
    else if (dzialanie = '*')
        return a*b;
    else if (dzialanie = '/')
        return a/b;
    else
        return  0;
}

/////////////
funkcje

#include <iostream>

using namespace std;


//deklaracje funkcji
void fun1(int a, int b); //funkcja nie zwracająca wartości - void
int fun2(int a, int b); //funkcja zwracająca wartość - zawsze musi mieć typ zwracany i instrukcję RETURN. To może być dowolny typ.

/*
    Po słowie kluczowym "return" funkcje kończy swoje działanie
    Funkcja może miec wiele wyrażeń "return", jeśli zastosujesz np konstrukcję z "if"
*/

void fun3();

//funkcja przesyłająca argumenty przez wartość
void fun4(int a);
//w tym wypadku wewnątrz funkcji operujemy na kopiach przekazanej zmiennej, na zewnątrz jej wartość pozostaje bez zmian

//funkcja przesyłająca argumenty przez referencję
void fun5(int &a);
//w tym wypadku przekazany argument zostaje związany z zewnętrzną zmienną, zmieniając ją wewnątrz funkcji, zmieniamy także zewnętrzną zmienną
//Wniosek: Przesyłanie argumentów funkcji przez referencję pozwala tej funkcji na modyfikowanie zmiennych (nawet lokalnych) znajdujących się po za tą funkcją

void temperatura( float stopnie, int skala = 0); //funkcja z argumentami domniemanymi
int multi(int x, float m, int a = 4, float y = 6.55, int k = 10); //funkcja z argumentami domniemanymi
/*
Możliwe wywołania multi
    multi(2, 3.14);                //a = 4, y = 6.55, k = 10
    multi(2, 3.14, 7);            //a = 7, y = 6.55, k = 10
    multi(2, 3.14, 7, 0.3);        //a = 7, y = 0.3, k = 10
    multi(2, 3.14, 7, 0.3, 5);  //a = 7, y = 0.3, k = 10

    Nie możliwe jest opuszczenie domniemanego argumentu a lub u, a umieszczenie argumentu k. Zatem wywołanie poniższe jest złe.
    multi(2, 3.14, 7, , 5);

    W języku C++ nie może wystąpić sytuacja taka, że obok siebie stoją dwa przecinki

*/

void ton(int); //funkcja z NIENAZWANYM ARGUMENTEM
/*
    deklaracja "void fun3();"  jest tym samym, co deklaracja "void fun3(void);"
*/

//funkcje typu INLINE
inline int zao(float liczba)
{
    return (liczba + 0.5);
}
/*
    Nie potrzebują one deklaracji, ponieważ wynik od razu podstawiany jest pod instrukcję return
    Funkcje typu inline zostały pomyślane dla naprawdę małych krótkich funkcji i tylko wtedy mają sens.
    Nie należy ich nadużywać
*/

//MAIN
int main()
{
    cout<<"witaj";

    ton(1);
}


//definicje funkcji
void fun1(int a, int b)
{
    cout<<"z funkcji";
}

int fun2(int a, int b)
{
    return 1;
}

void fun3()
{
    cout<<"jestem funkcja bez argumentow";
}

void fun4(int a)
{
    a*=2;
}

void fun5(int &a)
{
    a = a * 2; // to samo wyrażenie, co skrótowy zapis a*=2;
}

void ton(int)
{
    cout<<"ton";
}

//////////////////

silnia

#include <iostream>

using namespace std;

int silnia(int a);
int n;
int c=1;

int main()
{

       cout<<"Podaj dowolna liczbe"<<endl;
       cin>>n;
       silnia(n);

}

int silnia(int a=0)
{
        for(a=n;a=n;n--)
   {

               c=c*n;
   }

        cout<<c<<endl;
       return 1;
}

////////////////

petle

de <iostream>

using namespace std;

int main()
{

int a,b;
int n=1;

	cout<<"Podaj a"<<endl;
	cin>>a;
	b=a;
	/*
	cout<<"0"<<endl;


	for(a>n;a>n;n++)
	{

		cout<<n+1<<endl;
	}
	for(b=n;b=n;n=n-1)
	{
		cout<<n<<endl;
	}
		cout<<"0"<<endl;
		*/






	/*
	cout<<"0"<<endl;
	while(a>n)
	{

		cout<<n<<endl;
		n=n+1;

	}

	cout<<n<<endl;


	while(b=n)
	{

		cout<<n<<endl;

		n=n-1;

	}
	cout<<"0"<<endl;
	*/



	/*cout<<"0"<<endl<<"1"<<endl;
	do {
    cout<<n+1<<endl;
    n++;
} while( a >n );


	do {
    cout<<n<<endl;
    n--;
} while( a=n );
	cout<<"0"<<endl;
	*/
}

//////////

#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <iostream>

using namespace std;

int main(void)
{

int i;
time_t t;

srand((unsigned) time(&t));

cout<<"Liczby losowe z przedzialu od 0 do 99";

for(i=0; i<10; i++)
    cout<<rand() % 100<<endl;

/*
    Jesli chcemy otrzymać liczby losowe z danego przedziału: <a;b>
    wzór: rand() s + a;
    s = b - a + 1;

    np <3;11>
    rand()%9 + 3;
*/


}