Exemple:

1. Alocarea de spaţiu în heap pentru o matrice.

int** m;
int n,p;
/* se alocă spaţiu pentru vectorul cu adresele celor n linii ale
matricei */
m=(int**)malloc(m*sizeof(int*));
for(int i=0;i<m;i++)
/*se alocă spaţiu pentru fiecare linie a matricei, cîte p elemente*/
m[i]=(int*)malloc(n*sizeof(int));

2. Să se scrie un subprogram pentru citirea de la tastatură a dimensiunii şi elementelor unui

vector memorat în heap.

void cit_vect(int *n, float **v)

{ int i;
printf("Nr. elemente: ");
scanf("%d ", n);
*v=(float*)malloc(*n*sizeof(float));
Programarea calculatoarelor
for(i=0;i<*n;i++)
{ printf("v(%d)= ",i);
scanf("%f",&(*v)[i]);
}
}

3. Să se scrie o funcţie care să citească cel mult n numere întregi şi le păstreze în zona de
memorie a cărei adresă de început este dată printr-un pointer. Funcţia returnează numărul
valorilor citite.

int cit_nr(int n, int* p)

{ int nr, i;
int* q=p+n; // q este adresa unde se termina zona
//rezervata pentru cele n numere
i=0;
while(p<q) //cit timp nu s-au citit n numere
{ printf("Numarul %d= ", i);
if(scanf("%d", &nr)!=1) break; //in caz de eroare la citire
//se termina ciclul
*p=nr;
p++;
i++;
}
return(i);
}

4. Să se aproximeze soluţia unei ecuaţii de forma f(x)=0 prin metoda bisecţiei.

#include<stdio.h>

#include<conio.h>

#include<math.h>

/*prototipul functiei bisectie*/

void bisectie(float,float,float(*f)(float),float,long,int *,float *);

/*prototipul functiei pentru care se aplica metoda bisectiei*/

float fct(float);

/* functia principala*/

void main()

