ARCHIV

C/C++ (21) - Práce s řetězci

Přistupovat přímo k jednotlivým znakům řetězce je občas poněkud neohrabané, v řadě případů je lepší použít některou z funkcí ze string.h.

2.6.2005 09:00 | Jan Němec | Články autora | přečteno 76533×

Práce s řetězci

O řetězcích už leccos víme. V Céčku je textový řetězec reprezentován prostým ukazatelem do paměti, typem char *. Znakům odpovídají jednotlivé byty a platná část dat je ukončena bytem s hodnotou 0 (nikoli znakem '0'). Chceme-li provádět s řetězcem nějaké operace, přistupujeme k jednotlivým znakům pomocí operátoru pro indexování pole [] nebo prostřednictvím pointerové aritmetiky.

char veta[] = "Ema má mísu masa.";
char slovo[10];
int i = 0;
char *p = slovo;

while (veta[i] && veta[i] != ' ' &&
       p - slovo < sizeof(slovo) - 1) {
       
  *p++ = veta[i++];
}
*p = 0;

printf("1. slovo věty '%s' je '%s'.\n", veta, slovo);

Psaní takovéhoto kódu je ovšem únavné a navíc poměrně náchylné na chyby. Programátor snadno zapomene ukončovací nulu, nepohlídá si maximální délku řetězce a podobně. Kód není příliš přehledný a programátorův kolega bude muset chvíli přemýšlet, než zjistí, že se jedná o kopírování prvního slova věty. Naštěstí se základní operace s řetězci neustále opakují, a tak nalezly své místo ve standardní knihovně jazyka C.

#include <string.h>
size_t strlen(const char *s);
char *strcpy(char *dest, const char *src);
char *strcat(char *dest, const char *src);
char *strdup(const char *s);
char *strstr(const char *haystack, const char *needle);
int strcmp(const char *s1, const char *s2);

Všechny uvedené funkce předpokládají, že všechny vstupní parametry typu const char * jsou platné ukazatele do paměti, z níž máme právo číst a která navíc dříve nebo později obsahuje byte s hodnotou 0 - ukončení řetězce. Výstupní parametry typu char * musí ukazovat do bloku paměti, kam máme právo zápisu a který je dostatečně velký pro uložení výsledku. Nesplnění uvedených předpokladů může vést k paměťovým chybám za běhu programu, nejčastěji přímo k pádu programu nebo k přepsání dat, jež jsou v paměti uložena za výstupním řetězcem.

Funkce strlen vrací délku řetězce bez ukončovací nuly.

unsigned u;

u = strlen("linux");
/* V u je 5. */

Funkce strcpy kopíruje src včetně ukončovací nuly do dest a tento řetězec je zároveň návratovou hodnotou. Řetězce se nesmějí v paměti překrývat, takže není například možné posunout řetězec v paměti o jeden byte voláním strcpy(s + 1, s).

char s[6];

strcpy(s, "linux");
/* V s je "linux", tedy {'l', 'i', 'n', 'u', 'x', 0}. */

Kdybych proměnnou s definoval jako char * (bez další inicializace), jednalo by se o pokus o zkopírování 6 bytů na nějaké místo v paměti určené pouze obsahem zásobníku před vstupem do funkce. Výsledkem by byl nejspíš pád programu nebo přepsání dat.

Funkce strcat přidá src za dest, přičemž přepíše původní ukončovací nulu dest a na konec výsledného řetězce přidá novou. Řetězce se nesmějí v paměti překrývat, nelze tedy například volat strcat(s, s) pro zdvojení řetězce.

char s[64] = "Ctrl + Alt";

strcat(s, " + Del");
/* V s je známý trojhmat. */

Získat kopii řetězce dá v C trochu práci. Náš příklad se strcpy je výjimečný, neboť předem známe maximální délku řetězce. V obecném případě bychom museli postupovat asi takhle:

char *s;

s = (char *) malloc(strlen(neznamy_retezec) + 1);
strcpy(s, neznamy_retezec);
/* .... */
free(s);

Naštěstí to jde i trochu jednodušeji s funkcí strdup.

