1. Introdução
Em nossa vida, existem muitas sequências longas de caracteres que precisam ser processadas centralmente, como nomes, números de certificado de província...
Neste momento, precisamos introduzir um novo conceito --- string .
"hello world!"Essa string de caracteres entre aspas duplas é chamada de string literal, ou string para abreviar.
Nota: Uma aspa simples é usada para citar um caractere e uma aspa simples não pode ser usada para citar dois ou mais caracteres.
'a'; // 字符a ' '; // 字符空格 'ab'; // err "abcdef"; // 字符串（由双引号引起的一串字符）
Em segundo lugar, a definição e armazenamento de strings
Na linguagem C, usamos o tipo int para abrir espaço para armazenamento, e o tipo de caractere usamos char, então existe um tipo que pode armazenar strings?
A resposta é não, não existe nenhum tipo em C que possa armazenar strings diretamente.
Como char é um byte, apenas um caractere pode ser armazenado. Neste momento, podemos usar arrays, que abrem um espaço de armazenamento contínuo na memória para armazenar vários elementos de dados do mesmo tipo de dados , para que possamos armazenar strings por meio de arrays de caracteres .
char arr[] = "hello world!";O código acima usa uma matriz de caracteres para armazenar strings.
1. String armazena oculto '\0'
A marca final da string é um caractere de escape de '\0'. Ao calcular o comprimento da string, '\0' é a marca final e não é contado como o conteúdo da string. '\0' está oculto.
Portanto, a matriz de caracteres acima abre espaço de armazenamento de 13 bytes na memória (valor literal da string + oculto '\0').
char arr[] = "hello world!";
// 在内存中字符串实际存储
'h'、'e'、'l'、'l'、'o'、' '、'w'、'o'、'r'、'l'、'd'、'!'、'\0'
Vamos dar uma olhada no impacto de '\0' em strings através de alguns exemplos.
// 例子1
int main()
{
char ch1[] = "abcdef";
printf("%s", ch1); // %s打印字符串
return 0;
}O resultado da impressão é abcdef e há uma marca final '\0' oculta no final da matriz de caracteres ch1, abrindo 7 bytes de espaço, para que possa ser impressa normalmente.
// 例子2
int main()
{
char ch2[] = { 'a','b','c','d','e','f' };
printf("%s", ch2);
return 0;
}O resultado da impressão é abcdef seguido por um monte de caracteres ilegíveis, porque não há marca final '\0' na matriz de caracteres ch2, que abre 6 bytes de espaço.
// 例子3
int main()
{
char ch2[] = { 'a','b','c','d','e','f','\0' };
printf("%s", ch2);
return 0;
}Adicionar '\0' com base no Exemplo 2 abriu 7 bytes de espaço e descobrimos que o resultado da impressão é abcdef, portanto, quando %s imprime uma string, ele para quando encontra o final da string '\0' imprimir .
3. Impressão de strings
1. Imprimir no modo %s
%d é um formato decimal inteiro de entrada e saída, %f imprime um número de ponto flutuante de precisão simples, %lf imprime um número de ponto flutuante de precisão dupla, %c imprime um único caractere e %x imprime um número hexadecimal.
Então, %s é o formato para imprimir a string e parar de imprimir ao encontrar o final da string '\0' .
int main()
{
char arr[] = "hello world!";
printf("%s\n", arr);
return 0;
}2. Imprima de forma circular
int main()
{
char arr[] = "hello world!";
for(int i = 0; i <= (sizeof(arr) / sizeof(char) - 2); i++)
{
printf("%c",arr[i]);
}
return 0;
}①sizeof(arr) calcula o tamanho do espaço ocupado pela matriz de caracteres, sizeof(char) calcula o tamanho de cada elemento de caractere na matriz de caracteres e divide os dois por sizeof(arr) / sizeof(char) para obter o número de caracteres armazenados na matriz de caracteres.
②Como há uma pequena diferença de 1 entre o subscrito do array e a ordem do elemento, e o último caractere '\0' não precisa ser impresso, então sizeof(arr) / sizeof(char) - 2 pode obter o subscrito do array de o último caractere.
Em quarto lugar, o comprimento da corda
Na linguagem C, para encontrar o comprimento de uma string, você precisa usar a função strlen() e precisa incluir o arquivo de cabeçalho string.h .
#include <stdio.h>
#include <string.h>
int main()
{
char arr[] = "hello world!";
printf("%d\n", strlen(arr));
return 0;
}O resultado final da saída é 12, observe que um espaço também é contado como um caractere.
Então, e se a definição da string for definida da seguinte maneira?
#include <stdio.h>
#include <string.h>
int main()
{
char arr[] = { 'h','e','l','l','o',' ','w','o','r','l','d','!' };
printf("%d\n", strlen(arr));
return 0;
}Nesse momento, descobrimos que o resultado impresso era um valor aleatório.
Isso ocorre porque o final da string é um caractere de escape '\0'. Ao calcular o comprimento da string, '\0' é a marca final e não é contado como o conteúdo da string .
O primeiro código esconde '\0' atrás de '!', ao calcular o comprimento, ele lê o '\0' oculto e para o cálculo (não conta '\0'), então o resultado é 12.
O segundo código é a inicialização normal do array. Não há nenhum caractere de escape '\0' após '!', e '\0' não é lido ao calcular o comprimento, então continua a contagem regressiva até encontrar '\0' , portanto, a saída produzida é um valor aleatório.
Com uma pequena modificação com base no segundo código, o comprimento correto pode ser calculado, basta adicionar o caractere de escape '\0' no final. O seguinte código:
#include <stdio.h>
#include <string.h>
int main()
{
char arr[] = { 'h','e','l','l','o',' ','w','o','r','l','d','!','\0' };
printf("%d\n", strlen(arr));
return 0;
}Cinco, o tamanho da matriz de caracteres
Para calcular o tamanho de um tipo de array, precisamos usar a palavra-chave sizeof, em bytes.
int main()
{
char arr[] = "hello world!";
printf("%d\n", sizeof(arr));
return 0;
}O código acima esconde '\0' na string e '\0' também ocupa um espaço de armazenamento na matriz, então o resultado de saída do código acima é 13.
int main()
{
char arr[] = { 'h','e','l','l','o',' ','w','o','r','l','d','!' };
printf("%d\n", sizeof(arr));
return 0;
}No código acima, como não há '\0' no final da matriz de caracteres, o tamanho final da matriz é calculado como 12.
int main()
{
char arr[] = { 'h','e','l','l','o',' ','w','o','r','l','d','!','\0' };
printf("%d\n", sizeof(arr));
return 0;
}O código acima tem '\0' no final da matriz de caracteres, portanto, o tamanho final da matriz é calculado como 13.
6. Diferencie sizeof() e strlen()
Não há conexão necessária entre sizeof() e strlen().
sizeof é uma das 32 palavras-chave comuns na linguagem C e é usada para calcular o tamanho do espaço de memória ocupado por um tipo ou variável (em bytes).
strlen é uma função de biblioteca que precisa incluir o arquivo de cabeçalho de string.h. Ele é usado para calcular o comprimento da string e parar o cálculo quando encontra '\0' (o resultado não inclui '\0').
Abaixo, utilizo um código para demonstrar
#include<stdio.h>
#include<string.h>
int main()
{
char arr1[] = "dengfenglai";
char arr2[] = { 'd','e','n','g','f','e','n','g','l','a','i' };
char arr3[] = { 'd','e','n','g','f','e','n','g','l','a','i','\0' };
printf("%d\n", strlen(arr1)); // 11
printf("%d\n", strlen(arr2)); // 随机值
printf("%d\n", strlen(arr3)); // 11
printf("%d\n", sizeof(arr1)); // 12
printf("%d\n", sizeof(arr2)); // 11
printf("%d\n", sizeof(arr3)); // 12
return 0;
}Através do código acima e das respostas nos comentários, pode nos ajudar a entender melhor.