Witam!
Umieszczam proste programy z zajęć z c++. Jeżeli ktoś nie zna podstaw to może z nich korzystać kopiując niektóre części

//************************************************** **********************
//FUNKCJE I KONTROLA DANYCH - PRZYKLADY
//POLECENIA:
// 1) zapoznaj sie z programem;
// 2) zmien program (linie //$$$$$ tak, by k bylo zmienna lokalna w main();
//************************************************** ***********************


#include <iostream.h>
#include <conio.h>
#include <stdlib.h> //biblioteka zawierajaca strtod( , )

int k; //$$$$$
// zmienna globalna -unikamy jej stosowania;
// kompilator nadaje jej wartosc poczatkowa zero;
// dostepna w kazdej funkcji bez przekazywania przez naglowek;

double Czytaj_rzecz(int,int,char*);
//deklaracja funkcji, defincja po main()
//-------------------------------------definicje kolejnych funkcji--
void opis() //FUNKCJA BEZ PARAMETROW FORMALNYCH
{ clrscr();
gotoxy(10,1);
cout<<"CZYTANIE LICZBY RZECZYWISTEJ - KONTROLA POPRAWNOSCI ";
gotoxy(10,2);
cout<<"FUNKCJE - ZMIENNE LOKALNE I GLOBALNE ";
}
//-------------------------------------------------------------------
void zwieksz_k() //$$$$$
{
k+=1; // to samo co k++;
}
//-------------------------------------------------------------------
//************************************************** *****************

main ()
{ // zmienne lokalne
double liczba_rzecz;
char znak;
//$$$$$
//------------------------------------------

opis();
do
{
zwieksz_k (); // $$$$$

//WYWOLANIE FUNKCJI Z PARAMETRAMI AKTUALNYMI
liczba_rzecz=Czytaj_rzecz(3,wherey()+3,"Podaj liczbe a: ");

cout<<"\t\t\tWczytano: liczba_" << k<< " = "<<liczba_rzecz<<endl;
cout<<" Koniec \? (t\\n) ";
znak=getch();
}
while(znak !='t' && k< 5);
}
//************************************************** *******************

double Czytaj_rzecz(int x,int y, char* tekscik)
{
char znaki[80], *endptr;
double m;
do{
gotoxy(x,y);clreol();
cout<< tekscik; cin >> znaki;
m=strtod(znaki, &endptr);
} while(*endptr != NULL);
return m;
}

//POLECENIA:
// 1) URUCHOM PROGRAM ( TEN ALGORYTM POTRZEBNY NA EGZAMIN)
// 2) ZOBACZ JAK SIE PISZE WLASNA FUNKCJE int nwd(int, int);
// 3) SPRAWDZ CO SIE ZMIENI GDY NAGLOWEK FUNKCJI NA int nwd(int&, int&);
// czyli gdy parametry sa przekazane referencje (adres) , a nie przez wartosc ???

//-------------------------------------------
// Obliczenie NWD(a,b) - metoda Euklidesa.
//-------------------------------------------
#include <iostream.h>
#include <conio.h>
//-------------------------------------------

int nwd(int, int); //deklaracja funkcji - uwaga srednik !

int main ()
{
int a, b;

cout << "\n\tObliczenie najwiekszego wspolnego podzielnika NWD(a,b)\n\n";
do {
cout << "Podaj 2 liczby naturalne a>0 b>0: ";
cin >> a >> b;
}while (a <=0 || b<=0);
cout << "\n\t NWD( "<< a <<" ,"<< b <<" ) = " << nwd(a,b) << endl;
getch();
return 0;
}
/* Obliczenie NWD(a,b) */
int nwd(int x, int y) //DEFINICJA funkcji - uwaga bez srednika !
{
while (x != y) //to samo co
(x>y) ? x=x-y : y=y-x; // if(x>y) x-=y; else y-=x;
return x;

}

/*--------------------------------------------------------
Program wczytuje liczbe n i wylicza
sume liczb od 1 do n, tzn. 1+2+3+...+n
uzywajac petli for, while i do-while, oraz petli z wyskokiem
----------------------------------------------------------*/
#include <iostream.h>
#include <conio.h>

int main()
{
int n, i, suma = 0;
// clrscr();
cout << " Program wczytuje liczbe n i wylicza sume liczb od 1 do n, tzn. 1+2+3+...+n\n\n";
cout << "Podaj liczbe naturalna: ";
cin >> n;
cout << "\n\nOto wyniki obliczone 4 ma sposobami:\n";

// ================================================== ==sposob pierwszy:
for ( i=1; i <= n; i++ )
suma += i; //inny zapis suma=suma+i;
cout << "\n1+2+...+" << n << " = " << suma
<< " (petla for)" << endl << endl;

//================================================== ===== sposob drugi:
i = 1; suma = 0;
do
{ suma += i;
i++;
} while ( i <= n );
cout << "\n1+2+...+" << n << " = " << suma
<< " (petla do...while)" << endl << endl;

// ================================================== =====sposob trzeci:
suma = 0; i=n;
while ( i )
{ suma += i;
i--;
}
cout << "\n1+2+...+" << n << " = " << suma
<< " (petla while)" << endl << endl;

//================================================== ======= sposob czwarty:
suma = 0; i=n;
while ( 1 ) //petla niekonczaca sie nigdy, to samo co: f(;{...} lub do{...}while(1)
{ suma += i;
i--;
if(!i)break; // konieczny jest warunek wyskoku z petli(np. gdy i osiagnie zero)
}
cout << "\n1+2+...+" << n << " = " << suma
<< " (petla while(1) z intr. break)" << endl << endl;
//================================================== =========== koniec ==
getch();
return 0;
}

Obliczanie funkcji sinus


