<string.h>

Esta é uma biblioteca padrão da linguagem C. Nela estão contidos protótipos utilizados para a manipulação de strings, também conhecidos como array de chars. Estas funções são capazes desde a contagem, cópia e concatenação, comparação e diversas outras modificações como podemos ver nos exemplos a seguir.

Macros

  • NULL: Um ponteiro constante que aponta para 0 (zero), pode ser escrito com uma chamada de cast definida por: (void *)(0)

Variáveis

  • size_t: Um longo inteiro sem sinal, responsável por guardar a quantidade de bytes de qualquer objeto retornado pelo operador sizeof.

Funções

memchr() memcmp() memcpy() memmove() memset() strcat() strncat() strchr() strrchr() strcmp() strncmp() strcoll() strcpy() strncpy() strcspn() strspn() strpbrk() strstr() strtok() strlen() strerror()

void *memchr(const void *str, int c, size_t n)

Procura pela primeira ocorrência do caractere c (um unsigned char) nos primeiros n bytes do bloco de memória apontado por str.

Recebe: Um ponteiro para o bloco de memória, o caractere a ser procurado e o número de bytes a serem analisados.

Retorna: Um ponteiro para a posição da primeira ocorrência do caractere ou NULL caso não seja encontrado.

Exemplo

// EXEMPLO MEMCHR()
#include <stdio.h>
#include <string.h>

int main () {
   const char str[] = "http://www.pet.inf.ufscar.br";
   const char ch = '.';
   char *ret;

   ret = memchr(str, ch, strlen(str));

   printf("String depois de |%c| eh - |%s|\n", ch, ret);

   return(0);
}

Saída esperada

String depois de |.| eh - |.inf.ufscar.br|

int memcmp(const void *str1, const void *str2, size_t n)

Compara os primeiros n bytes das áreas de memória apontadas por str1 e str2.

Recebe: Dois ponteiros para os blocos de memória e a quantidade n de bytes a serem comparados.

Retorna:

  • Se o valor for < 0: str1 é menor que str2.
  • Se o valor for > 0: str1 é maior que str2.
  • Se o valor for == 0: os blocos são idênticos nos primeiros n bytes.

Exemplo

// EXEMPLO MEMCMP()
#include <stdio.h>
#include <string.h>

int main () {
   char str1[15];
   char str2[15];
   int ret;

   memcpy(str1, "abcdef", 6);
   memcpy(str2, "ABCDEF", 6);

   ret = memcmp(str1, str2, 5);

   if(ret > 0) {
      printf("str2 eh menor que str1\n");
   } else if(ret < 0) {
      printf("str1 eh menor que str2\n");
   } else {
      printf("str1 eh igual a str2\n");
   }

   return(0);
}

Saída esperada

str2 eh menor que str1

void *memcpy(void *dest, const void *src, size_t n)

Copia n bytes da área de memória src para a área de memória dest.

Recebe: Um ponteiro para o destino, um ponteiro para a origem dos dados e o número de bytes a serem copiados.

Retorna: Um ponteiro para o destino (dest).

Exemplo

// EXEMPLO MEMCPY()
#include <stdio.h>
#include <string.h>

int main () {
   const char src[50] = "http://www.pet.inf.ufscar.br";
   char dest[50];

   strcpy(dest,"Helo!! ");
   printf("Antes do memcpy dest = %s\n", dest);
   
   // Copia a string de src para dest, incluindo o caractere nulo
   memcpy(dest, src, strlen(src) + 1);
   printf("Depois do memcpy dest = %s\n", dest);

   return(0);
}

Saída esperada

Antes do memcpy dest = Helo!! 
Depois do memcpy dest = http://www.pet.inf.ufscar.br

void *memmove(void *str1, const void *str2, size_t n)

Copia n bytes da área de memória str2 para str1. Diferente da memcpy, esta função lida com segurança caso os blocos de memória se sobreponham.

Recebe: O ponteiro de destino, o ponteiro de origem e o número de bytes a serem movidos.

Retorna: Um ponteiro para o destino (str1).

Exemplo

// EXEMPLO MEMMOVE()
#include <stdio.h>
#include <string.h>

int main () {
   char dest[] = "oldstring";
   const char src[]  = "newstring";

   printf("Antes de memmove dest = %s, src = %s\n", dest, src);
   
   // Move os 9 bytes de src para dest
   memmove(dest, src, 9);
   printf("Depois de memmove dest = %s, src = %s\n", dest, src);

   return(0);
}

Saída esperada

Antes de memmove dest = oldstring, src = newstring
Depois de memmove dest = newstring, src = newstring

