https://www.programiz.

com/c-programming/online-compiler/ //compilator C online

Multe exemple sunt de pe 'tutorialspoint'.

int* pc, c; //am declarat un pointer (de tip 'int')'pc' si o variabila 'c' (de ac. tip)

c = 5;

pc = &c; //am asociat acest pointer cu adresa variabilei 'c'

printf("%d", *pc); // Output: 5, cu '*' aflam valoarea variabilei stocata la adresa la care gasim
//pointerul (asociat variabilei)

CONCLUZIE:

- '&' pentru aflarea adresei variabilei si/sau asocierea cu un pointer anterior definit

- '*' pentru aflarea valorii variabilei ce se regaseste la pointerul asociat variabilei

ALT caz: cum am putea schimba valoarea unei variabile utilizand un pointer

int* pc, c;

c = 5;

pc = &c;

*pc = 1; //alocam valoarea 1 prin citirea valorii pointerului asociat var. c si apoi
cu //'=' se asociaza noua valoare pe care o vom gasi la adresa respectiva

printf("%d", *pc); // Ouptut: 1

printf("%d", c); // Output: 1

ALT caz: asociem pointerul definit pe rand la cate o variabila, se observa schimbarea valorii (cat si a
adresei) dupa a doua asociere:

int* pc, c, d;

c = 5;

d = -15;
pc = &c; printf("%d", *pc); // Output: 5

pc = &d; printf("%d", *pc); // Ouptut: -15

Un exemplu mai complex ce combina situatii de mai sus:

#include <stdio.h>

int main()

int* pc, c;

c = 22;

printf("Address of c: %p\n", &c);

printf("Value of c: %d\n\n", c); // 22

pc = &c;

printf("Address of pointer pc: %p\n", pc);

printf("Content of pointer pc: %d\n\n", *pc); // 22

c = 11;

printf("Address of pointer pc: %p\n", pc);

printf("Content of pointer pc: %d\n\n", *pc); // 11

*pc = 2;

printf("Address of c: %p\n", &c);

printf("Value of c: %d\n\n", c); // 2

return 0;

}
va avea iesirea:

Address of c: 2686784

Value of c: 22

Address of pointer pc: 2686784

Content of pointer pc: 22

Address of pointer pc: 2686784

Content of pointer pc: 11

Address of c: 2686784

Value of c: 2

OBS. cateva situatii de eroare:

int c, *pc;

// pc is address but c is not

pc = c; // Error

// &c is address but *pc is not

*pc = &c; // Error

// both &c and pc are addresses

pc = &c; // Not an error

// both c and *pc are values

*pc = c; // Not an error

SI o echivalenta:
int *p = &c; eq. Cu expresiile: int *p; p = &c;

TRECEM la vectori (arrays), sa citim adresele unde se gasesc elementele unui vector:

#include <stdio.h>