//---------------------------------------------------------------------------
#include <iostream.h>
#include <conio.h>
#include <math.h>
#include <iomanip.h>
//---------------------------------------------------------------------------
// Obliczanie funkcji sinus poprez przyblizenie szeregiem potegowym
// sin(xr)= xr/1 - (xr*xr*xr)/(1*2*3) + (xr*xr*xr*xr*xr)/(1*2*3*4*5) - .........
int main()
{
float s, // wartosc funkcji sinus (suma szeregu)
x, // argument funkcji sinus w stopniach
w, // wartosc kolejnego wyrazu szeregu
eps, // dokladnosc obliczen
xr, // argument funkcji sinus w radianach
xr2; // argument w radianach do kwadratu
int i; // liczba iteracji
do{
// clrscr();
cout<<"\n\n======================OPIS PROGRAMU===================================";
cout<<"\n Obliczanie funkcji sinus poprez przyblizenie szeregiem potegowym\n";
cout<<" sin(xr)= xr/1 - (xr*xr*xr)/(1*2*3) + (xr*xr*xr*xr*xr)/(1*2*3*4*5) - ...\n\n";
cout<<"Podaj kat w stopniach i dokladnosc mniejsza od 1: " ;
cin>>x>>eps;

// wprowadz dane: kat w stopniach i dokladnosc (< 1)

xr = (x/180)*M_PI; //zamiana na radiany
xr2 = xr*xr; //uzupelnij
i = 0;
s = xr; w = s;
do
{
i++;
w = w*xr2/((2*i+2)*(2*i+3)); //uzupelnij
if (i%2 != 0) s-=w; else s+=w ; //uzupelnij;
}
while (w<eps );
cout << "\nsin(" << setprecision(5) << x
<< ") = " << setprecision(7)<< s << endl;
cout << "\nliczba iteracji = " << i << endl;
cout << "SIN(xr) z math.h = "<< sin(xr)<<endl;
cout<< "\n ...press any key...(ESC=27 - stop)";
}while( getch()!= 27);
return 0;
}
//---------------------------------------------------------------------------

/*------------------------------------------------------------
zad. TAB_ZNAKOW
Program ma wczytywac teskst kilkulinijkowy zlozony z wyrazow
(ciag znakow czarnych) rozdzielonych spacjami lub nowa linia,
a na stepnie wypisac go na ekranie z pominieciem zbednych spacji
(linia zaczyna sie od wyrazu) Ponadto, zlicza:
- wszyskie znaki
- ilosc wyrazow w kazdej linii
- wszyskie znaki czarne
- ilosc linii

-------------------------------------------------------------*/
#include <stdio.h>
#include <conio.h>
#include<iostream.h>
int main()
{
char A[1000];
char a[1],b[1]; //wczytaj caly tekst do tablicy znakowej
int linie,znaki,wyrazy,i,j,k,l; //policz i wypisz ilosc wszyskich znakow
//--------------------------------------------------------------------
linie=0;
wyrazy=0;
znaki=0;
i=0;
k=0;

// jakas petla
b[0]='~';
while((scanf("%c",&a[0]))&&(k!=2))
{ //sprawdzaj w petli znaki z tablicy:
switch(a[0])
{
case ' ': {
if(b[0]!=' ')
{
A[i]=a[0];
i++;l++;
b[0]=a[0];
}else{l++;}
break; //usuwaj zbedne spacje (zostaw maks 1-na)
}
case '\n': {
if(b[0]!='\n')
{
A[i]=a[0];
i++;l++;
b[0]=a[0];
linie++;
break;
}
else
{k=2;break;l++;}
}


//licz linie, restartuj licznik wyrazow
default : {
if((b[0]!=' ')&&(b[0]!='\n')&&(b[0]!='~'))
{
A[i]=a[0];
i++;l++;
b[0]=a[0];
znaki++;
break;
}
else
{
A[i]=a[0];
i++;l++;
b[0]=a[0];
wyrazy++;
znaki++;
break;
}
} // licz wyrazy i znaki czarne
}
}
for(j=0;j<i;j++){cout<<A[j];};
//wypisz ile bylo wyrazow w linii

//-----------------------------------------------------------------------
cout<<"\n"<<"W tekscie bylo:"<<endl<<linie<<" linii"<<endl<<znaki
<<" czarnych znakow"<<endl<<wyrazy<<" wyrazow"; //wypisz ile linii oraz czarnych znakow w tekscie
getch();
//return 0;
}

// OPERACJE NA LISCIE DYNAMICZNEJ

// POLECENIA:
// 1. Zapoznaj sie z programem LISTA1.CPP i sprawdz jego dzialanie.
// 2. Dopisz 3 funkcje i wlacz je do menu w main() :
// a. Wzorujac sie na procedurze: void Pisz_Liste()
// napisz i wlacz do programu procedure: void Pisz_Parzyste() ,
// ktora wypisuje na ekranie tylko "Wartosci" parzyste z listy.
// b. Wzorujac sie na procedurze: void Usun_Liste()
// napisz i wlacz do programu procedure: void Usun_K_z_Listy() ,
// ktora usuwa tylko K liczb z poczatku listy. Jezeli lista
// zawiera mniej niz K elementow, to usuwane sa wszystkie. Liczba
// K jest wczytywana wewnatrz tej procedury.
// c. (zad. nieobowiazkowe) Wzorujac sie na procedurze: void Pisz_Liste()
// napisz i wlacz do programu procedure: void Pisz_do_Pliku() ,
// ktora zapisuje do pliku tekstowego "Wartosci" z listy, (nazwe
// pliku podaje uzytkownik, patrz program Pliki2.cpp z katalogu cpp_9a).
//
// a. 2pkt b.3pkt c. 3pkt

//-------------------------------------------------------------------------

/************************************************** ****************/
/* OPIS PROGRAMU LISTA.CPP - */
/* Program tworzy liste jednokierunkowa bez sortowania elementow. */
/* Element roboczy listy przechowuje wartosc typu calkowitego */
/* oraz wskaznik na nast&#169;pny element. */
/* Utowrzona lista jest ukierunkowana "do przodu". */
/* Program umozliwia rowniez wyswietlenie kolejnych wartosci */
/* calkowitych znajdujacych sie na liscie oraz usuwanie listy. */
/* Dla uproszczenia - brak kontroli danych. */
/************************************************** ****************/

#include <iostream.h>
#include <conio.h>
typedef struct El // struktura elementu roboczego
{ int Wartosc;
struct El *Nastepny; // wska&#171;nik do nast&#169;pnego elementu
} ELEMENT;
typedef struct // struktura elementu informacyjnego(listy)
{ ELEMENT *Glowa;
ELEMENT *Ogon;
}INFO;

INFO *Lista; // wska&#171;nik do elementu informacyjnego
// dla uproszenia zadeklarowano go
// jako zmienna globalna
void Pisz_Menu();
void Do_Listy( int W);
void Dopisz_K_elem_do_Listy();
void Pisz_Liste();
void Usun_Liste();
//$$$
//$$$
//$$$

