Definirea sirurilor de caractere
Functii de prelucrare a sirurilor
Exemple

Siruri de caractere

Definirea sirurilor de caractere

Limbajul C nu defineste tipul de data sir ( string in Pascal ), dar exista doua posibilitati de definire a sirurilor:

ca tablou de caractere; exemple:

char sir1[30];
char sir2[10]="exemplu";

pointer la caractere; exemple:

char *sir3; // sir3 trebuie initializat cu adresa unui

// sir sau a unui spatiu alocat pe heap

char *sir4="test";// sir2 este initializat cu adresa

// sirului constant

O constanta sir de caractere se reprezinta intre ghilimele. Ultimul caracter din sir este caracterul nul ('\0'). Ex: "Anul 2000" ocupa 10 octeti de memorie, ultimul fiind '\0'.

Functii de prelucrare a sirurilor

declarate in stdio.h

char * gets(char * s);

citeste caracterele din intrare pina la intalnirea caracterului Enter, care nu se adauga la sir, in s; plaseaza '\0' la sfarsitul lui s; returneaza adresa primului caracter din sir; daca se tasteaza CTRL/Z returneaza NULL

int puts(char * s);

tipareste sirul s, trece apoi la rand nou

scanf("%s",s);

citeste caracterele din intrare pina la intalnirea primului blanc sau Enter, care nu se adauga la sir, in s; plaseaza '\0' la sfarsitul lui s; daca se tasteaza CTRL/Z returneaza EOF

printf("%s",s);

tipareste sirul s

declarate in string.h

int strcmp(char *s1,char *s2);

returneaza <0, daca s1 < s2

0, daca s1 = s2

>0, daca s1 > s2

int strncmp(char *s1,char *s2,int n);

comparare a doua siruri pe lungimea n

char* strcpy(char *d,char *s);

copiaza sirul sursa s in sirul destinatie d; returneaza adresa sirului destinatie

char* strncpy(char *d,char *s,int n);

copiaza maxim n caractere de la sursa la destinatie; returneaza adresa sirului destinatie

int strlen(char *s);

returneaza lungimea sirului fara a numara caracterul terminator

char* strcat(char *d,char *s);

concateneaza cele doua siruri si returneaza adresa sirului rezultat.

char* strchr(char s,char c);

returneaza pozitia primei aparitii a caracterului c in sirul s, respectiv NULL daca c nu e in s

char* strstr(char *s,char *ss);

returneaza pozitia primei aparitii a sirului ss in sirul s, respectiv NULL daca ss nu e in s

Exemple

0. Mai jos sunt prezentate variante de implementare a unor functii de biblioteca de mai sus:

int strcmp( char *s1, char *s2){
   int i;
   for(i=0;s1[i]||s2[i];i++)
      if(s1[i]<s2[i])
        return -1;
      else
        if(s1[i]>s2[i])
          return 1;
   return 0;
}

char *strcpy( char *d, char *s){
   int i=0;
   while(s[i]){ //0
     d[i]=s[i];i++;
   }
   d[i]='\0';   //1
   return d;
}
//secventa ce cuprinde liniil dintre //0 si //1 inclusiv este echivalenta //cu:
       while(d[i]=s[i])i++;

char *strcat(char *d, char *s){
    int i=0,j=0;
    while(d[i]) i++;/*la iesirea din while, i este indicele caracterului terminator */
    while(d[i++]=s[j++]);
    return d;
}

1. Sa se scrie un program care:
- citeste cuvintele tastate fiecare pe cate un rand nou, pana la CTRL/Z
( varianta: pana la introducerea un cuvant vid )
- afiseaza cuvantul cel mai lung
- construieste si afiseaza cuvantul format din ultima litera din cuvintele introduse, transformata in minuscula ( nu vor fi prelucrate cuvintele ce nu se termina cu o litera )
- afiseaza cuvintele ce incep cu o vocala.

#include <stdio.h>
#include <string.h>
#include <conio.h>
#include <ctype.h>

#define LUNG 80
#define NR 15

char tab_cuv[NR][LUNG];
int nr_cuv=0; /* numarul cuvintelor introduse */