void *memset(void *str, int c, size_t n)

Preenche os primeiros n bytes da área de memória apontada por str com o valor constante c.

Recebe: Um ponteiro para o bloco de memória, o valor (convertido para unsigned char) a ser definido e o número de bytes a serem preenchidos.

Retorna: Um ponteiro para a área de memória str.

Exemplo

// EXEMPLO MEMSET()
#include <stdio.h>
#include <string.h>

int main () {
   char str[50];

   strcpy(str, "Essa e a funcao memset");
   puts(str);

   // Preenche os primeiros 7 caracteres com '$'
   memset(str, '$', 7);
   puts(str);
   
   return(0);
}

Saída esperada

Essa e a funcao memset
$$$$$$$ e a funcao memset

char *strcat(char *destino, const char *fonte)

Concatena a string fonte ao final da string de destino.

Recebe: A string de destino (que deve ter espaço suficiente) e a string fonte a ser anexada.

Retorna: Um ponteiro para a string de destino resultante. O caractere nulo (\0) inicial do destino é sobrescrito pelo primeiro caractere da fonte, e um novo caractere nulo é adicionado ao final da nova string combinada.

Exemplo

// EXEMPLO STRCAT()
#include <stdio.h>
#include <string.h>

int main() {
    char resultado[50] = "Programa ";
    printf("%s\n", resultado);

    strcat(resultado, "de Ensino ");
    printf("%s\n", resultado);

    strcat(resultado, "e Tutoria");
    printf("%s\n", resultado);
    
    char curso[10] = " - BCC";
    strcat(resultado, curso);
    printf("%s\n", resultado);
    
    return 0;
}

Saída esperada

Programa 
Programa de Ensino 
Programa de Ensino e Tutoria
Programa de Ensino e Tutoria - BCC

char *strncat(char *dest, const char *src, size_t n)

Concatena até n caracteres da string src ao final da string dest.

Recebe: A string de destino, a string de origem e o número máximo de caracteres a serem anexados.

Retorna: Um ponteiro para a string de destino (dest). A função garante a adição do caractere nulo (\0) ao final da concatenação.

Exemplo

// EXEMPLO STRNCAT()
#include <stdio.h>
#include <string.h>

int main () {
   char src[50], dest[50];

   strcpy(src,  "This is source");
   strcpy(dest, "This is destination");

   // Anexa os primeiros 15 caracteres de src em dest
   strncat(dest, src, 15);

   printf("Final destination string : |%s|\n", dest);

   return(0);
}

Saída esperada

Final destination string : |This is destinationThis is source|

char *strchr(const char *str, int c)

Procura pela primeira ocorrência do caractere c (um unsigned char) na string apontada por str.

Recebe: A string onde a busca será feita e o caractere a ser procurado.

Retorna: Um ponteiro para a primeira ocorrência do caractere ou NULL caso não seja encontrado.

Exemplo

// EXEMPLO STRCHR()
#include <stdio.h>
#include <string.h>

int main () {
   const char str[] = "http://www.tutorialspoint.com";
   const char ch = '.';
   char *ret;

   ret = strchr(str, ch);

   printf("String after |%c| is - |%s|\n", ch, ret);

   return(0);
}

Saída esperada

String after |.| is - |.tutorialspoint.com|

int strcmp(const char *str1, const char *str2)

Compara a string apontada por str1 com a string apontada por str2 caractere por caractere.

Recebe: Duas strings para comparação.

Retorna:

  • Se o valor for < 0: str1 é menor que str2.
  • Se o valor for > 0: str1 é maior que str2.
  • Se o valor for == 0: ambas as strings são idênticas.

Exemplo

// EXEMPLO STRCMP()
#include <stdio.h>
#include <string.h>

int main () {
   char str1[15];
   char str2[15];
   int ret;

   strcpy(str1, "abcdef");
   strcpy(str2, "ABCDEF");

   ret = strcmp(str1, str2);

   if(ret < 0) {
      printf("str1 is less than str2\n");
   } else if(ret > 0) {
      printf("str2 is less than str1\n");
   } else {
      printf("str1 is equal to str2\n");
   }

   return(0);
}

Saída esperada

str2 is less than str1

int strncmp(const char *str1, const char *str2, size_t n)

Compara os primeiros n caracteres das strings str1 e str2.

Recebe: Duas strings e o número máximo de caracteres a serem comparados.