//================================================== ===================
void main ()
{
char znak;

Lista = new INFO;
Lista->Glowa = NULL;
Lista->Ogon = NULL;

do
{
clrscr();
Pisz_Menu();
znak=getch();
switch (znak)
{
case '1': Dopisz_K_elem_do_Listy(); break;
case '2': Pisz_Liste(); break;
case '3': Usun_Liste(); break;
case '4': ; break; //$$$
case '5': ; break; //$$$
case '6': ; break; //$$$
}
}
while (znak !='7');
// koniec programu
Usun_Liste();
}

//================================================== =======PROCEDURY=====

void Pisz_Menu()
{
cout <<"PRZYKLADOWE OPERACJE NA LISCIE DYNAMICZNEJ\n";
cout <<"1. Dopisz k liczb do listy\n";
cout <<"2. Pokaz cala liste\n";
cout <<"3. Usun cala liste\n";
cout <<"4. Pokaz elementy parzyste w liscie\n";
cout <<"5. Usun k elementow poczatkowych z listy\n";
cout <<"6. Zapisz liste na plik tekstowy\n";
cout <<"7. Zakoncz program\n";
cout <<"*********************************************** *\n";
}

//-------------------------------------------------------------------------
void Do_Listy(int W)
/* Procedura dolacza nowy element do listy - na koniec listy */
{
ELEMENT *Nowy;
Nowy = new ELEMENT;
if (Lista->Glowa == NULL) // doˆ&#165;czenie nowego elementu
{ // do listy pustej
Lista->Glowa = Nowy;
Lista->Ogon = Lista->Glowa;
}
else // doˆ&#165;czenie nowego elementu
{ Lista->Ogon->Nastepny = Nowy; // na koäcu listy niepustej
Lista->Ogon = Nowy;
}
Nowy->Wartosc = W;
Nowy->Nastepny = NULL;
}

//---------------------------------------------------------------------
void Dopisz_K_elem_do_Listy()
/* Procedura dopisuje K elementow na koniec listy */
{
int i, K, W;

clrscr();
cout << "Ile elementow dopisujemy do listy (podaj K<6): ";
cin >> K;
cout << "Wprowadz kolejne elementy listy:\n";
for (i=1; i <=K; i++)
{
cout << "element_";
cout.width(2);
cout << i << " = ";
cin >> W;
Do_Listy(W);
}
cout << "Elementy dopisano do listy - nacisnij klawisz\n";
getch();
}

//------------------------------------------------------------------------
void Pisz_Liste()
/* Procedura wyswietla elementy listy w kierunku od poczatku do konca */
{
ELEMENT *Biezacy;
int i = 0;

clrscr();
Biezacy = Lista->Glowa;
if (Lista->Glowa == NULL)
cout << "Lista jest pusta\n";
else while (Biezacy != NULL)
{
i++;
cout.width(2);
cout << "element_"<< i << " : " << Biezacy->Wartosc << endl;
Biezacy = Biezacy->Nastepny;
}
cout << "Wypisano elementy z listy - nacisnij klawisz\n";
getch();
}

//-------------------------------------------------------------------------
void Usun_Liste()
{
int i=0;
ELEMENT *Usuniety;

if (Lista->Glowa == NULL)
cout << "Lista jest pusta - nacisnij klawisz";
else { while (Lista->Glowa != NULL)
{
i++;
Usuniety = Lista->Glowa;
Lista ->Glowa = Lista ->Glowa->Nastepny;
delete Usuniety;
}
if (Lista ->Glowa == NULL)
cout << "\nListe usunieto ( " <<
i <<" element. ) - nacisnij klawisz" << endl;
}
getch();
}

//------------------------------------------------------------------------

Ten nie jest do końca uzupełniony i za to przepraszam

/*=========================FUNKCJE I WSKAZNIKI=============*/
/* Program umozliwia: */
/* 1. Wczytanie aktualnego rozmiaru tablicy liczb calk. */
/* 2. Losowanie elementow tablicy liczb calkowitych; */
/* 3. Okreslenie indeksow elementow minimalnego i */
/* maksymalnego, a takze ich wartosci; */
/* 4. Obliczenie sredniej arytmetycznej elementow */
/* lezacych pomiedzy elementami minimalnym i */
/* maksymalnym ( lacznie z nimi). */
/* 5. Podanie adresow tablicy X, elementu minimalnego */
/* i maksymalnego. */
/*==========================UZUPELNIJ PROGRAM==============*/
#include <iostream.h>
#include <conio.h> // getch();
#include <stdlib.h> //do geratora liczb losowych
#include <time.h> //do geratora liczb losowych
#include <stdio.h>
//----------------------------------------FUNKCJE-----------
void Dane_Tab(int *wsk_n, int *wsk_tab); //PUNKTACJA:
void Ind_Min_Max(int n, int *wsk_tab,int *wsk_Ind_Min, int *wsk_Ind_Max); // 2pkt
double Srednia(int *wsk_tab, int poz_Min, int poz_Max); // 2+2 pkt
void Pisz_El_Max (int *wsk_tab, const int *wsk_Max); // 1pkt
void Pisz_El_Min (int *wsk_tab , int poz_Min); // 1pkt
//-------------------------------------------------
main () // blok glowny 2pkt
{

int x;
const int n_Max = 10; // max rozmiar tablicy
int X[n_Max]; // definicja tablicy

int n, // aktualny rozmiar tablicy
Ind_Min, //indeks elementu min.
Ind_Max; // indeks elementu maks.
Dane_Tab ( &n,X );
//goto koniec; // WYRZUC TA INSTRUKCJE, KIEDY UZUPELNISZ PROGRAM

//--------------------------------------------------------------
Ind_Min_Max (n,X, &Ind_Min,&Ind_Max );//uzupelnij
Pisz_El_Max (X, &Ind_Max );//uzupelnij
Pisz_El_Min (X , Ind_Min);//uzupelnij
//uzupelnij tam gdzie ?
cout<< "\nSrednia wartosc elementow miedzy MIN a MAX: ";
cout<< Srednia(X, Ind_Min, Ind_Max)<<endl;
cout<<"\nAdresy ( tabl.X, El_Min, El_Max): "<<endl;
cout<< hex << &X <<" "<< ( &X[Ind_Max] ) <<" "<<( &X[Ind_Min] )<<endl; //adresy w bajtach(liczby 16-owe)
cout<< dec << (int)(&X) <<" "<<(int)(&X[Ind_Max]) <<" "<<(int)(&X[Ind_Min]);//adresy w (int)

koniec:getch();
} // koniec bloku glownego
//--------------------------------------------------------

