Fakultet elektrotehnike, strojarstva i brodogradnje
Sveucilista u Splitu
Studij racunarstva

Kolegij: Programiranje 1                              Sk.god. 2004/2005

Student: _______________________


                         DOMACI RAD - VJEZBA 9

1. Kratko opisite
   a) Adresu podatka u memoriji racunala
   b) Svrhu & operatora
   c) Svrhu * operatora
   d) Svrhu prijenosa pokazivaca (kao argumenta) u funkciju
   e) Vezu izmedju imena polja podataka i pokazivaca na to polje
   f) Dinamicko alociranje memorije

2. Odgovorite na sljedeca pitanja:
   a) Kako se odredjuje adresa podatka u memoriji racunala?
   b) Koji vrstu informacija sadrzi pokazivac?
   c) Kako se prijavljuje pokazivac? Zasto se navodi oznaka vrste podatka 
      u prijavi pokazivaca?
   d) Koja su dva nacina pristupa clanovima polja?
   e) Sto znaci zbrajanje (ili oduzimanje) cijeloga broja s pokazivacem?

3. Objasnite sljedece prijave:
   a) float a, b;
      float *pa, *pb;
   b) float a = -0.167;
      float *pa = &a;
   c) double *a[12];

4. Napisite prijave za sljedece slucajeve:
   a) Prijaviti dva pokazivaca koji pokazuju na cjelobrojne varijable 
      Broj i Godina
   b) Prijaviti pokazivac na float podatak i pokazivac na double podatak
   c) Prijaviti jednodimenzionalno float polje primjenom pokazivaca
   d) Prijaviti int funkciju Funkcija1 koja ocekuje dva argumenta. Svaki 
      argument je pokazivac na cjelobrojni podatak.

5. Program za odredjivanje povrsine trapeznim pravilom (P_082) preraditi 
   na nacin da se polje podataka definira pokazivacem. Broj clanova 
   polja neka se odredi za vrijeme izvodjenja programa (dinamicka 
   alokacija memorije)

----------------------------------------------------------------------
                          ODGOVORI / RJESENJA
----------------------------------------------------------------------
//Opet,pitanja mozda i nisu tocna

1.
	a) Adresa podatka u memoriji je lokacija na kojoj je zapisan podatak u memoriji. 
	b) &-adresni operator,pokaziva na adresu memorijske lokacije.
	c) *-operator indirekcije,pristupamo sadržaju na koji pokazuje pokazivač
	d) Ako pošaljemo pokazivače kao argumente u funkciju,tada svaka će svaka 
	promjena u funkciji biti vidljiva i u main funkciji,sve promjene se rade direktno 
	nad adresama.
	f) Dinamičko alociranje memorije:

		npr:
		int *polje;
		polje = (int *) malloc ( n*sizeof(int) ); //Rezerviranje memorije za polje, 'n' unese korisnik, broj clanova;
		//rezervira se 4*n B memorije.

	   Pozivom funkcije malloc() postavlja se zahtjev za dodatnim zauzimanjem memorije.
	   Budući da se memorija zauzima u toku izvršavanja programa -dinamičko zauzimanje 
	   memorije.

********************************************************************************************

2.	
	a)	Pomoću adresnog operatora,npr. &x vraća adresu varijable x u memoriji.
	b)	POkazivač sadrži adresu objekta na koju pokaziva.(cijelobrojni tip podatka)
	c)	tip *ime_pokazivaca;
	  	tip označava da je na adresi koju sadrži pokazivač upisana vrijednost zadanog tipa.
	d)	Članovima polje se može pristupiti preko:

		i)direktno npr 	int P[3]={1,2,3};
				printf("%d",P[1]);	Ispis:2 //(0,1)

		ii)preko pokazivaca:
				int P[3]={1,2,3};
				int *p=&P[0];//pokazivac na prvi clan polja
				printf("\n%d %d %d ",*p,*(p+1),*(p+2));//1, pomice za 1,za 2
	
	e)
		zbrajanje, ili oduzimanje cijelog broja s pokazivačem, odnosno aritmetika pokazivača,
	  	omogućava pristup raz. memorijskim lokacijama. npr: ako je p pokazivač na neki element
	 	polja, tada p++ povećava p tako da pokaziva sljedeći element,odnosno p+=i ga povećava
		tako da pokazuje na element koji je 'i' memorijskih lokacija 'udaljen' od elementa na koji
		trenutno pokazuje pokazivač.

***********************************************************************************************

3.

	a)	float a, b;	//Prijava dviju varijabli tipa float
      		float *pa, *pb;	// Prijava dvaju pokazivača koji pokazuju na varijable tipa float.
				// deklarira dva pokazivača, koji će sadržavati adrese realne vrijednosti 
				// u memoriji

	b) 	float a = -0.167;//Deklaracija i inicijalizacija 
      		float *pa = &a;	 //Inicijalizacija pokazivača ,pokazivaču se dodjeljuje adresa u memoriji na 
				// koju je zapiana vrijednost varijable 2
	

	c)	double *a[12];	//deklarcija polja pokazivača koji pokazuju na vrijdnosti tipa double

********************************************************************************************************

4.
	a)	int Broj,Godina;
		int *pBroj=&Broj,*pGodina=&Godina;

	b)	float *pf;
		double *pd;

	c)	 int     *polje;	//pokazivač na polje
		polje = (int *) malloc ( n*sizeof(int) ); //Rezerviranje memorije za polje 'n' unese korisnik, broj clanova


	d)	int Funkcija1 (int*,int*);


***********************************************************************************************************

5.



	#include <stdio.h>
	#include <math.h>
	# include <stdlib.h>

	// Prototipovi funkcija
	double   Povrsina ( int, double *, double );
	double   Funkcija ( double );

	// Glavna funkcija
	main()
	{
		   // Prijava varijabli
		   int      n, i;          // Broj podjela; brojac
		   double  	a, b, h;       // Granice; sirina potpodrucja
		   double   x;             // Argument funkcije
		   double   A;             // Procjena povrsine
		   double  *p;

		   // Unos podataka
		   printf ("Upisite donju granicu  a = ");
		   scanf ("%lf", &a);
		   printf ("Upisite gornju granicu b = ");
		   scanf ("%lf", &b);
			printf ("Upisite broj podjela   n = ");
			   scanf ("%d", &n);
			p=(double*)malloc(n*sizeof(double));

	   // Sirina potpodrucja
	   h = (b - a)/(n - 1);

		// Iznosi funkcija
	   for (i = 0; i < n; i++)
	   	{
		      x = a + i*h;
		      *(p+i) = Funkcija (x);

	        }

	   // Povrsina
	   	A = Povrsina ( n, p, h );
	   printf ("\nZa n = %d   povrsina iznosi A = %8.3f", n, A);

	   return 0;
	}


	//    Funkcija Povrsina
	double   Povrsina ( int n, double *p, double h )
	{
  	 // Prijava varijabli
		int   	i;
  	 double   A;

		// Zbrajanje ordinata
		A = *p + *(p+(n-1));
  	 for (i = 1; i < (n-1); i++)
      	A = A + 2.0*(*(p+i));

   	// Povrat u pozivnu funkciju
  	 return  A*h/2.0;
	}


	//    Funkcija Funkcija
	double   Funkcija ( double x )
	{
  	 return ( x*x*x );
	}