Exemplu (alocarea dinamică a unui text):

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

char *citire_text(void);

void main(void)
{
char *g_text;
puts("");
if ( g_text=citire_text() ) // daca s-a reusit citirea
printf("\ntextul citit:\n%s", g_text);
free(g_text); // elibereaza zona de memorie; vezi mai jos
functia free
}

char *citire_text(void)
{
char *text=NULL; // se creează un pointer care se initializeaza
cu NULL (pointer vid), pentru ca realloc sa se comporte ca si
malloc la prima apelare
char c;
int n=0;
while ( (c=getchar()) != EOF)
{
if((text=(char*)realloc( text, (n+2)*sizeof(char) ))==NULL)
return NULL; // a aparut o eroare
text[n]=c;
++n;
}
// n+2 = n+1 elem(deoarece n porneste de la 0) + 1 pentru'\0'
text[n]='\0'; // termintorul de sir
return text; // returneaza adresa sirului de caractere citit
}
#include <stdlib.h>
#include <stdio.h>
/* problema care citeste si afiseaza o matrice alocata dinamic;
matricea este alocata astfel incat sa poata fi accesata ca o matrice
alocata static*/

int **alocare_matr(int **matr, int *an, int *am);

int citire_matr(int **matr, int n, int m);
void afisare_matr(int **matr, int n, int m);
void main(void)
{
int **matr, m, n;
matr=alocare_matr(matr, &n, &m);
if (matr!=NULL) //s-a putut aloca memorie
citire_matr(matr, n, m);
else
{
printf("eroare la alocare");
return; // se termina programul
}
afisare_matr(matr, n, m);
}

int **alocare_matr(int **matr, int *an, int *am)

{
int i, j;
printf("\nmatricea are N linii si M coloane\n");
printf("N=");
scanf("%d",an );
printf("M=");
scanf("%d",am );

// se aloca memorie pentru pointerii unde se stocheaza inceputul

adresa liniilor
if ( (matr=(int **)calloc(*an,sizeof(int *) ) )==NULL )
return NULL; // daca nu se aloca mem, functia returneaza
NULL

// se aloca memorie pentru matricea efectiva

if ( ( matr[0]=(int *)calloc((*an)*(*am),sizeof(int)))==NULL ) //
operatorul cast
return NULL; // daca nu se aloca mem, functia returneaza
NULL

for( i=1; i<*an; i++ )

matr[i]=matr[0]+i*(*am); //punem in tabl matr adresele
celr n linii din matrice

return matr;
}

int citire_matr(int **matr, int n, int m)

{
int i, j, k=0;
for( i=0; i<n; i++ )
for (j=0; j<m; j++)
{
 printf("a[%d][%d]=", i, j);
k=k+scanf("%d", (*(matr+i)+j) ); //sau,
comportament identic
// k=k+scanf("%d", matr[i][j] );
}
return k;
}

void afisare_matr(int **matr, int n, int m)

{
int i, j;
for( i=0; i<n; i++ )
{
for (j=0; j<m; j++)
printf("%d ", *(*(matr+i)+j) );
printf("\n");
}

Să se scrie o funcţie care calculează cel mai mare divizor comun dintre
două numere întregi nenule, utilizînd algoritmul lui Euclid şi un
apelant pentru testare.

#include <stdio.h>
/*definirea functiei cmmdc*/
int cmmdc(int a, int b)
{ int r,d=a,i=b;
do {r=d%i;
d=i; i=r;}
while(r<>0);
return i;}
void main()
{ int n1,n2;
printf("Numerele pentru care se va calcula cmmdc:");
scanf("%d%d",&n1,&n2);
if(n1&&n2) printf("\ncmmdc=%d",cmmdc(n1,n2));
else printf("Numerele nu sînt nenule!");}

Acelaşi exemplu folosind prototip pentru funcţia cmmdc:

#include <stdio.h>
/* prototipul functiei cmmdc*/
int cmmdc(int, int);
void main()
{ int n1,n2;
printf("Numerele pentru care se va calcula cmmdc:");
scanf("%d%d",&n1,&n2);
if(n1&&n2) printf("\ncmmdc=%d",cmmdc(n1,n2));
else printf("Numerele nu sînt nenule! ");}
/*definirea functiei cmmdc*/
int cmmdc(int a, int b)
{ int r,d=a,i=b;
do {r=d%i;
d=i; i=r;}
while(r<>0);
return i;}
 Să se calculeze produsul scalar dintre doi vectori.

a) rezultatul se întoarce prin numele funcţiei:

float ps(float x[], float y[], int n)
{ int i,prod=0;
for(i=0;i<n;prod+=x[i]*y[i++]);
return prod;}

Apelul se realizează astfel:

float a[30],b[30];
int dimensiune;
………………
printf("Produsul scalar al vectorilor a si b este:%f",
ps(a,b,dimensiune));

b) rezultatul se întoarce prin parametru de ieşire:

void ps(float x[], float y[], int n, float *prod)
{ int i;
*prod=0;
for(i=0;i<n;(*prod)+=x[i]*y[i++]);}

Apelul se realizează astfel:

float a[30],b[30],produs_scalar;
int dimensiune;
ps(a,b,dimensiune,&produs_scalar);
printf("Produsul scalar al vectorilor a si b este:%f",
produs_scalar);

Să se calculeze elementul maxim dintr-un vector şi poziţiile

tuturor apariţiilor acestuia (v, n sînt parametri de intrare; max,
nr_ap, poz sînt parametri de ieşire).

void maxim(float v[],int n,float *max,int *nr_ap,int

poz[])
{ int i;
for(*max=v[0],i=1;i<n;i++)
if(*max<v[i])
{*nr_ap=1;poz[0]=i; max=v[i];}
else if(*max==v[i])poz[*nr_ap++]=i;}

Apelul se realizează astfel:

float a[30],el_max;
int dimensiune,nr_aparitii,pozitii[30];
maxim(a,dimensiune,&max,&nr_aparitii,pozitii);

Să se calculeze produsul dintre o matrice şi un vector.

#include<malloc.h>
……………………
float * prod(float a[][30], float v[],int m, int n)
{ float *p;int i,j;
p=(float *)malloc(sizeof(float)*m);
for(i=0;i<m;i++)
for(p[i]=0,j=0;j<n;j++) p[i]+=a[i][j]*v[j];
return p;}
Apelul se realizează astfel:
float a[20][30], b[30], *c;
int m,n;
…………………………
c=prod(a,b,m,n);

Să se realizeze un program C pentru ridicarea unei matrice la o

putere. Pentru aceasta se folosesc două funcţii care returnează, prin
pointeri, produsul a două matrice (înmulţire), respectiv ridicarea unei
matrice la o putere (putere).

#include<stdio.h>
#include<conio.h>
#include<alloc.h>
float** inmultire(float **a,float **b,int n)
{ int i,j,k; float **c;
c=(float **)malloc(n*sizeof(float *));
for(i=0;i<n;i++)
*(c+i)=(float *)malloc(n*sizeof(float));
for(i=0;i<n;i++)
for(j=0;j<n;j++)
for(k=0,c[i][j]=0;k<n;c[i][j]+=a[i][k]*b[k++][j]);
return c;}
float** putere(float **a,int p,int n)
{ float **c,**ap;int l,m,i;
ap=(float **)malloc(n*sizeof(float *));
for(i=0;i<n;i++)
*(ap+i)=(float *)malloc(n*sizeof(float));
for(l=0;l<n;l++)
for(m=0;m<n;ap[l][m]=a[l][m],m++);
for(i=0;i<p-1;i++)
{c=inmultire(a,ap,n);
for(l=0;l<n;l++)
for(m=0;m<n;ap[l][m]=c[l][m],m++);}
return ap;}
void main()
{ int i,j,p,n,l,m; float **a,**ap,f;
clrscr();
printf("\n n=");
scanf("%i",&n);
a=(float **)malloc(n*sizeof(float *));
for(i=0;i<n;i++)
*(a+i)=(float *)malloc(n*sizeof(float));
for(i=0;i<n;i++)
for(j=0;j<n;j++)
{scanf("%f ",&f);
*(*(a+i)+j)=f;}
scanf("%i",&p);
ap=putere(a,p,n);
for(i=0;i<n;i++)
{for(j=0;j<n;j++)
printf("%f ",*((*(ap+i)+j)));
printf("\n");}
getch();}
 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 termeni construiti:");
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;}