void Dane_Tab(int *wsk_n, int *wsk_tab)
//================================================== =======
// Wczytanie rozmiaru i kolejnych element&#162;w tablicy.
// UWAGA:
// wsk_n - wskaznik do aktualnego rozmiaru tablicy;
// wsk_tab - wskaznik do tablicy elementow.
//================================================== =======
{ int i;
cout << "Podaj rozmiar tablicy [1,10]: ";
cin >> *wsk_n;

time_t t; //inicjacja generat.liczb.losowych wg czasu komp.
srand((unsigned) time(&t));

cout << "\nWylosowano elementy tablicy X:\n";
cout <<"[0] [1] [2] [3] [4] [5] [6] [7] [8] [9]"<< endl;
for (i = 0; i < *wsk_n; i++)
{
*(wsk_tab+i)=rand()%20; //losujemy liczby z [0; 20]
cout.width (2); cout<< *(wsk_tab+i) << " ";
}
cout<<endl<<endl;
}

//-----------------------------------------------------------
void Ind_Min_Max(int n, int *wsk_tab,
int *wsk_Ind_Min, int *wsk_Ind_Max)
//================================================== =======
// Okreslenie indeksow elementow min i max.
// UWAGA:
// n - rozmiar tablicy;
// wsk_tab - wskaznik do tablicy elementow;
// wsk_Ind_Min - wskaznik do indeksu elementu min.;
// wsk_Ind_Max - wskaznik do indeksu elementu maks.
//================================================== =======
{
int i, El_Max, El_Min;
El_Max = *wsk_tab; *wsk_Ind_Max = 0;
El_Min = *wsk_tab; *wsk_Ind_Min = 0;

for (i =0; i< n; i++, wsk_tab++)
{
if (El_Max < *wsk_tab)
{
El_Max = *wsk_tab;
*wsk_Ind_Max = i;
}
//uzupelnij
if (El_Min > *wsk_tab)
{
El_Min = *wsk_tab;
*wsk_Ind_Min = i;
}
}
}
//-----------------------------------------------------------

double Srednia(int *wsk_tab, int poz_Min, int poz_Max)
//================================================== ========
// 1. Obliczenie sredniej arytmetycznej elementow
// lezacych pomiedzy elementami minimalnym i
// maksymalnym w tabicy o adresie poczatkowym wsk_tab.
// 2. UWAGA: elementy minim. i maksym. wliczamy
// do sredniej.
// poz_Min - wskaznik do indeksu elem. min.;
// poz_Max - wskaznik do indeksu elem. maks.
//================================================== ========
{ double suma=0;
// uzupelnij
int p, i, k; // index pocz. , biezacy i koncowy dla dodawania
if (poz_Min<poz_Max){p=poz_Min; k=poz_Max;}
else {p=poz_Max; k=poz_Min;}
for ( i=p;i<=k; i++) suma +=*(wsk_tab+i);
return ( suma/(k-p+1));
//uzupelnij :2-ga wersja (uzyj wylacznie wskaznikow)
// int *s, *p,*i, *k;
// s=suma; *s= ;
// if ( ){p= ; k= ;}
// else {p= ; k= ;}
// for (i=p; ; )(*s) += ;
// return ( );
}
//--------------------------------------------------------
void Pisz_El_Max (int *wsk_tab, const int *wsk_Max)
//================================================== ========
// wsk_tab - adres poczatku tablicy ;
// wsk_Ind_Max - indeks elementu maks.
//================================================== ========
{
cout << "\nElement o wartosci maksymalnej: ";
cout << *wsk_tab<<endl;//uzupelnij;
cout << "Numer elementu maksymalnego: " << *(wsk_Max) <<endl;//uzupelnij;
cout << endl;
}
//--------------------------------------------------------

void Pisz_El_Min (int *wsk_tab , int poz_Min )//uzupelnij
//================================================== ========
// wsk_tab - adres poczatku tablicy ;
// wsk_Ind_Min - indeks elementu minim.
//================================================== ========
{
cout << "\nElement o wartosci minimalnej: ";
cout << *wsk_tab<<endl;//uzupelnij;
cout << "Numer elementu minimalnego: " <<poz_Min<<endl;//uzupelnij;
cout << endl;
}
//----------------------------------------------------------

/*=========================FUNKCJE I WSKAZNIKI=============*/
/* Program umozliwia: */
/* 1. Wczytanie aktualnego rozmiaru tablicy liczb calk. */
/* 2. Losowanie elementow tablicy liczb calkowitych; */
/* 3. Okreslenie indeksow elementow minimalnego i */
/* maksymalnego, a takze ich wartosci; */
/* 4. Obliczenie sredniej arytmetycznej elementow */
/* lezacych pomiedzy elementami minimalnym i */
/* maksymalnym ( lacznie z nimi). */
/* 5. Podanie adresow tablicy X, elementu minimalnego */
/* i maksymalnego. */
/*==========================UZUPELNIJ PROGRAM==============*/
#include <iostream.h>
#include <conio.h> // getch();
#include <stdlib.h> //do geratora liczb losowych
#include <time.h> //do geratora liczb losowych
#include <stdio.h>
//----------------------------------------FUNKCJE-----------
void Dane_Tab(int *wsk_n, int *wsk_tab); //PUNKTACJA:
void Ind_Min_Max(int n, int *wsk_tab,int *wsk_Ind_Min, int *wsk_Ind_Max); // 2pkt
double Srednia(int *wsk_tab, int poz_Min, int poz_Max); // 2+2 pkt
void Pisz_El_Max (int *wsk_tab, const int *wsk_Max); // 1pkt
void Pisz_El_Min (int *wsk_tab , int poz_Min); // 1pkt
//-------------------------------------------------
main () // blok glowny 2pkt
{

int x;
const int n_Max = 10; // max rozmiar tablicy
int X[n_Max]; // definicja tablicy

int n, // aktualny rozmiar tablicy
Ind_Min, //indeks elementu min.
Ind_Max; // indeks elementu maks.
Dane_Tab ( &n,X );
//goto koniec; // WYRZUC TA INSTRUKCJE, KIEDY UZUPELNISZ PROGRAM

//--------------------------------------------------------------
Ind_Min_Max (n,X, &Ind_Min,&Ind_Max );//uzupelnij
Pisz_El_Max (X, &Ind_Max );//uzupelnij
Pisz_El_Min (X , Ind_Min);//uzupelnij
//uzupelnij tam gdzie ?
cout<< "\nSrednia wartosc elementow miedzy MIN a MAX: ";
cout<< Srednia(X, Ind_Min, Ind_Max)<<endl;
cout<<"\nAdresy ( tabl.X, El_Min, El_Max): "<<endl;
cout<< hex << &X <<" "<< ( &X[Ind_Max] ) <<" "<<( &X[Ind_Min] )<<endl; //adresy w bajtach(liczby 16-owe)
cout<< dec << (int)(&X) <<" "<<(int)(&X[Ind_Max]) <<" "<<(int)(&X[Ind_Min]);//adresy w (int)

koniec:getch();
} // koniec bloku glownego
//--------------------------------------------------------