Retorna:

  • Se o valor for < 0: os primeiros n caracteres de str1 formam uma sequência menor que str2.
  • Se o valor for > 0: os primeiros n caracteres de str1 formam uma sequência maior que str2.
  • Se o valor for == 0: as sequências são idênticas até o limite n.

Exemplo

// EXEMPLO STRNCMP()
#include <stdio.h>
#include <string.h>

int main () {
   char str1[15];
   char str2[15];
   int ret;

   strcpy(str1, "abcdef");
   strcpy(str2, "ABCDEF");

   // Compara apenas os primeiros 4 caracteres
   ret = strncmp(str1, str2, 4);

   if(ret < 0) {
      printf("str1 is less than str2\n");
   } else if(ret > 0) {
      printf("str2 is less than str1\n");
   } else {
      printf("str1 is equal to str2\n");
   }

   return(0);
}

Saída esperada

str2 is less than str1

int strcoll(const char *str1, const char *str2)

Compara a string str1 com a string str2. Diferente da strcmp, o resultado desta função depende da configuração LC_COLLATE da localidade (idioma/região) atual do sistema.

Recebe: Duas strings para serem comparadas.

Retorna:

  • Se o valor for < 0: str1 vem antes de str2 conforme a localidade.
  • Se o valor for > 0: str1 vem depois de str2 conforme a localidade.
  • Se o valor for == 0: as strings são consideradas equivalentes na localidade atual.

Exemplo

// EXEMPLO STRCOLL()
#include <stdio.h>
#include <string.h>

int main () {
   char str1[15];
   char str2[15];
   int ret;

   strcpy(str1, "abcde");
   strcpy(str2, "ABCDE");

   ret = strcoll(str1, str2);

   if(ret > 0) {
      printf("str1 eh maior que str2\n");
   } else if(ret < 0) {
      printf("str2 eh maior que str1\n");
   } else {
      printf("str1 eh igual a str2\n");
   }

   return(0);
}

Saída esperada

str1 eh maior que str2

char *strcpy(char *dest, const char *src)

Copia a string apontada por src para o destino dest, incluindo o caractere nulo terminador (\0).

Recebe: Um ponteiro para o destino onde o conteúdo será copiado e um ponteiro para a origem dos dados.

Retorna: Um ponteiro para a string de destino (dest).

Exemplo

// EXEMPLO STRCPY()
#include <stdio.h>
#include <string.h>

int main () {
   char src[40];
   char dest[100];
  
   // Limpa o destino e prepara a origem
   memset(dest, '\0', sizeof(dest));
   strcpy(src, "Esta eh a origem");
   
   // Copia o conteúdo de src para dest
   strcpy(dest, src);

   printf("String de destino: %s\n", dest);
   
   return(0);
}

Saída esperada

String de destino: Esta eh a origem

char *strncpy(char *dest, const char *src, size_t n)

Copia até n caracteres da string apontada por src para dest. Caso a string de origem seja menor que n, o restante do destino é preenchido com caracteres nulos (\0).

Recebe: Um ponteiro para o destino, um ponteiro para a origem e o número máximo de caracteres a serem copiados.

Retorna: Um ponteiro para a string de destino (dest). Atenção: se não houver um caractere nulo nos primeiros n bytes de src, a string resultante em dest não será terminada em nulo.

Exemplo

// EXEMPLO STRNCPY()
#include <stdio.h>
#include <string.h>

int main () {
   char src[40];
   char dest[12];
  
   // Inicializa o destino com nulos
   memset(dest, '\0', sizeof(dest));
   strcpy(src, "Esta eh a origem");
   
   // Copia apenas os primeiros 10 caracteres
   strncpy(dest, src, 10);

   printf("String final de destino: %s\n", dest);
   
   return(0);
}

Saída esperada

String final de destino: Esta eh a

size_t strcspn(const char *str1, const char *str2)

Calcula o comprimento do segmento inicial de str1 que consiste inteiramente de caracteres que não estão presentes em str2.

Recebe: A string a ser analisada (str1) e a string contendo os caracteres a serem evitados/rejeitados (str2).

Retorna: O número de caracteres lidos em str1 antes de encontrar qualquer caractere que pertença à str2.

Exemplo

// EXEMPLO STRCSPN()
#include <stdio.h>
#include <string.h>

int main () {
   int len;
   const char str1[] = "ABCDEF4960910";
   const char str2[] = "013";

   // Conta quantos caracteres no início de str1 não são '0', '1' ou '3'
   len = strcspn(str1, str2);

   printf("Comprimento da primeira parte que nao contem caracteres de str2 eh %d\n", len);
   
   return(0);
}

Saída esperada

Comprimento da primeira parte que nao contem caracteres de str2 eh 10