{ float a,b,eps,x;

int cod;

long n;

float (*functie)(float);

clrscr();

printf("Introduceti capetele intervalului:");

scanf("%f%f",&a,&b);

printf("\nEroarea admisa:");

scanf("%f",&eps);

printf("\nNumarul maxim de iteratii:");

scanf("%li",&n);

functie=fct;
bisectie(a,b,functie,eps,n,&cod,&x);

if(!cod)

printf("\nNu se poate calcula solutia aproximativa");

else

printf("\n Solutia aproximativa este: %f",x);

/*descrierea functiei pentru care se aplica metoda bisectiei*/

float fct(float x)

{ return x*x*x-3*x+14;

/*functia ce implementeaza metoda bisectiei*/

void bisectie(float a,float b,float (*f)(float),float eps,long n,

int *cod,float *x)

{ int gata=0;

long c;

for(c=0;(c<n)&&!gata;c++)

{ *x=(a+b)/2;

gata=fabs(*x-a)<eps;

if ((*f)(*x)*(*f)(a)<0)

b=*x;

else a=*x;

*cod=gata;

}
6. Căutarea în vectori sortaţi (căutarea binară)

Fie v este un vector de numere reale sortat crescător şi k este un număr real dat. Problema este de
a identifica (dacă există) o valoare poz, astfel încât v[poz]=k. Rezolvarea ei porneşte cu luarea în
considerare a întregului vector v şi determinarea poziţiei mijlocului m= n/2 . Dacă v[m]=k,
atunci poz:=m. Dacă v[m]>k, atunci se procedează în acelaşi mod cu vectorul format din primele
m componente din v, altfel cu cel format din componentele v[m+1],…,v[n-1]. Se generează astfel
subvectori din ce în ce mai mici până când valoarea k este găsită sau până când nu mai poate fi
generat un nou subvector.

#include <stdio.h>

#include <conio.h>

int cauta_binar(float *,int,int,float);

void main()

{ clrscr();

printf("Dimensiunea vectorului:");

int n;

scanf("%i",&n);

printf("Elementele vectorului\n");

float v[100];

for(unsigned i=0;i<n;i++)

scanf("%f",&v[i]);

printf("Cheia de cautare:");

float k;

scanf("%f",&k);

int c=cauta_binar(v,0,n-1,k);

if(c==-1)

printf("Cheia nu a fost gasita");

else printf("Cheia pe pozitia:%i",c);

getch();

int cauta_binar(float *v,int li,int ls,float k)

{ if(li>ls)

return -1;

int mij=(li+ls)/2;

if(v[mij]==k)

return mij;

if(v[mij]>k)

return cauta_binar(v,li,mij-1,k);

return cauta_binar(v,mij+1,ls,k);

7. Să se scrie o funcţie eficientă pentru ridicarea unui număr la o putere naturală.

Funcţia are ca parametri baza (b) şi exponentul (e) şi returnează, prin numele ei, valoarea cerută.

-varianta iterativă:

long putere(int b,int e)

{ long p=1;

while(e)

if(e%2) {p*=b;e--;}

else {b*=b; e/=2;}

return p;}

-varianta recursivă:

long putere(int b,int e)

{ long p;
if(!e) p=1;

else if(e%2) p=b*putere(b,e-1);

else p=putere(b,e/2)*putere(b,e/=2);

return p;}

8. Să se scrie funcţia pentru aproximarea valorii soluţiei unei ecuaţii algebrice transcendente prin
metoda tangentei. Funcţia are ca parametri de intrare soluţia iniţială (x0), numărul maxim de
iteraţii (n), precizia cerută (eps), valoarea minimă a tangentei (eps2), funcţia asociată ecuaţiei (f),
derivata funcţiei asociate ecuaţiei (fd), derivata funcţiei de iteraţie (gd) şi adresa unde se va
înscrie soluţia. Funcţia returnează prin numele său un cod de eroare cu următoarea semnificaţie:
0 – nu s-a găsit soluţie datorită numărului prea mic de iteraţii; 1 – nu s-a găsit soluţie datorită
anulării derivatei funcţiei asociate ecuaţiei; 2 – nu s-a găsit soluţie deoarece metoda nu este
convergentă pentru datele primite; 3 – s-a găsit soluţie aproximativă.

-varianta iterativă
int tangenta(float x0,int n,float eps,float eps2,float (*f)(float),
float(*fd)(float),float(*gd)(float),float *x)
{ int cod=0;
while((n)&&(!cod))
{if(fabs((*fd)(x0))<eps2) cod=1;
else if(fabs((*gd)(x0))>1) cod=2;
else {*x=x0-(*f)(x0)/(*fd)(x0);
if(fabs(*x-x0)<eps1) cod=3;
else {x0=*x; n--;}
}
}
return cod;}

-varianta recursivă
int tangenta(float x0,int n,float eps,float eps2,float (*f)(float),
float(*fd)(float),float(*gd)(float),float *x)
{ int cod;
if(n==0) cod=0;
else {if(fabs((*fd)(x0))<eps2) cod=1;
else if(fabs((*gd)(x0))>1) cod=2;
else {*x=x0-(*f)(x0)/(*fd)(x0);
if(fabs(*x-x0)<eps1) cod=3;
else cod=tangenta(*x,n-1,eps,eps2,f,fd,gd,x);}
}
return cod;}
9. Să se scrie funcţia pentru calcului lui n!, recursiv şi nerecursiv. Funcţia are ca parametru de
intrare pe n şi returnează, prin numele ei, valoarea factorialului.

-varianta recursivă

long fact(long n)

{ long f;

if (n==1)f=1;

else f=n*fact(n-1);

return(f);}

-varianta iterativă

long fact(long n)

{long f=1;

for(long i=1;i<=n;i++)

f*=i;

return(f);}