void Dane_Tab(int *wsk_n, int *wsk_tab)
//================================================== =======
// Wczytanie rozmiaru i kolejnych element&#162;w tablicy.
// UWAGA:
// wsk_n - wskaznik do aktualnego rozmiaru tablicy;
// wsk_tab - wskaznik do tablicy elementow.
//================================================== =======
{ int i;
cout << "Podaj rozmiar tablicy [1,10]: ";
cin >> *wsk_n;

time_t t; //inicjacja generat.liczb.losowych wg czasu komp.
srand((unsigned) time(&t));

cout << "\nWylosowano elementy tablicy X:\n";
cout <<"[0] [1] [2] [3] [4] [5] [6] [7] [8] [9]"<< endl;
for (i = 0; i < *wsk_n; i++)
{
*(wsk_tab+i)=rand()%20; //losujemy liczby z [0; 20]
cout.width (2); cout<< *(wsk_tab+i) << " ";
}
cout<<endl<<endl;
}

//-----------------------------------------------------------
void Ind_Min_Max(int n, int *wsk_tab,
int *wsk_Ind_Min, int *wsk_Ind_Max)
//================================================== =======
// Okreslenie indeksow elementow min i max.
// UWAGA:
// n - rozmiar tablicy;
// wsk_tab - wskaznik do tablicy elementow;
// wsk_Ind_Min - wskaznik do indeksu elementu min.;
// wsk_Ind_Max - wskaznik do indeksu elementu maks.
//================================================== =======
{
int i, El_Max, El_Min;
El_Max = *wsk_tab; *wsk_Ind_Max = 0;
El_Min = *wsk_tab; *wsk_Ind_Min = 0;

for (i =0; i< n; i++, wsk_tab++)
{
if (El_Max < *wsk_tab)
{
El_Max = *wsk_tab;
*wsk_Ind_Max = i;
}
//uzupelnij
if (El_Min > *wsk_tab)
{
El_Min = *wsk_tab;
*wsk_Ind_Min = i;
}
}
}
//-----------------------------------------------------------

double Srednia(int *wsk_tab, int poz_Min, int poz_Max)
//================================================== ========
// 1. Obliczenie sredniej arytmetycznej elementow
// lezacych pomiedzy elementami minimalnym i
// maksymalnym w tabicy o adresie poczatkowym wsk_tab.
// 2. UWAGA: elementy minim. i maksym. wliczamy
// do sredniej.
// poz_Min - wskaznik do indeksu elem. min.;
// poz_Max - wskaznik do indeksu elem. maks.
//================================================== ========
{ double suma=0;
// uzupelnij
int p, i, k; // index pocz. , biezacy i koncowy dla dodawania
if (poz_Min<poz_Max){p=poz_Min; k=poz_Max;}
else {p=poz_Max; k=poz_Min;}
for ( i=p;i<=k; i++) suma +=*(wsk_tab+i);
return ( suma/(k-p+1));
//uzupelnij :2-ga wersja (uzyj wylacznie wskaznikow)
// int *s, *p,*i, *k;
// s=suma; *s= ;
// if ( ){p= ; k= ;}
// else {p= ; k= ;}
// for (i=p; ; )(*s) += ;
// return ( );
}
//--------------------------------------------------------
void Pisz_El_Max (int *wsk_tab, const int *wsk_Max)
//================================================== ========
// wsk_tab - adres poczatku tablicy ;
// wsk_Ind_Max - indeks elementu maks.
//================================================== ========
{
cout << "\nElement o wartosci maksymalnej: ";
cout << *wsk_tab<<endl;//uzupelnij;
cout << "Numer elementu maksymalnego: " << *(wsk_Max) <<endl;//uzupelnij;
cout << endl;
}
//--------------------------------------------------------

void Pisz_El_Min (int *wsk_tab , int poz_Min )//uzupelnij
//================================================== ========
// wsk_tab - adres poczatku tablicy ;
// wsk_Ind_Min - indeks elementu minim.
//================================================== ========
{
cout << "\nElement o wartosci minimalnej: ";
cout << *wsk_tab<<endl;//uzupelnij;
cout << "Numer elementu minimalnego: " <<poz_Min<<endl;//uzupelnij;
cout << endl;
}
//----------------------------------------------------------

/*---------------------------------------------------------*/
/* OPERACJE NA TABLICY DWUWYMIAROWEJ */
/* Program umozliwia: */
/* 1. Wczytanie aktualnego rozmiaru tablicy liczb calk. */
/* 2. Wczytanie elementow tablicy liczb calkowitych; */
/* 3. Zamiane miejscami elementow tablicy lezacych */
/* po przeciwnej stronie prostej pionowej dzielacej */
/* tablice na dwie rowne czesci. */
/* 4. Wyswietlenie tablicy po zamianie kolumn. */
/* Uwaga: brak kontroli danych. */
/*---------------------------------------------------------*/

//POLECENIA:
// 1) PRZEANALIZUJ DZIALANIE PROGRAMU
// 2) NAPISZ FUNKCJE int Suma( , , ) , KTORA ZWRACA WARTOSC SUMY
// ELEMENTOW NA OBWODZIE TABLICY DWUWYMIAROWEJ. WYWOLAJ FUNKCJE
// W main(), ABY PROGRAM WYPISYWAL NA EKRANIE OBLICZONA SUME;
// 3) ZASTAP FUNKCJE Zamien_1 PRZEZ FUNKCJE Zamien_2, KTORA:
// " Zamienia miejscami elementy tablicy lezace
// po przeciwnej stronie prostej poziomej dzielacej
// tablice na dwie rowne czesci"
// 4) Zastap czytanie tablicy jej losowaniem, zmien postac dwoch funkcji
// tak aby zostaly uzyte zmienne wskaznikowe zamiast A[][]
// 5) Napisz funkcje, ktora dokonuje transpozycji tablicy A[n][m]
// do Tablicy Dynamicznej B[m][n].
//
// PUNKTACJA: 2)3punkty 3)3pkt 4)3pkt 5)4pkt .
//---------------------------------------------------------------------


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


