Limbaje de programare: Tablouri, şiruri, pointeri

Repetăm mai jos câteva tipare simple care trebuie stăpânite pentru rezolvarea unor probleme cu tablouri, şiruri, pointeri.

Parcurgerea unui tablou

Secvenţele de cod de mai jos presupun existenţa unui tablou a de dimensiune size:
de exemplu primit ca parametru în funcţie: void f(double a[], unsigned size)
sau declarat: const int size = 10; /* sau altă valoare */ double a[size];

cu un indice, crescător:

  for (int i = 0; i < size; ++i) {
    /* foloseste a[i] */
  }

cu un indice, descrescător:

  for (int i = size; i--; ) {   // i e size .. 1 in test inainte de decrementare
    /* foloseste a[i] */	// si size-1 .. 0 in ciclu, la folosire
  }

cu un pointer, crescător:

  /* declara un pointer p pentru parcurgere,
     si un pointer end cu adresa la care se termina tabloul;
     sau se poate compara si direct p < a + size */
  for (double *p = a, *end = a + size; p < end; ++p) {
    printf("%f ", *p);	// *p e valoarea de la adresa p
  }

cu un pointer, descrescător:

  /* declara un pointer p cu adresa la care se termina tabloul;
     il decrementeaza pana ajunge la a;
     p-- testeaza valoarea dinainte de decrementare, testam > a */
  for (double *p = a + size; p-- > a; ) {
    printf("%f ", *p);	// *p e valoarea de la adresa p
  }
  /* la fel, dar valoarea e decrementata inainte de testare, testam >= a */
  for (double *p = a + size; --p >= a; ) {
    printf("%f ", *p);	// *p e valoarea de la adresa p
  }

Alocarea dinamică a unui tablou

Alocăm dinamic un tablou dacă creăm un tablou într-o funcţie şi avem nevoie de el după încheierea funcţiei; în acest caz funcţia trebuie să transmită în afară adresa tabloului (de exemplu ca valoare returnată).
Mai alocăm dinamic un tablou (chiar când e folosit doar în funcţie) când tabloul e mare, şi din acest motiv nu dorim să fie pe stivă (unde se pun variabilele locale).

Un tablou de n elemente de tipul tip se alocă cu apelul
malloc(n * sizeof(tip))
. Valoarea returnată se atribuie unui pointer de tipul tip * şi se foloseşte doar după ce s-a verificat că nu e NULL (alocarea a avut succes) . Un exemplu de funcţie care adună doi vectori de reali de aceeaşi dimensiune şi returnează adresa vectorului creat:

double *addvect(double a[], double b[], unsigned len)
{
  double *c = malloc(len * sizeof(double));
  if (c)	// c e folosit doar dacă e nenul
    for (int i = len; i--; )	// un pointer poate fi folosit cu indici [i]
      c[i] = a[i] + b[i];	// ca un tablou (numele tabloului e adresa lui)
  return c;
}

Parcurgerea unui şir de caractere

Un şir de caractere se parcurge la fel ca şi un tablou, cu un indice, sau cu un pointer. Un şir de caractere se termină cu caracterul '\0' deci parcurgerea se face cât timp caracterul curent e nenul.

void parcurge(char *s)
{
  for (int i = 0; s[i]; ++i) {
    /* fa ceva cu caracterul curent s[i] */
  }
  for (char *p = s; *p; ++p) {
    /* fa ceva cu caracterul curent *p */
  }
}

Dacă sirul de caractere e dat printr-un pointer (şi nu adresa constantă de început a unui tablou), şi ulterior în acea funcţie nu mai avem nevoie de adresa de început a şirului, putem parcurge şirul chiar cu pointerul dat:

char *strchr(const char *s, int c)	// cauta caracterul c in sirul s
{
  for (; *s; ++s)		// parcurge cat timp *s e nenul
    if (*s == c) return s;	// returneaza adresa unde a fost gasit
  return NULL;			// altfel returneaza NULL: nu a fost gasit
}

Alocarea dinamică a unui şir de caractere

Alocarea şirurilor de caractere se face după aceleaşi reguli ca şi orice alocare de tablou. În acest caz particular:

orice şir trebuie încheiat cu '\0', deci trebuie alocat cu un octet mai mult decât lungimea utilă a şirului
sizeof(char) e 1, deci se poate aloca malloc(lungime_sir + 1)

Un caz comun este cel în care dorim să facem o copie a unui şir (de exemplu pentru că şirul se află într-un tablou static care urmează a fi refolosit / suprascris). (O funcţie strdup care face acest lucru nu e definită în standardul C, dar există în standardul POSIX şi în multe biblioteci).

char *strdup(char *s)
{
  char *p = malloc(strlen(s) + 1);
  if (p) strcpy(p, s);
  return p;
}

Marius Minea

Last modified: Tue Dec 4 16:30:00 EET 2012