Universitatea deVest Timisoara

Facultatea de Matematica si Informatica Programare I

Limbajul de programare C

06.02.18 Lucian Cucu - The C Programming Language 1

Universitatea deVest Timisoara
Facultatea de Matematica si Informatica Programare I

Pointers: legal operations with pointers – summary and comments

1. Initialization and assignment

2. De-referentiation
3. Addition/substraction of an integer to/from a pointer
4. Incrementation/decrementation
5. Substraction of a pointer from another pointer
6. Comparison of two pointers

Comments:
- Operations 3 and 4 only make sense (shall only be performed) if the pointer
points to an element of an array!
- Operations 5 and 6 only make sense (shall only be performed) if both pointers
point to elements of the same array!

Lucian Cucu - The C Programming Language

06.02.18 2
Universitatea deVest Timisoara
Facultatea de Matematica si Informatica Programare I

Pointeri: aritmetica pointerilor

Toate operatiile cu/asupra pointerilor iau in considerare dimensiunea

obiectelor de tipul declarat al pointerului! (aritmetica pointerilor)

int n;
TYPE t[N], *p, *q;
p=&t[0]; /* p=t */
q=&t[4];
...
...*p... /*value starting at address p and stored on sizeof(TYPE) bytes as data of type TYPE */
...p+n... /* compiles to p+n*sizeof(TYPE) */
...p++... /* compiles to p=p+1*sizeof(TYPE) */
...n=q-p... /* compiles to n=(q-p)/sizeof(TYPE) */

Lucian Cucu - The C Programming Language

06.02.18 3
Universitatea deVest Timisoara
Facultatea de Matematica si Informatica Programare I

Pointeri: pointeri void

Declaratie:
void *name;

Singura operatie legala cu pointeri void este atribuirea:

ex.
void *p;
TYPE1 *p1;
TYPE2 *p2;
...
p=p1;
...
p2=p;
...

Pointerii void pot fi folositi doar pentru “depozitarea” de adrese!

Lucian Cucu - The C Programming Language
06.02.18 4
Universitatea deVest Timisoara
Facultatea de Matematica si Informatica Programare I

Pointeri si functii
Functiile pot:
a) sa primeasca pointeri ca parametri
b) sa returneze pointeri
/* a) */
/* function prototype */
TYPE1 *function(TYPE2 *ptr);
...
TYPE2 v, *pv=&v;
...
function(&v); /*function call*/
function(p); /*function call*/
...

/* b) */
TYPE1 *q;
...
q=function(p);
*q=... /* wrong! q may be NULL! */

if((q=function(p)) == NULL)
handle_error();
*q=... /* right! q is not NULL */
Lucian Cucu - The C Programming Language
06.02.18 5
Universitatea deVest Timisoara
Facultatea de Matematica si Informatica Programare I

Pointeri: functii cu parametri de tip tablou

E.g.
TYPE1 function(TYPE2 t[]); /* t este in realitate un pointer! */
...
TYPE2 array[L];
...
function(array); /* &array[0] se transmite ca argument catre function */
...
.
.
. call
ret. context
Problema: t:
addr.

In functie nu se cunoaste numarul de elemente ale tabloului! .

.
.

array:0
1
Solutie: 2
.
.
Exista mai multe solutii cu grad diferit de reutilizare! .
L-1

Lucian Cucu - The C Programming Language

06.02.18 6
Universitatea deVest Timisoara
Facultatea de Matematica si Informatica Programare I

Pointeri: functii cu parametri de tip tablou (1)

file.c

TYPE1 function(TYPE2 t[]);

#define L 100
#define M 1000
...
array1[L], array2[M];
TYPE2 array1[L];
...
function(array1);
...
function(array2); /* wrong! array2 has a different
... number of elements! */
function.c
#define L 100
TYPE1 function(TYPE2 t[ ])
{
int i;
...
for(i=0; i < L ; i++)
... t[i] ...; /*process t[i] */
...
}

Lucian Cucu - The C Programming Language

06.02.18 7
Universitatea deVest Timisoara
Facultatea de Matematica si Informatica Programare I

Pointeri: functii cu parametri de tip tablou (2)

file.c

TYPE1 function(TYPE2 t[], int n);

#define L 100
#define M 1000
...
TYPE2 array1[L], array2[M];
...
function(array1, L);
...
function(array2, M);
...

function.c
TYPE1 function(TYPE2 t[ ], int n)
{
int i;
...
for(i=0; i < n ; i++)
... t[i] ...; /*process t[i] */
...
}

Lucian Cucu - The C Programming Language

06.02.18 8
Universitatea deVest Timisoara
Facultatea de Matematica si Informatica Programare I

Pointeri: functii cu parametri de tip tablou (2)

Caz special: tablouri cu elemente de tipul char.
Daca tabloul se utilizeaza pentru stocarea:
de intregi “mici” unui sir de caractere

TYPE1 function(char t[], int n); TYPE1 function(char t[]);

#define L 100 #define L 100
#define M 1000 #define M 1000
... ...
char array1[L], array2[M]; char array1[L]="Arad", array2[M]="Timisoara";
... ...
function(array1, L); function(array1);
... ...
function(array2, M); function(array2);
... ...