#include <iostream.h>
#include <conio.h>

const int n_Max = 10; // max liczba wierszy tablicy
const int m_Max = 10; // max liczba kolumn tablicy
// parametry formalne moga byc oznaczone innymi nazwami niz aktualne !!!

/*int **B;
int xsize,ysize=10;*/

void Czyt_Dane(int *n, int *m, int A[][10]);
void Zamien_1(int n, int m, int A[][10]);
void Zamien_2(int n, int m, int A[][10]); //$$$
void Pisz_Tab (int n, int m, int A[][10]);
int Suma (int n, int m, int A[][10]);
void Trans (int n, int m, int A[][10], int **B,int linia[10]);

/************************************************** ***************/
main () // blok glowny
{
int A[n_Max][m_Max]; // definicja tablicy
int n,i; // aktualna liczba wierszy
int m,k; // aktualna liczba kolumn
int** B, *linia; // t, linia - nazwy tablic (wskaznikow)
// ilosc wierszy i kolumn, moze byc wczytana na biezacoint** t;

B=new int* [n_Max]; linia= new int[n_Max] ; //przez new[] - tylko w c++
for(int i=0; i<n_Max; i++) B[i]= new int [m_Max];



cout << "ZAMIANA KOLUMN W TABLICY DWUWYMIAROWEJ\n\n\n";
Czyt_Dane (&n,&m, A);

// clrscr();
cout <<"Tablica przed zamiana: "<<endl;
Pisz_Tab (n, m, A);
//Zamien_1(n, m, A);
Zamien_2(n, m, A);
cout <<"Tablica po zamianie: "<<endl;
Pisz_Tab (n, m, A);
cout <<"Suma Liczb na obwodzie: "<<endl;
cout <<Suma(n,m,A)<<endl;
cout <<"Tablica transponowana: "<<endl;
Trans(n,m,A,B,linia);

getch();
} // koniec bloku glownego

/*---------------------------------------------------------*/

void Czyt_Dane(int *n, int *m, int A[][10])
/* Wczytanie rozmiaru i kolejnych elementow tablicy */
{
int j,i;
cout << "Podaj liczbe wierszy: ";
cin >> *n;
cout << "Podaj liczbe kolumn: ";
cin >> *m;

time_t t; //inicjacja generat.liczb.losowych wg czasu komp.
srand((unsigned) time(&t));


for (i = 0; i < *n; i++)
{ for (j = 0; j < *m; j++)
{
*(*(A+i)+j)=rand()%20; //losujemy liczby z [0; 20]
cout.width (2);
}
cout<<"\n";
}
}




/*---------------------------------------------------------*/

void Zamien_2(int n, int m, int A[][10])
/* Zamiana miejscami elementow tablicy lezacych po */
/* przeciwnych stronach prostej pionowej dzielacej */
/* tablice na dwie rowne czesci */
{
int i,j, pom;

for (i = 0; i < m; i++)
for (j = 0; j < n/2; j++)
{
pom = A[j][i];
A[j][i] = A[n-j-1][i];
A[n-j-1][i] = pom;
}
}

/*---------------------------------------------------------*/
void Zamien_1(int n, int m, int A[][10])
/* Zamiana miejscami elementow tablicy lezacych po */
/* przeciwnych stronach prostej pionowej dzielacej */
/* tablice na dwie rowne czesci */
{
int i,j, pom;

for (i = 0; i < n; i++)
for (j = 0; j < m/2; j++)
{
pom = A[i][j];
A[i][j] = A[i][n-j-1];
A[i][n-j-1] = pom;
}
}






/*-----------------------------------------------------------*/
void Pisz_Tab (int n, int m, int A[][10])
/* Wyswietlenie tablicy */
{ int i,j, x, y;

for (i = 0; i < n; i++)
{ for (j = 0; j < m; j++)
{
cout << *(*(A+i)+j)<<'\t';
}
cout << endl;
}
}

/*--------------------------------------------------------*/
int Suma (int n, int m, int A[][10])
/* Zliczanie na obwodzie*/
{ int i,suma2;
suma2=0;
for (i=0; i<m; i++)
suma2=suma2+A[0][i];

for (i=1; i<n; i++)
suma2=suma2+A[i][0];

for (i=1; i<m; i++)
suma2=suma2+A[n-1][i];

for (i=1; i<n-1; i++)
suma2=suma2+A[i][m-1];

return suma2;
}
/*--------------------------------------------------------*/
void Trans (int n, int m, int A[][10], int **B,int linia[10])
{ int i,j,k;

for( i=0; i<n_Max; i++)
{ linia[i]=i+1;
for( j=0; j<m_Max; j++)
{
B[i][j]=*(*(A+j)+i); // !!! TO SAMO CO: B[i][j]=A[j][i];

} }
printf("\n");
k=m; m=n; n=k;
for (i = 0; i < n; i++)
{ for (j = 0; j < m; j++)
{
cout << *(*(B+i)+j)<<'\t';
}
cout << endl;
}



// delete []B; delete[]linia; //---------zwolnienie pamieci powolanej przez new
}

//CZYTANIE DANYCH Z PLIKU I ZAPISYWANIE WYNIKOW NA PLIK TEKSTOWY
//PRZYGOTOWANO PLIK PL1.TXT ; PLIK WYNIKOWY dowolna nazwa uzytkownika,
// najlepiej z rozszerzeniem *.txt

#include <fstream.h>
#include <iostream.h>
#include <conio.h>
#include <stdlib.h>

fstream mojplik; //zmienna typu plikowego
// mojplik to nazwa dowolna
char Nazwa_Pliku[50];
int i, L;
double a,b,suma;
char znak, buf[80];