char *s;

s = strdup(neznamy_retezec);
/* .... */
free(s);

V obou případech je vhodné ještě otestovat, zda malloc nebo strdup nevrátila NULL.

Podřetězec můžeme nalézt funkcí strstr.

const char *s = "Restaurace a jídelny";
const char *v = strstr(s, "del");

if (!v) {
  puts("Řetězec nenalezen");
} else {
  printf("\"%s\" obsahuje značku počítačů na pozici %i.\n",
    s, v - s + 1);
}

Občas je třeba řetězce porovnávat.

char *s1 = "abcde";
char *s2 = "abcdf";
int i = strcmp(s1, s2);
char c;

if (i < 0) c = '<'; else
  if (i > 0) c = '>'; else
   c = '=';

printf("\"%s\" %c \"%s\"\n", s1, c, s2);

Určitou nevýhodou funkcí strcpy a strcat je, že nehlídají velikost výstupního řetězce. Problém lze vyřešit pomocí dynamické alokace bufferu, ale někdy je praktičtější stanovit maximální velikost operace a případné přebytečné znaky prostě oříznout. Zde pomohou funkce strncpy a strncat, které mají jako poslední parametr maximální velikost kopírovaných dat (nikoliv velikost výsledku !). Pokud řetězec kopírovaný strncpy delší, chybí výsledku ukončovací nula.

char s[6];

strncpy(s, "linuxsoft", sizeof(s) - 1);
s[sizeof(s) - 1] = 0;
/* V s je "linux", tedy {'l', 'i', 'n', 'u', 'x', 0}. */

Analogií pro porovnání je funkce strncmp, které porovnává maximálně prvních n znaků z obou řetězců.

Příklad pro dnešní díl

Ukážeme si jak (nepříliš efektivně) spojit vstupní parametry programu do jednoho řetězce.

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

int main(int argc, char **argv) {
  char celkem = 1;
  int i;
  char *s;

  /* Sečteme délky parametrů a přidáme jedničku pro ukončovací nulu. */
  for (i = 0; i < argc; i++) {
    celkem += strlen(argv[i]);
  }
  
  /* Naalokujeme řetězec. */
  s = (char *) malloc(celkem);

  /* To se nemusí vždy podařit. */
  if (!s) {
    puts("Málo paměti.");
    return 1;
  }

  /* Ze s uděláme prázdný řetězec ukončený nulou. */
  s[0] = 0;
  
  /* A parametry do něj nakopírujeme. */
  for (i = 0; i < argc; i++) {
    strcat(s, argv[i]);
  }
  
  puts(s);

  /* Nakonec naalokovaný řetězec uvolníme. */
  free(s);
  return 0;
}

Uvedený příklad je funkční, pouze trochu neefektivní. Pokud zavoláme program s n jednoznakovými parametry, bude v cyklu strcat postupně kopírovat aktuální parametr za 0, 1, 2, ... znakový mezivýsledek. Jen hledání ukončovací nuly mezivýsledku ve strcat má tedy časovou složitost 1 + 2 + 3 + ... + n - 1, tedy n * (n - 1) / 2, což je kvadratická časová složitost. Mnohem lepší je si zapamatovat částečné součty délek parametrů a aktuální parametr kopírovat pomocí strcpy nebo memcpy vždy přímo na příslušné místo výsledného řetězce. Celý algoritmus pak má lineární časovou složitost. Zvídavější čtenáři si to mohou zkusit napsat jako domácí cvičení.

Pokračování příště

V příštím dílu se podíváme na struktury a uniony.

Verze pro tisk

DISKUZE Referencna prirucka 27.10.2005 15:45 Michal Zahradnicek Re: Referencna prirucka 29.10.2005 01:31 Aleš Hakl Re: Referencna prirucka 1.11.2005 13:25 camlost Chybička? 11.2.2007 12:35 Viktor Bubla   Re: Chybička? 12.2.2007 09:20 Jan Němec Zobrazit označené Zobrazit vše Příspívat do diskuze mohou pouze registrovaní uživatelé.