void citire_cuv(void){
printf("*** Se introduc maxim %d cuvinte, terminate cu CTRL/Z:\n",NR);
while(nr_cuv<NR && gets(tab_cuv[nr_cuv]))nr_cuv++;
/* la CTRL/Z gets returneaza NULL (= 0) */
/* citirea se poate face si cu scanf:
while(nr_cuv<NR && scanf("%s",tab_cuv[nr_cuv])!=EOF)nr_cuv++; */
/* daca terminarea se face cu un cuvant vid:
while(nr_cuv<NR && strcmp("",gets(tab_cuv[nr_cuv])))nr_cuv++; */
}

/* Varianta: tab_cuv se declara ca tablou de pointeri, se modifica declaratia lui tab_cuv si functia citire_cuv, restul functiilor raman nemodificate;

#include <alloc.h>
char* tab_cuv[NR];
void citire_cuv(void){
char cuv_crt[LUNG];
printf("*** Se introduc maxim %d cuvinte, terminate cu CTRL/Z:\n",NR);
while(nr_cuv<NR && gets(cuv_crt)){
    if((tab_cuv[nr_cuv]=(char *)malloc(strlen(cuv_crt)+1))==NULL){
      puts("*** Spatiu insuficient ! ***");
      exit(1);
    }
    strcpy(tab_cuv[nr_cuv],cuv_crt);
    nr_cuv++;
}
}
*/

void constr_cuv(void){
char c,cuv[NR+1]; /* lungimea maxima este egala cu numarul maxim de cuvinte + 1 pentru terminator */
int i,j; /* i parcurge cuvintele din tab_cuv, j pozitiile din cuv */
for(i=j=0;i<nr_cuv;i++)
if(isalpha(c=tolower(tab_cuv[i][strlen(tab_cuv[i])-1])))
cuv[j++]=c;
cuv[j]='\0';
printf("*** Cuvantul construit:|%s|\n",cuv);
}

void cuv_max(void){
int i,lung_crt,lung_max=0;
char * p_max; /* pointerul spre cuvantul maxim */
    /* se poate memora indicele cuvantului maxim: int i_max;
       sau memora cuvantul maxim intr-un sir: char c_max[LUNG]; */
for(i=0;i<nr_cuv;i++)
    if((lung_crt=strlen(tab_cuv[i]))>lung_max){
      p_max=tab_cuv[i];
      lung_max=lung_crt;
    }
printf("*** Cuvantul de lungime maxima %d este:|%s|\n",lung_max,p_max);
}

void cuv_vocale(void){
int i;
puts("*** Cuvintele ce incep cu vocale:");
for(i=0;i<nr_cuv;i++)
    switch(toupper(tab_cuv[i][0])){
     case 'A': case'E': case 'I': case 'O': case 'U':puts(tab_cuv[i]);
   } /* in loc de switch se putea folosi
char c; if(c=toupper(tab_cuv[i][0]),c=='A' ||
     c=='E' || ...)puts(tab_cuv[i]); */
}

void main(void){

citire_cuv();
cuv_max();
constr_cuv();
cuv_vocale();

getch();
}

2.Se citesc trei siruri s1, s2 si s3. Sa se afiseze sirul obtinut prin inlocuirea in s1 a tuturor aparitiilor lui s2 prin s3. ( Observatie: Daca s3 este sirul vid, din s1 se vor sterge toate subsirurile s2 ).

#include <stdio.h>
#include <string.h>

#define LUNGS 80

void main(void){
char s1[LUNGS],s2[LUNGS],s3[LUNGS],rezultat[LUNGS];
char *s1ptr=s1,*s2pos, *rezptr=rezultat;

puts("*** sirul s1:"); gets(s1);
puts("*** subsirul s2:"); gets(s2);
puts("*** s3:"); gets(s3);

while(s2pos=strstr(s1ptr,s2)){
    while(s1ptr<s2pos)*rezptr++=*s1ptr++;
    strcpy(rezptr,s3);
    rezptr+=strlen(s3);
    s1ptr+=strlen(s2);
}
strcpy(rezptr,s1ptr);
puts("*** sirul rezultat:"); puts(rezultat);

getch();
}

Carmen Holotescu

aprilie 2000