main()
{
// clrscr();
//------------------------------------dane z pliku, kopiowane na ekran ---
cout << "Podaj nazwe pliku: ";
cin >> Nazwa_Pliku;
mojplik.open(Nazwa_Pliku, ios::in);

if (!mojplik) // sprawdzanie czy taki plik isnieje
{ cout << "Blad otwarcia pliku " << Nazwa_Pliku << endl;
}
else
{
cout << "Dane z pliku " << Nazwa_Pliku<<": \n\n";

//szukanie 1-ej nowej linii w pliku z kopiowanim znakow,
//gdy tylko while(); to bez kopiowania znakow do buf[]
i=0;
while ( (znak=mojplik.get()) != '\n'|| (i==80))
{buf[i++]= znak;};

mojplik >> L;
mojplik >> a >> b;
//-----sprawdzamy, co wczytano z pliku
cout << buf;
cout << "\netload= " << L<< " a= "<< a << " b= " << b;
mojplik.close();
cout << endl << "Zakoäczono operacje w pliku " << Nazwa_Pliku << endl;

//------------obliczenia--------
suma=a+b; L++;
//-----wyniki do pliku i na ekran----

//------------------------------------ wyniki do pliku i na ekran ---
cout << "\n\nPodaj nazwe pliku dla wynikow: ";
cin >> Nazwa_Pliku;
mojplik.open(Nazwa_Pliku, ios:ut );
mojplik << "\nWYNIKI OBLICZEN\n";
mojplik << suma <<" suma a+b\n";
mojplik << L << " L+1\n";
cout << "\n\nWYNIKI OBLICZEN\n";
cout << suma <<" suma\n";
cout << L << " L\n";
} //koniec else
mojplik.close();
cout << endl << "Zakoäczono operacje w pliku " << Nazwa_Pliku << endl;

//----------------------------------------------------koniec-----------
while (!kbhit()){ } //to samo co getch();
}

/STRUKTURY DYNAMICZNE I PLIKI

/************************************************** ****************/
/* OPIS PROGRAMU LISTA.CPP - PRZYKLAD Z WYKLADU */
/* Program tworzy liste jednokierunkowa bez sortowania elementow. */
/* Element roboczy listy przechowuje wartosc typu calkowitego */
/* oraz wskaznik na nast&#169;pny element. */
/* Utowrzona lista jest ukierunkowana "do przodu". */
/* Program umozliwia rowniez wyswietlenie kolejnych wartosci */
/* calkowitych znajdujacych sie na liscie oraz usuwanie listy. */
/* Dla uproszczenia - brak kontroli danych. */
/************************************************** ****************/

#include <iostream.h>
#include <conio.h>

typedef struct El // struktura elementu roboczego
{ int Wartosc;
struct El *Nastepny; // wska&#171;nik do nast&#169;pnego elementu
} ELEMENT;
typedef struct // struktura elementu informacyjnego
{ ELEMENT *Glowa;
ELEMENT *Ogon;
}INFO;

INFO *Lista; // wska&#171;nik do elementu informacyjnego
// dla uproszczenia zadeklarowano go
// jako zmienna globalna
void Pisz_Menu();
void Do_Listy( int W);
void Dopisz_K_elem_do_Listy();
void Pisz_Liste();
void Usun_Liste();

//================================================== ===================
main ()
{
char znak;

Lista = new INFO;
Lista->Glowa = NULL;
Lista->Ogon = NULL;

do
{
//clrscr();
Pisz_Menu();
znak=getch();
switch (znak)
{
case '1': Dopisz_K_elem_do_Listy(); break;
case '2': Pisz_Liste(); break;
case '3': Usun_Liste(); break;
}
}
while (znak !='4');
// koniec programu
Usun_Liste();
}

//================================================== =======PROCEDURY=====

void Pisz_Menu()
{
cout <<"\n********************************************* ***\n";
cout <<"PRZYKLADOWE OPERACJE NA LISCIE DYNAMICZNEJ\n";
cout <<"1. Dopisz k liczb do listy\n";
cout <<"2. Pokaz cala liste\n";
cout <<"3. Usun cala liste\n";
cout <<"4. Zakoncz program\n";
cout <<"*********************************************** *\n";
}

//-------------------------------------------------------------------------
void Do_Listy(int W)
/* Procedura dolacza nowy element do listy - na koniec listy */
{
ELEMENT *Nowy;
Nowy = new ELEMENT;
if (Lista->Glowa == NULL) // doˆ&#165;czenie nowego elementu
{ // do listy pustej
Lista->Glowa = Nowy;
Lista->Ogon = Lista->Glowa;
}
else // doˆ&#165;czenie nowego elementu
{ Lista->Ogon->Nastepny = Nowy; // na koäcu listy niepustej
Lista->Ogon = Nowy;
}
Nowy->Wartosc = W;
Nowy->Nastepny = NULL;
}

//---------------------------------------------------------------------
void Dopisz_K_elem_do_Listy()
/* Procedura dopisuje K elementow na koniec listy */
{
int i, K, W;

//clrscr();
cout << "Ile elementow dopisujemy do listy (podaj K<6): ";
cin >> K;
cout << "Wprowadz kolejne elementy listy:\n";
for (i=1; i <=K; i++)
{
cout << "element_";
cout.width(2);
cout << i << " = ";
cin >> W;
Do_Listy(W);
}
cout << "Elementy dopisano do listy - nacisnij klawisz\n";
getch();
}

//------------------------------------------------------------------------
void Pisz_Liste()
/* Procedura wyswietla elementy listy w kierunku od poczatku do konca */
{
ELEMENT *Biezacy;
int i = 0;

//clrscr();
Biezacy = Lista->Glowa;
if (Lista->Glowa == NULL)
cout << "Lista jest pusta\n";
else while (Biezacy != NULL)
{
i++;
cout.width(2);
cout << "element_"<< i << " : " << Biezacy->Wartosc << endl;
Biezacy = Biezacy->Nastepny;
}
cout << "Wypisano elementy z listy - nacisnij klawisz\n";
getch();
}

//-------------------------------------------------------------------------
void Usun_Liste()
{
int i=0;
ELEMENT *Usuniety;

if (Lista->Glowa == NULL)
cout << "Lista jest pusta - nacisnij klawisz";
else { while (Lista->Glowa != NULL)
{
i++;
Usuniety = Lista->Glowa;
Lista ->Glowa = Lista ->Glowa->Nastepny;
delete Usuniety;
}
if (Lista ->Glowa == NULL)
cout << "\nListe usunieto ( " <<
i <<" element. ) - nacisnij klawisz" << endl;
}
getch();
}

//------------------------------------------------------------------------

potwierdzam dobre pomysłyy

/*---------------------------------------------------------*/
/* OPERACJE NA TABLICY DWUWYMIAROWEJ */
/* Program umozliwia: */
/* 1. Wczytanie aktualnego rozmiaru tablicy liczb calk. */
/* 2. Wczytanie elementow tablicy liczb calkowitych; */
/* 3. Zamiane miejscami elementow tablicy lezacych */
/* po przeciwnej stronie prostej pionowej dzielacej */
/* tablice na dwie rowne czesci. */
/* 4. Wyswietlenie tablicy po zamianie kolumn. */
/* Uwaga: brak kontroli danych. */
/*---------------------------------------------------------*/