TYPE1 function(char t[ ], int n) TYPE1 function(char t[ ])

{ {
int i; int i=0;
... ...
for(i=0; i < n ; i++) while(t[i] != '\0')
... t[i] ...; /*process t[i] */ ... t[i] ...; /*process t[i] */
... ...
} }

Lucian Cucu - The C Programming Language

06.02.18 9
Universitatea deVest Timisoara
Facultatea de Matematica si Informatica Programare I

Pointeri si tablouri

Pointerii se utilizeaza cel mai adesea in contextul prelucrarii tablourilor!

Remember:

- adunarea/scaderea unui intreg la/de la un pointer

- incrementarea/decrementarea
- scaderea unui pointer dintr-un alt pointer
- compararea a doi pointeri

au sens doar daca pointerii implicati pointeaza spre elemente de tablou!

Lucian Cucu - The C Programming Language

06.02.18 10
Universitatea deVest Timisoara
Facultatea de Matematica si Informatica Programare I

Pointeri si tablouri: echivalenta notatiei cu pointeri si respectiv cu indecsi

Remember: numele unui tablou este un sinonim pentru adresa primului sau element si este o
constanta!
TYPE t[N], *p=t;
t:

0 1 2 3 4 … i … N-1
p:

p este egal cu t si ambele valori sunt adrese (adresa elementului t[0])

Atunci
p+0 este egal cu t+0
p+i este egal cu t+i
*p este egal cu *t
*(p+i) este egal cu *(t+i)
dar
p++ nu este egal cu t++ ! (t este o constanta si nu poate fi modificata!)
Si
t[0] este egal cu p[0]
t[i] este egal cu p[i]
Un pointer poate fi utilizat ca nume de tablou (poate fi indexat) si
numele de tablou poate fi utilizat ca pointer (daca aceasta nu implica modificarea valorii sale, care
este constanta!)
Lucian Cucu - The C Programming Language
06.02.18 11
Universitatea deVest Timisoara
Facultatea de Matematica si Informatica Programare I

Pointeri si tablouri: eficienta utilizarii pointerilor

Nu orice utilizare a pointerilor aduce eficienta sporita!

TYPE t[N], *p=t;
t[i] inseamna *(t+i) care e echivalent cu *(p+i)
for(i=0; i<N; i++)
Dar, atat p cat si t sunt adrese, deci li se aplica aritmetica
t[i]=…; pointerilor,
ceea ce inseamna ca are loc o inmultire (ascunsa)

este echivalent cu *(t+i*sizeof(TYPE))

Sumar al operatiilor:
for(i=0; i<N; i++) 1 adunare, 1 inmultire si 1 de-referentiere / iteratie

*(p+i)=…;
Echivaland incrementarea cu o adunare
Sumar al operatiilor:
si ambele variante 1 adunare si 1 de-referentiere / iteratie
sunt mai lente decat: Avantaj: 1 inmultire / iteratie mai putin!
for(i=0; i<N; i++, p++)
*p=…;
Lucian Cucu - The C Programming Language
06.02.18 12
Universitatea deVest Timisoara
Facultatea de Matematica si Informatica Programare I

Pointeri: prelucrarea de siruri de caractere

/* strcpy: copy t to s; array subscript version */ /* strcpy: copy t to s; pointer version */

void strcpy(char *s, char *t) void strcpy(char *s, char *t)
{
{
int i;
int i; i = 0;
i = 0; while ((*s = *t) != '\0')
while ((s[i] = t[i]) != '\0') { s++; t++; }
i++; } }

/* strcpy: copy t to s; pointer version 2 */

void strcpy(char *s, char *t)
{
while ((*s++ = *t++) != '\0')
;
}

Lucian Cucu - The C Programming Language

06.02.18 13
Universitatea deVest Timisoara
Facultatea de Matematica si Informatica Programare I

Pointeri: pointeri const vs pointeri la obiecte const

Modificatorul const
Sintaxa: const type_name variable_name;
or
type_name const variable_name;
Utilizare: modificator de declaratie utilizat pt a interzice modificari ale valorii initiale a variabilei
Ex.
const int a, b; /* identic cu: int const a, b; */
a=0; b=1; /* eronat: nu se pot modifica valorile constantelor a and b, care trebui initializate!

De aceea
const int a=0, b=1; /* identic cu: int const a, b; */
a=++b; /* gresit, dar a si b au fost initializati */

Pointer la const:
const int a=0, b=1, *p=&a; /* identic cu: int const a=0, b=1, *p=&b; */
*p=100; /*eronat: nu se poate modifica valoarea constanta a lui a */
p=&b; /* OK! P nu e constant! */

Pointer const :
int a=0, b=1;
int * const p=&a; /* identic cu: int a=0, b=1, * const p=&a; */
*p=a+b; /* OK! Identic cu a=a+b; */
p=&b; /* eronat: nu se poate modifica valoarea constanta a lui p */

Lucian Cucu - The C Programming Language

06.02.18 14