char *strerror(int errnum)

Pesquisa em uma matriz interna pelo número do erro errnum e retorna um ponteiro para a string com a mensagem de erro correspondente.

Recebe: O número do erro (geralmente a variável global errno).

Retorna: Um ponteiro para a string que descreve o erro. As mensagens dependem da implementação do sistema e da localidade atual.

Exemplo

// EXEMPLO STRERROR()
#include <math.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
  
int main(){
  // Tentar calcular log de número negativo gera erro de domínio
  printf("log(-1.0) = %f\n", log(-1.0));
  printf("Erro de número %d obtido!\n", errno);
  printf("Descrição do erro: %s\n\n", strerror(errno));
  
  // Tentar calcular log de zero gera erro de intervalo (range)
  printf("log(0.0) = %f\n", log(0.0));
  printf("Erro de número %d obtido!\n", errno);
  printf("Descrição do erro: %s\n", strerror(errno));
  
  return 0;
}

Saída esperada

log(-1.0) = nan
Erro de número 33 obtido!
Descrição do erro: Numerical argument out of domain

log(0.0) = -inf
Erro de número 34 obtido!
Descrição do erro: Numerical result out of range

size_t strlen(const char *fonte)

Calcula o comprimento da string apontada por fonte, não incluindo o caractere nulo terminador (\0).

Recebe: Um ponteiro para a string que se deseja medir.

Retorna: Um valor do tipo size_t (inteiro sem sinal) representando a quantidade de caracteres antes do nulo.
Nota: Como o retorno é um unsigned long na maioria das arquiteturas, utilize o especificador %lu no printf para evitar warnings.

Exemplo

// EXEMPLO STRLEN()
#include <stdio.h>
#include <string.h>

int main() {
    char stringA[] = "PET - BCC";
    char stringB[] = "Computacao UFSCar";

    printf("String A: %s\n", stringA);
    printf("Tamanho da string A: %lu\n\n", (unsigned long)strlen(stringA));

    printf("String B: %s\n", stringB);
    printf("Tamanho da string B: %lu\n", (unsigned long)strlen(stringB));
    
    return 0;
}

Saída esperada

String A: PET - BCC
Tamanho da string A: 9

String B: Computacao UFSCar
Tamanho da string B: 17

char *strpbrk(const char *fonte, const char *comparacao)

Localiza a primeira ocorrência na string fonte de qualquer um dos caracteres presentes na string comparacao.

Recebe: A string a ser analisada e a string contendo o conjunto de caracteres a serem buscados.

Retorna: Um ponteiro para o primeiro caractere em fonte que coincide com algum caractere de comparacao, ou NULL se nenhuma coincidência for encontrada.

Exemplo

// EXEMPLO STRPBRK()
#include <stdio.h>
#include <string.h>

int main() {
    char fonte[] = "Programa de Ensino e Tutoria - BCC/UFSCar";
    char comparacao[] = "aeiou";
     
    printf("String 'fonte': \n%s\n\n", fonte);
    printf("String 'comparacao':\n%s\n\n", comparacao);
     
    char *retorno = strpbrk(fonte, comparacao);

    if (retorno) {
        printf("String após a primeira ocorrência de uma vogal: %s\n", retorno);
    }

    return 0;
}

Saída esperada

String 'fonte': 
Programa de Ensino e Tutoria - BCC/UFSCar

String 'comparacao':
aeiou

String após a primeira ocorrência de uma vogal: ograma de Ensino e Tutoria - BCC/UFSCar

char *strrchr(const char *fonte, int caractere)

Procura pela última ocorrência do caractere caractere (convertido para char) na string apontada por fonte.

Recebe: Uma string fonte e o caractere a ser buscado (passado como int).

Retorna: Um ponteiro para a última posição do caractere na string ou NULL caso ele não seja encontrado. O caractere nulo terminador é considerado parte da string.

Exemplo

// EXEMPLO STRRCHR()
#include <stdio.h>
#include <string.h>

int main() {
    int caractere = 'a';
    char fonte[] = "Programa de Ensino e Tutoria - BCC";

    printf("Localizar a última letra '%c' na frase: %s\n", caractere, fonte);
    
    char *resultado = strrchr(fonte, caractere);

    if(resultado != NULL) {
        printf("\nCaractere '%c' encontrado!\n", caractere);
        printf("String a partir da última ocorrência: %s\n", resultado);
    } else {
        printf("\nCaractere '%c' não encontrado!\n", caractere);
    }

    return 0; 
}

Saída esperada