//POLECENIA:
// 1) PRZEANALIZUJ DZIALANIE PROGRAMU
// 2) NAPISZ FUNKCJE int Suma( , , ) , KTORA ZWRACA WARTOSC SUMY
// ELEMENTOW NA OBWODZIE TABLICY DWUWYMIAROWEJ. WYWOLAJ FUNKCJE
// W main(), ABY PROGRAM WYPISYWAL NA EKRANIE OBLICZONA SUME;
// 3) ZASTAP FUNKCJE Zamien_1 PRZEZ FUNKCJE Zamien_2, KTORA:
// " Zamienia miejscami elementy tablicy lezace
// po przeciwnej stronie prostej poziomej dzielacej
// tablice na dwie rowne czesci"
// 4) Zastap czytanie tablicy jej losowaniem, zmien postac dwoch funkcji
// tak aby zostaly uzyte zmienne wskaznikowe zamiast A[][]
// 5) Napisz funkcje, ktora dokonuje transpozycji tablicy A[n][m]
// do Tablicy Dynamicznej B[m][n].
//
// PUNKTACJA: 2)3punkty 3)3pkt 4)3pkt 5)4pkt .
//---------------------------------------------------------------------


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


#include <iostream.h>
#include <conio.h>

const int n_Max = 10; // max liczba wierszy tablicy
const int m_Max = 10; // max liczba kolumn tablicy
// parametry formalne moga byc oznaczone innymi nazwami niz aktualne !!!

/*int **B;
int xsize,ysize=10;*/

void Czyt_Dane(int *n, int *m, int A[][10]);
void Zamien_1(int n, int m, int A[][10]);
void Zamien_2(int n, int m, int A[][10]); //$$$
void Pisz_Tab (int n, int m, int A[][10]);
int Suma (int n, int m, int A[][10]);
void Trans (int n, int m, int A[][10], int **B,int linia[10]);

/************************************************** ***************/
main () // blok glowny
{
int A[n_Max][m_Max]; // definicja tablicy
int n,i; // aktualna liczba wierszy
int m,k; // aktualna liczba kolumn
int** B, *linia; // t, linia - nazwy tablic (wskaznikow)
// ilosc wierszy i kolumn, moze byc wczytana na biezacoint** t;

B=new int* [n_Max]; linia= new int[n_Max] ; //przez new[] - tylko w c++
for(int i=0; i<n_Max; i++) B[i]= new int [m_Max];



cout << "ZAMIANA KOLUMN W TABLICY DWUWYMIAROWEJ\n\n\n";
Czyt_Dane (&n,&m, A);

// clrscr();
cout <<"Tablica przed zamiana: "<<endl;
Pisz_Tab (n, m, A);
//Zamien_1(n, m, A);
Zamien_2(n, m, A);
cout <<"Tablica po zamianie: "<<endl;
Pisz_Tab (n, m, A);
cout <<"Suma Liczb na obwodzie: "<<endl;
cout <<Suma(n,m,A)<<endl;
cout <<"Tablica transponowana: "<<endl;
Trans(n,m,A,B,linia);

getch();
} // koniec bloku glownego

/*---------------------------------------------------------*/

void Czyt_Dane(int *n, int *m, int A[][10])
/* Wczytanie rozmiaru i kolejnych elementow tablicy */
{
int j,i;
cout << "Podaj liczbe wierszy: ";
cin >> *n;
cout << "Podaj liczbe kolumn: ";
cin >> *m;

time_t t; //inicjacja generat.liczb.losowych wg czasu komp.
srand((unsigned) time(&t));


for (i = 0; i < *n; i++)
{ for (j = 0; j < *m; j++)
{
*(*(A+i)+j)=rand()%20; //losujemy liczby z [0; 20]
cout.width (2);
}
cout<<"\n";
}
}




/*---------------------------------------------------------*/

void Zamien_2(int n, int m, int A[][10])
/* Zamiana miejscami elementow tablicy lezacych po */
/* przeciwnych stronach prostej pionowej dzielacej */
/* tablice na dwie rowne czesci */
{
int i,j, pom;

for (i = 0; i < m; i++)
for (j = 0; j < n/2; j++)
{
pom = A[j][i];
A[j][i] = A[n-j-1][i];
A[n-j-1][i] = pom;
}
}

/*---------------------------------------------------------*/
void Zamien_1(int n, int m, int A[][10])
/* Zamiana miejscami elementow tablicy lezacych po */
/* przeciwnych stronach prostej pionowej dzielacej */
/* tablice na dwie rowne czesci */
{
int i,j, pom;

for (i = 0; i < n; i++)
for (j = 0; j < m/2; j++)
{
pom = A[i][j];
A[i][j] = A[i][n-j-1];
A[i][n-j-1] = pom;
}
}






/*-----------------------------------------------------------*/
void Pisz_Tab (int n, int m, int A[][10])
/* Wyswietlenie tablicy */
{ int i,j, x, y;

for (i = 0; i < n; i++)
{ for (j = 0; j < m; j++)
{
cout << *(*(A+i)+j)<<'\t';
}
cout << endl;
}
}

/*--------------------------------------------------------*/
int Suma (int n, int m, int A[][10])
/* Zliczanie na obwodzie*/
{ int i,suma2;
suma2=0;
for (i=0; i<m; i++)
suma2=suma2+A[0][i];

for (i=1; i<n; i++)
suma2=suma2+A[i][0];

for (i=1; i<m; i++)
suma2=suma2+A[n-1][i];

for (i=1; i<n-1; i++)
suma2=suma2+A[i][m-1];

return suma2;
}
/*--------------------------------------------------------*/
void Trans (int n, int m, int A[][10], int **B,int linia[10])
{ int i,j,k;

for( i=0; i<n_Max; i++)
{ linia[i]=i+1;
for( j=0; j<m_Max; j++)
{
B[i][j]=*(*(A+j)+i); // !!! TO SAMO CO: B[i][j]=A[j][i];

} }
printf("\n");
k=m; m=n; n=k;
for (i = 0; i < n; i++)
{ for (j = 0; j < m; j++)
{
cout << *(*(B+i)+j)<<'\t';
}
cout << endl;
}



// delete []B; delete[]linia; //---------zwolnienie pamieci powolanej przez new
}