I standard biblioteket findes en række funktioner, der arbejder på tekststrenge. Knap 20 ialt. Du skal inkludere string.h for at få adgang til disse. Læs om streng funktionerne i appendix A i C by Dissection.

30.1 Sammensætning af strenge 30.3 Substring ved brug af strncpy 30.2 En alternativ funktion til strcpy

30.1.  Sammensætning af strenge
Indhold   Op Forrige Næste   Slide Aggregerede slides    Stikord Programindeks Opgaveindeks 

Dette afsnit handler om strcat og strcpy. Fælles for disse og tilsvarende funktioner er den koncise, korte, og lidt kryptiske navngivning, som er en reminicens fra både C og Unix traditionen.

Vi viser herunder, i program 30.1, et program, som benytter strcat til at sammensætte strengene "Aalborg" og "University" til "Aalborg University". Læg mærke til at vi bliver nødt til at sammesætte de to bestanddele med et eksplit mellemrum: " ".

1
2
3
4
5
6
7
8
9
10
11
12
13
14

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

int main(void) {

  char s[25] = "Aalborg";  
  char t[] = "University";
  char *res;

  res = strcat(strcat(s," "),t);
  printf("%s: %i chars\n", res, strlen(s));
  
  return 0;
}

Strengen s indeholder god plads til "Aalborg University": 25 tegn ialt. Med to indlejrede kald af strcat, på det røde sted, sammensættes strengene til det ønskede resultat. På det blå sted ses et kald af strlen, som tæller antallet af tegn i en streng (ikke medregnet nultegnet). Programmet udskriver "Aalborg University: 18 chars".

30.2.  En alternativ funktion til strcpy
Indhold   Op Forrige Næste   Slide Aggregerede slides    Stikord Programindeks Opgaveindeks 

Som beskrevet ganske kort i afsnit 30.1 kopierer strcpy tegnene fra den anden parameter ind i strengen, som overføres i den første parameter.

Vort udgangspunkt er således en observation om, at strcpy arbejde inden for allerede allokeret lager. Dette er et generelt kendetegn for mange funktioner i C standard library.

Herunder, i program 30.2 programmerer vi en streng kopieringsfunktion, som allokerer ny og frisk plads til den streng, som overføres som parameter. Den eksisterende streng kopieres over i det nyallokerede lager, således at den eksisterende streng og den nye streng er strukturelt ens (jf. afsnit 28.2).

1
2
3
4
5
6
7
8
9
10

/* Copy s to a fresh allocated string and return it */
char *string_copy(const char *s){
  
 static char *new_str;

 new_str = (char *)malloc(strlen(s)+1);
 strcpy(new_str,s);

 return new_str;
}

På det røde sted ser vi selve lagerallokeringen. Vi bruger dynamisk lagerallokering med malloc, jf. afsnit 26.2. Vi assigner pointeren new_str til det nye lagerområde. Dernæst foretages kopieringen af s over i new_str med strcpy. Vi erklærer new_str som static (det lilla sted), idet new_str skal returneres som resultat fra funktionen string_copy. Dette er ikke strengt nødvendigt, men dog en god ide når vi returnerer en array fra en funktion.

Herunder ser vi på en variant af str_copy fra program 30.2. I denne variant er det essentielt at vi på det røde sted erklærer new_str som static. Årsagen er, at vi i denne variant af programmet statisk har allokeret lokalt lager på køretidsstakken, som ønskes 'med ud fra funktionen' pr. returværdi. I program 30.2 allokerede vi dynamisk lager i det område, vi plejer at benævne som heapen.

Hvis vi glemmer 'static' i erklæringen af new_str i program 30.3 vil vi få en dangling reference, jf. afsnit 26.3. Compileren vil muligvis advare dig, hvis du glemmer static.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

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


/* Copy s to a locally allocated string and return it */
char *string_copy(const char *s){
  
 static char new_str[8];  /* static is essential. Zero initialized */
 strncpy(new_str,s,7);

 return new_str;
}


int main(void) {

  char s[] = "Aalborg University", *t;
  t = string_copy(s);
  strcpy(s,"---");      /* destroy s */

  printf("The original is: %s.\nThe copy is: %s\n", s, t);
  
  return 0;
}

Som en mindre detalje i program 30.3 overskriver vi på det sorte sted delvist s, som lige er kopieret over i t. Dermed kan vi erkende, at s og t ikke er lig med hinanden i reference forstand, jf. afsnit 28.2.

30.3.  Substring ved brug af strncpy
Indhold   Op Forrige Næste   Slide Aggregerede slides    Stikord Programindeks Opgaveindeks 

Vi viser i dette afsnit en typisk anvendelse af strncpy, som udtrækker en delstreng af en tekststreng. Bemærk at det ikke er strcpy, men strncopy vi diskuterer.

Strengen vi betragter er str, som indeholder "The Aalborg University basis year". På det sorte sted fylder vi target med '\0' tegn. Dette sikrer i den sidste ende nulafslutningen af target. Det røde sted er central for dette eksempel. Bemærk først udtrykket str+4, som udpeger "Aalborg University basis year". Den sidste parameter, 18, i kaldet af strncpy kopierer netop 18 tegn. Samlet set kopieres "Aalborg University" over i target. Programmet udskriver således

The substring is: Aalborg University
Length: 18

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

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

#define LEN 25

int main(void) {

  char str[] = "The Aalborg University basis year";
  char target[25];
  int i; 

  for(i = 0; i < LEN; i++) target[i] = '\0';  

  strncpy(target, str+4, 18);

  printf("The substring is: %s\nLength: %i\n",
          target, strlen(target));
  
  return 0;
}