int main() {

int x[4];

int i;

for(i = 0; i < 4; ++i) {

printf("&x[%d] = %p\n", i, &x[i]);

printf("Address of array x: %p", x); //cu '%p' afisam adresa de inceput a vectorului care este
//de fapt adresa primului element.

return 0;

va avea iesirea:

&x[0] = 1450734448

&x[1] = 1450734452

&x[2] = 1450734456

&x[3] = 1450734460

Address of array x: 1450734448

//se observa ca adresele sunt din 4 in 4 bytes, compilatorul a alocat aceasta cantitate de memorie
pentru fiecare element al vectorului pentru ca e de tip 'int'
UN mic exemplu prin care folosim pointer pentru a defini elem. unui vector si de a calcula suma
acestor elemente:

#include <stdio.h>

int main() {

int i, x[6], sum = 0;

printf("Enter 6 numbers: ");

for(i = 0; i < 6; ++i) {

// Equivalent to scanf("%d", &x[i]);

scanf("%d", x+i);

// Equivalent to sum += x[i]

sum += *(x+i); //iteram termenii vectorului adunand la suma valoarea gasita

//la urmatoarea adresa (deci a urmatorului element)

printf("Sum = %d", sum);

return 0;

va avea iesirea:
Enter 6 numbers: 2

12

Sum = 29

Inca un ex. care sa mai fixexe o data cele de mai sus:

#include <stdio.h>

int main() {

int x[5] = {1, 2, 3, 4, 5};

int* ptr;

// ptr is assigned the address of the third element

ptr = &x[2];

printf("*ptr = %d \n", *ptr); // 3

printf("*(ptr+1) = %d \n", *(ptr+1)); // 4

printf("*(ptr-1) = %d", *(ptr-1)); // 2

return 0;

va avea iesirea:
*ptr = 3

*(ptr+1) = 4

*(ptr-1) = 2

EXEMPLE cu pointeri ca argumente ale functiilor

Primul ex. ne arata cum sa interschimbam valoarea a doua variabile utilizand o functie cu parametri
pointeri:

#include <stdio.h>

void swap(int *n1, int *n2);

int main()

int num1 = 5, num2 = 10;

// address of num1 and num2 is passed

swap( &num1, &num2); //folosim '&' pentru a lucra cu adresele variabilelor num1 si num2

printf("num1 = %d\n", num1);

printf("num2 = %d", num2);

return 0;

void swap(int* n1, int* n2) //functia lucreaza cu acesti 2 parametri definiti ca pointeri

int temp;

temp = *n1; //variabila temp ia valoarea ce se gaseste la adresa n1

*n1 = *n2; //valoarea de la adresa n1 este inlocuita ce valoarea de la adresa n2

*n2 = temp; //valoarea de la adresa n2 este inlocuita ce temp

va avea iesirea:
num1 = 10

num2 = 5

SI un ex. simplu de incrementare a unei variabile cu ajutorul unui pointer

asociat:
#include <stdio.h>

void addOne(int* ptr) {

(*ptr)++; // aduna 1 la valoarea gasita *ptr

int main()

int* p, i = 10;

p = &i;

addOne(p);

printf("%d", *p); // 11

return 0;

}
INTRODUCERE SI ACCESARE elemente vector utilizand pointeri:
#include <stdio.h>

int main() {

int data[5];

printf("Enter elements: ");

for (int i = 0; i < 5; ++i)

scanf("%d", data + i);

printf("You entered: \n");

for (int i = 0; i < 5; ++i)

printf("%d\n", *(data + i)); //citim element cu element utilizand valorile de la adresele

//succesive ale elementelor vectorului

return 0;

va avea iesirea:
Enter elements: 1

You entered:

EX.1- incrementare pointer

#include <stdio.h>

const int MAX = 3; // constanta de tip integer egala cu nr. de elemente ale vectorului 'var'

int main () {

int var[] = {10, 100, 200};

int i, *ptr; //definim pointer-ul 'ptr'

/* asociem pointer-ul 'ptr' cu adresa de inceput a vectorului 'var' */

ptr = &var;

for ( i = 0; i < MAX; i++) {

printf("Address of var[%d] = %x\n", i, ptr );

printf("Value of var[%d] = %d\n", i, *ptr );

/* prin indexare mergem la locatia de adresa a urmatorului element al vectorului 'var' */

ptr++;

return 0;

EX.2- decrementare pointer

#include <stdio.h>

const int MAX = 3; // constanta de tip integer egala cu nr. de elemente ale vectorului 'var'

int main () {

int var[] = {10, 100, 200};

int i, *ptr;

/* asociem pointer-ul 'ptr' cu adresa ultimului element al vectoruluin 'var' */

ptr = &var[MAX-1];

for ( i = MAX; i > 0; i--) {

printf("Address of var[%d] = %x\n", i-1, ptr );

printf("Value of var[%d] = %d\n", i-1, *ptr );

/* trecem la locatia de memorie a elememtului anterior al vectorului 'var' */

ptr--;

return 0;

EX.3- comparare pointer

#include <stdio.h>

const int MAX = 3;

int main () {

int var[] = {10, 100, 200};

int i, *ptr;

/* pointer-ul are adresa primului element din vector */

ptr = &var;

i = 0;

//bucla se opreste cand se ajunge la adresa ultimului element din vector

while ( ptr <= &var[MAX - 1] ) {

printf("Address of var[%d] = %x\n", i, ptr );

printf("Value of var[%d] = %d\n", i, *ptr );

/* point to the next location */

ptr++;

i++;

return 0;

EX.4- Arrays of pointers

//Incepem cu un vector simplu pentru care afisam elementele
#include <stdio.h>

const int MAX = 3;

int main () {

int var[] = {10, 100, 200};

int i;

for (i = 0; i < MAX; i++) {

printf("Value of var[%d] = %d\n", i, var[i] );

return 0;

//urmatoarea declaratie este a unui vector de pointeri de tip 'int', fiecare element tinand un pointer
a unei valori intregi

int *ptr[MAX];

//prin urmare urmatorul cod asociaza si apoi printeaza toti pointerii referitori la vectorul 'var'

#include <stdio.h>

const int MAX = 3;

int main () {

int var[] = {10, 100, 200};

int i, *ptr[MAX]; //se declara acest vector de pointeri

for ( i = 0; i < MAX; i++) {

ptr[i] = &var[i]; /* asociaza pointer la fiecare element al vectorului 'var' */

for ( i = 0; i < MAX; i++) {

printf("Value of var[%d] = %d\n", i, *ptr[i] ); //afisam valorile ce se gasesc la adresele pointerilor

return 0;

//putem utiliza si alt tip de vector, ca cel de mai jos

#include <stdio.h>

const int MAX = 4;

int main () {

// tipul este 'char' dar apare ca un vector cu 4 elemente de tip 'char', adresarea se face prin pointerul
'names'?

char *names[] = {

"Zara Ali",

"Hina Ali",

"Nuha Ali",

"Sara Ali"

};

int i = 0;

for ( i = 0; i < MAX; i++) {

printf("Value of names[%d] = %s\n", i, names[i] );

return 0;

EX.5- POINTER LA POINTER, primul pointer contine adresa celui de al doilea

pointer care pointeaza la locatia ce contine valoarea variabilei
'pointer (adresa)->pointer (adresa)->variabila (valoare)'

declaratie: **var

#include <stdio.h>

int main () {

int var;

int *ptr;

int **pptr;

var = 3000;
/* 'ptr' ia adresa lui 'var' */

ptr = &var;

/* 'pptr'ia adresa lui 'ptr' utilizand operatorul & */

pptr = &ptr;

/* preluarea valorii utilizand 'pptr' */

printf("Value of var = %d\n", var );

printf("Value available at *ptr = %d\n", *ptr );

printf("Value available at **pptr = %d\n", **pptr);

return 0;

EX.6- PASAREA UNUI POINTER LA O FUNCTIE, declaram pur si simplu ca

argument al functiei un pointer
#include <stdio.h>

#include <time.h>

void getSeconds(unsigned long *par);

int main () {

unsigned long sec;

getSeconds( &sec );//de ce folosesc & ? poate pentru a lua valoarea numerica ?

/* print the actual value */

printf("Number of seconds: %ld\n", sec );

return 0;

void getSeconds(unsigned long *par) {

/* preia valoarea curenta a nr. de secunde */

*par = time( NULL );

return;

}
#include <stdio.h>

/* function declaration */

double getAverage(int *arr, int size);

int main () {

/* definim un vector cu 5 elemente si o variabila care va fi media sumei elem. vectorului */

int balance[5] = {1000, 2, 3, 17, 50};

double avg;

/* pass pointer to the array as an argument */

avg = getAverage( balance, 5 ) ;

/* output the returned value */

printf("Average value is: %f\n", avg );

return 0;

//cum reuseste sa parsesze vectorul dat ca argument?

double getAverage(int *arr, int size) {

int i, sum = 0;

double avg;

for (i = 0; i < size; ++i) {

sum += arr[i];

avg = (double)sum / size;

return avg;

ex.7- RETURNAREA UNUI POINTER DE CATRE O FUNCTIE, ca declaratie

generala este de forma:
int * myFunction()
.

Nu este indicat de a returna o adresa a unei variabile locale (definita in corpul functiei),deci, vom
declara variabila

respectiva ca fiind 'static'.

Urmatorul exemplu: o functie care genereaza 10 valori aleatoare si le returneaza printr-un vector ce
repr. de fapt un pointer

cu adresa primului element

#include <stdio.h>

#include <time.h>

/* function to generate and return random numbers. */

int * getRandom( ) {

static int r[10];

int i;

/* set the seed */

srand( (unsigned)time( NULL ) );

for ( i = 0; i < 10; ++i) {

r[i] = rand();

printf("%d\n", r[i] );

return r;

/* main function to call above defined function */

int main () {

/* a pointer to an int */
int *p;

int i;

p = getRandom();

for ( i = 0; i < 10; i++ ) {

printf("*(p + [%d]) : %d\n", i, *(p + i) );

return 0;

#####################################################

Alt exemplu functional:

#include <iostream>

//using namespace std; //folosim ca sa nu mai punem "std" in cod

void definire_vector(int nr, int el[5])

{int i;

std::cout << "Introdu nr. elemente vector:";

std::cin >> nr;

std::cout << "Nr. de elemente introduse este:" << nr << std::endl;

std::cout << "Introdu elementele vectorului:\n" << std::endl;

for(i=0;i<nr;i++)

std::cin >> el[i];

//face parte din functia de citire a vectorului

std::cout << "Nr. de elemente vector este:" << nr << std::endl;

std::cout << "Elementele vectorului sunt:" << std::endl;

for (i=0;i<nr;i++)

std::cout << el[i] <<std::endl;

//return 0;

}
void citire_vector(int nr, int el[])

{int i;

std::cout << "Nr. de elemente vector este:" << nr << std::endl;

std::cout << "Elementele vectorului sunt:" << std::endl;

for (i=0;i<nr;i++)

std::cout << el[i];

//return 0;

int main(void)

{ int n, a[5],m, b[5];

definire_vector(n,a);

//citire_vector(n,a);

//definire_vector(m,b);

//citire_vector(m,&b);

return 0;