Índice
1. Encontre o comprimento da string
1,strlen
2. Funções de string com comprimento ilimitado
1, strcpy
2, quebrado
3,strcmp
3. Introdução às funções de string com comprimento limitado
1,strncpy
2,strncat
3,strncmp
4. Pesquisa de strings
1,strstr
2, início
5. Relatório de mensagens de erro
1, estresse
6. Operação de personagem
7. Função de operação de memória
1,memcpy
2,mover
3, conjunto de memórias
4,memcmp
Oito, resumo
1. Encontre o comprimento da string
1,strlen
size_t strlen(const char*str);
A string tem '\0' como marca final e a função strlen retorna o número de caracteres que aparecem antes de '\0' na string (excluindo '\0' )
A string apontada pelo parâmetro deve terminar com '\0'
Observe que o valor de retorno da função é size_t , que não é assinado (propenso a erros)
Nota :
#include <stdio.h>
int main()
{
const char*str1 = "abcdef";
const char*str2 = "bbb";
if (strlen(str2) - strlen(str1) > 0)
{
printf("str2>str1\n");
}
else
{
printf("srt1>str2\n");
}
return 0;
}
O resultado desta operação é str1>str2
Como o valor de retorno da função strlen é do tipo size_t e é um número inteiro sem sinal , o valor de retorno é um número maior ou igual a 0.
A implementação de simulação da função strlen é a seguinte:
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
size_t my_strlen(const char* str)
{
int num = 0;
while (*str++ != '\0')
{
num++;
}
return num;
}
int main()
{
char arr[] = "abcde";
int ret=my_strlen(arr);
printf("%d", ret);
return 0;
}
2. Funções de string com comprimento ilimitado
1, strcpy
char * strcat (char * destino, const char * origem);
A string de origem deve terminar com '\0'
Copiará '\0' na string de origem para o espaço de destino
O espaço de destino deve ser grande o suficiente para acomodar a string de origem
O espaço alvo deve ser variável
A implementação de simulação da função strcpy é a seguinte:
#include<stdio.h>
char* my_strcpy(char* arr, const char* arr1)
{
char* p = arr;
while (*arr++ = *arr1++);
return p;
}
int main()
{
char arr[10] = "abcde";
char arr1[] = "ghjkl";
char* ret = my_strcpy(arr, arr1);
printf("%s", arr);
return 0;
}
2, quebrado
char * strcat (char * destino, const char * origem);
A string de origem deve terminar com '\0'
O espaço de destino deve ser grande o suficiente para acomodar o conteúdo da sequência de origem.
O espaço alvo deve ser modificável
Que tal anexar a string a si mesma? -----Anexar uma string a si mesmo irá travar, porque '\0' será sobrescrito, então o programa não pode terminar e será um loop infinito!
3,strcmp
int strcmp (const char * str1, const char * str2);
regulamento padrão:
Se a primeira string for maior que a segunda string, um número maior que 0 será retornado.
Se a primeira string for igual à segunda string, 0 será retornado
Se a primeira string for menor que a segunda string, um número menor que 0 será retornado.
3. Introdução às funções de string com comprimento limitado
1,strncpy
char * strncpy ( char * destino, const char * origem, size_t num );
Copie num caracteres da string de origem para o espaço de destino
Se o comprimento da string de origem for menor que num, depois de copiar a string de origem, anexe 0 ao final do destino até num
2,strncat
char * strncat ( char * destino, const char * origem, size_t num );
dest deve ter espaço suficiente para acomodar a string a ser copiada
strncat substituirá o último ' \0 ' da string de destino e, em seguida, acrescentará ' \0 ' após a conclusão da adição de caracteres;
3,strncmp
int strncmp (const char * str1, const char * str2, size_t num);
Compare até que outro caractere seja diferente ou uma string termine ou todos os caracteres numéricos sejam comparados.
4. Pesquisa de strings
1,strstr
char * strstr (const char *str1, const char * str2);
A função strstr procura se a string str1 contém a string str2. Se existir, retorna o endereço da primeira ocorrência de str2 em str1; caso contrário, retorna NULL.
Implementação de simulação da função strstr:
#include<stdio.h>
#include<assert.h>
char* my_strstr(const char* dest, const char* src)
{
assert(dest&&src);
char* s1 = dest;
while (s1)
{
char* s2 = s1;
char* s3 = src;
while ((s2&&s3) && (*s2 == *s3))
{
s2++;
s3++;
}
if (*s3 == '\0')
return s1;
if (*s2 == '\0')
return NULL;
s1++;
}
}
int main()
{
char arr[] = "abbbcdef";
char brr[] = "bbc";
char* ret = my_strstr(arr, brr);
printf("%s", ret);
return 0;
}
2, início
char * strstr (const char *str1, const char * str2);
O parâmetro sep é uma string que define o conjunto de caracteres usados como separadores.
O primeiro parâmetro especifica uma sequência contendo 0 ou mais tokens separados por um ou mais delimitadores na sequência sep.
A função strtok encontra o próximo token em str, termina com \0 e retorna um ponteiro para esse token . ( Nota: A função strtok alterará a string manipulada, portanto, a divisão da string usando a função strtok geralmente é uma cópia temporária do conteúdo e pode ser modificada. )
O primeiro parâmetro da função strtok não é NULL , a função encontrará o primeiro token em str e a função strtok salvará sua posição na string
O primeiro parâmetro da função strtok é NULL A função iniciará na posição salva na mesma string e encontrará a próxima marca.
Se não existirem mais tokens na string, um ponteiro NULL será retornado
Exemplo de código strtok:
#include<stdio.h>
int main()
{
char arr[] = "[email protected]";
char arr1[] = ".@";
char* ret = 0;
for (ret = strtok(arr, arr1); ret != 0;ret=strtok(0,arr1))
{
printf("%s\n", ret);
}
return 0;
}
5. Relatório de mensagens de erro
1, estresse
char *strerror(int errnum);
Quando uma função da biblioteca da linguagem C falha na execução, haverá um código de erro (0, 1, 2, 3, 4, 5, 6, 7, 8, 9...)
Retornar código de erro e mensagem de erro correspondente
errno é uma variável de código de erro global
Quando ocorre um erro durante a execução de uma função da biblioteca da linguagem C, o código de erro correspondente será copiado para errno.
demonstração do código strerror:
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<errno.h>
int main()
{
printf("%s\n", strerror(0));
printf("%s\n", strerror(1));
printf("%s\n", strerror(2));
printf("%s\n", strerror(3));
return 0;
6. Operação de personagem
Função de classificação de caracteres:
| função | Retorna verdadeiro se seus parâmetros atenderem às seguintes condições |
| iscntrl | qualquer personagem de controle |
| isespaço | Caracteres de espaço em branco: espaço ' ', avanço de formulário '\f', avanço de linha '\n', retorno de carro '\r', tabulação '\t' ou tabulação vertical '\v' |
| até | Números decimais 0~9 |
| dígito próprio | Números hexadecimais, incluindo todos os números decimais, letras minúsculas a~f, letras maiúsculas A~F |
| é inferior | Letras minúsculas a~z |
| é superior | Letras maiúsculas A~Z |
| isalfa | Letras a~z ou A~Z |
| o salão de gelo | Letras ou números, a~z, A~Z, 0~9 |
| ispunct | Sinais de pontuação, quaisquer caracteres gráficos que não sejam números ou letras (imprimíveis) |
| eu sou'isgraph | qualquer personagem gráfico |
| corrida | Em seguida, caracteres imprimíveis, incluindo caracteres gráficos e caracteres de espaço em branco |
Conversão de personagem:
int parainferior ( int c );
int superior ( int c );
7. Função de operação de memória
1,memcpy
void * memcpy (void * destino, const void * fonte, size_t num);
A função memcpy copia num bytes de dados começando do local de origem até o local de memória de destino.
Esta função não irá parar quando encontrar '\0'
Se houver alguma sobreposição entre a origem e o destino, os resultados da cópia serão indefinidos.
Implementação de simulação de função Memcpy:
void* my_memcpy(void* dest, const void* src, size_t num)
{
while (num--)
{
*(char*)dest = *(char*)src;
(char*)dest += 1;
(char*)src += 1;
}
}
int main()
{
char arr[] = "abcde";
char arr1[] = "gjk";
my_memcpy(arr, arr1, sizeof(arr1[0]) * 2);
printf("%s", arr);
}
2,mover
void * memmove (void * destino, const void * fonte, size_t num)
A diferença com memcpy é que o bloco de memória de origem e o bloco de memória de destino processados pela função memmove podem se sobrepor.
Se o espaço de origem e o espaço de destino se sobrepuserem, você deverá usar a função memmove para lidar com isso.
Implementação de simulação de função Memmove:
void* my_memmove(void* dest, const void* src, size_t num)
{
if (dest <= src)
{
while (num--)
{
*(char*)dest = *(char*)src;
(char*)dest += 1;
(char*)src += 1;
}
}
else
{
while (num--)
{
*((char*)dest+num) = *((char*)src+num);
}
}
}
int main()
{
int arr[] = { 1,2,3,4,5,6,7,8 };
my_memmove(arr + 3, arr + 2, sizeof(arr[0]) * 3);
int i = 0;
for (i = 0; i < 8; i++)
{
printf("%d ", arr[i]);
}
return 0;
}
3, conjunto de memórias
void* memset ( void* destino , int c , size_t num );
memset é uma função de inicialização, sua função é definir tudo em uma determinada parte da memória para um valor especificado.
exemplo de código memset:
#include<stdio.h>
int main()
{
char arr[] = "abcde";
memset(arr + 1, '#', sizeof(arr[0]) * 3);
printf("%s", arr);
return 0;
}
4,memcmp
int memcmp (const void * ptr1, const void * ptr2, size_t num);
Compare num bytes começando nos ponteiros ptr1 e ptr2
O valor de retorno é o seguinte:
Exemplo de código memcmp:
#include<stdio.h>
int main()
{
char arr[] = "abcdef";
char brr[] = "abcghj";
int ret = memcmp(arr, brr, sizeof(arr[0]) * 3);
printf("%d\n", ret);
ret=memcmp(arr, brr, sizeof(arr[0]) * 4);
printf("%d", ret);
return 0;
}
Oito, resumo
Este artigo foi cuidadosamente elaborado após consulta a inúmeros materiais, é altamente legível e tem um efeito muito bom tanto para iniciantes quanto para revisores!
Recomenda-se coletar e ponderar continuamente!