Localizar a última letra 'a' na frase: Programa de Ensino e Tutoria - BCC

Caractere 'a' encontrado!
String a partir da última ocorrência: a - BCC

size_t strspn(const char *fonte, const char *comparacao)

Calcula o comprimento do segmento inicial de fonte que consiste inteiramente de caracteres presentes na string comparacao.

Recebe: A string a ser analisada e a string contendo o conjunto de caracteres permitidos.

Retorna: O número de caracteres no início de fonte que pertencem ao conjunto comparacao. Se o primeiro caractere da string fonte não estiver na string de comparação, a função retorna 0.

Exemplo

// EXEMPLO STRSPN()
#include <stdio.h>
#include <string.h>

int main() {
    char fonteA[] = "198462-PET-BCC/UFSCar";
    char fonteB[] = "PET-BCC/UFSCar-198462";
    char comparacao[] = "0123456789";
     
    printf("String 'fonteA':\n%s\n\n", fonteA);
    printf("String 'fonteB':\n%s\n\n", fonteB);
    printf("String 'comparacao':\n%s\n\n", comparacao);
     
    printf("Há um total de %lu dígitos iniciais na string fonteA.\n", (unsigned long)strspn(fonteA, comparacao));
    printf("Há um total de %lu dígitos iniciais na string fonteB.\n", (unsigned long)strspn(fonteB, comparacao));
     
    return 0;
}

Saída esperada

String 'fonteA':
198462-PET-BCC/UFSCar

String 'fonteB':
PET-BCC/UFSCar-198462

String 'comparacao':
0123456789

Há um total de 6 dígitos iniciais na string fonteA.
Há um total de 0 dígitos iniciais na string fonteB.

char *strstr(const char *fonte, const char *comparacao)

Localiza a primeira ocorrência da string completa comparacao dentro da string fonte.

Recebe: A string principal onde será feita a busca e a subsequência a ser procurada.

Retorna: Um ponteiro para o início da primeira ocorrência encontrada em fonte, ou NULL caso a subsequência não esteja presente.

Exemplo

// EXEMPLO STRSTR()
#include <stdio.h>
#include <string.h>
  
int main(){
  char *ponteiro;
  char fonte[] = "Programa de Ensino e Tutoria - BCC";
  char comparacao[] = "Ensino";
  
  printf("String 'fonte':\n%s\n\n", fonte);
  printf("Substring 'comparacao':\n%s\n\n", comparacao);
      
  ponteiro = strstr(fonte, comparacao);
      
  if(ponteiro != NULL){
    printf("Substring encontrada!\n");
    // A aritmética de ponteiros (ponteiro - fonte) resulta no índice
    printf("Substring inicia na posição %ld\n", (long)(ponteiro - fonte));
  } else {
    printf("Substring não encontrada!\n");
  }
      
  return 0;
}

Saída esperada

String 'fonte':
Programa de Ensino e Tutoria - BCC

Substring 'comparacao':
Ensino

Substring encontrada!
Substring inicia na posição 12

char *strtok(char *fonte, const char *delimitadores)

Divide uma string em uma sequência de tokens (sub-strings) com base em caracteres delimitadores especificados.

Recebe: A string a ser fatiada (na primeira chamada) e uma string contendo todos os caracteres que devem servir como separadores.

Retorna: Um ponteiro para o próximo token encontrado ou NULL se não houver mais tokens.
Importante: A função modifica a string original substituindo o delimitador encontrado por um caractere nulo (\0). Para obter os tokens subsequentes da mesma string, deve-se passar NULL no primeiro argumento em chamadas posteriores.

Exemplo

// EXEMPLO STRTOK()
#include <stdio.h>
#include <string.h>

int main(){
    char fonte[] = "Programa de.Ensino e#Tutoria-BCC-UFSCar";
    char delimitadores[] = "-.#"; // Note que o espaço não está aqui, então "Programa de" fica junto
    
    printf("String 'fonte':\n%s\n\n", fonte);
    printf("String 'delimitadores':\n%s\n\n", delimitadores);
    
    // Primeira chamada: passa a string original
    char *resultado = strtok(fonte, delimitadores);
    
    while(resultado != NULL){
        printf("%s\n", resultado);
        
        // Chamadas subsequentes: passa NULL para continuar de onde parou
        resultado = strtok(NULL, delimitadores);
    }
    
    return 0;
}

Saída esperada

String 'fonte':
Programa de.Ensino e#Tutoria-BCC-UFSCar

String 'delimitadores':
-.#

Programa de
Ensino e
Tutoria
BCC
UFSCar