Olá, seja bem-vindo de volta. Eu gostaria de fornecer uma demonstração de
uma solução para nosso desafio anterior, que tinha a ver com a compreensão das matrizes de caracteres.
Principalmente, vamos escrever funções para obter o comprimento de uma string, uma
função para concatenar uma string e uma função para verificar
se duas strings são iguais.
Vou criar um projeto. Vou apenas nomeá-lo para
entender as cadeias de caracteres.
E a primeira coisa que faremos é implementar essa função de comprimento.
Vamos criar três
declarações de função no topo.
Vamos nomear o primeiro comprimento de string.
Vamos usar a caixa de camelo para nomear.
Isso só vai exigir uma seqüência de caracteres constante.
Então, como sabemos que é uma string porque é um array de caracteres
e então vamos colocar um ponto-e-vírgula. Esse será o primeiro a ser criado, então vamos
parar por aí por enquanto.
E vamos criar essa
função, defini-la abaixo
para que você entenda essa bela palavra-chave const.
Const significa que é uma cadeia de caracteres que não pode ser alterada, não pode ser modificada.
O motivo de estarmos usando const aqui
é porque não queremos modificar a string dentro da função,
queremos basicamente analisá-la e, em seguida, retornar o comprimento, retornar um inteiro.
Esta função é realmente muito fácil de implementar porque estamos apenas passando por um array.
Portanto, podemos dizer que a contagem é
igual a zero. Esta é uma variável local.
Só pode ser usado dentro desta função.
Agora você pode se perguntar por que não podemos usar o tamanho do
operador, porque o tamanho do operador vai nos dizer o tamanho da string, não vai
nos dizer quantos caracteres estão dentro dessa string.
Mas tudo o que precisamos fazer é criar
um loop e percorrer o array até atingir o terminador nulo.
Assim, podemos olhar para nossa string Podemos dizer uau,
a contagem de strings não é igual ao terminador nulo,
o terminador nulo é representado dentro de um único
caractere como barra invertida zero.
E podemos usar o operador diferente de igualdade porque estamos comparando com caracteres.
E só temos uma coisa no corpo desta instrução while mais plus
count, apenas incrementando a contagem.
E então queremos devolvê-lo, apenas dizemos a contagem de retorno e é isso.
Essa é a função de comprimento de string inteira. É muito fácil porque a
string de caracteres está dentro de uma matriz
e a string termina com um terminador nulo.
Então, para testar isso, podemos iniciar
nosso método principal e criar alguns
caracteres constantes, basta dizer
a palavra um
Jason.
Portanto, é assim que você cria um array de caracteres em c.
Você não precisa ter a constante lá, mas ela não está sendo modificada.
Use a palavra-chave char, o tipo de dados char, o identificador e depois os colchetes.
É melhor não especificar o tamanho entre colchetes porque o
compilador c adicionará automaticamente um terminador nulo.
E então, logo após o
operador de atribuição, você coloca seu literal de string entre aspas duplas.
Criaremos alguns aqui apenas para garantir que estejam funcionando.
Podemos exibir cadeias de caracteres com muita facilidade porque podemos apenas usar
o símbolo de porcentagem s, exceto o que realmente queremos exibir aqui
são os comprimentos. Então, vamos usar o
percentual d.
Então, vamos apenas imprimir os links dessas três
strings, por cento de, e teremos apenas alguns espaços entre e, em seguida, adicionar
uma alimentação de linha.
E isso vai apenas chamar a função de comprimento de string
para cada palavra,
muito simples aqui, e é isso. Agora podemos construir e testar e ver se isso realmente funciona.
O que devemos ver como saída é que devemos ver o
comprimento de Jason, que é 5, o comprimento de okay que é 2 e o comprimento
de tudo o que parece ser cerca de 8.
Então aqui temos 5, 2 e 8, que parece certo.
Então é assim que você pode escrever um comprimento de string. Vamos passar para a função de concatenação.
A função de
concatenação vai pegar três strings e duas constantes.
E isso não vai retornar nada. Isso apenas colocará
a string resultante no primeiro parâmetro.
Então, vamos chamá-lo de concat. Teremos um
resultado e duas strings, uma
que desejamos concatenar duas e outra que desejamos ter
apenas uma única string. Então, vamos nomear string um, string dois.
E lá vamos nós. E essa é a nossa declaração de função.
Portanto, podemos usar em qualquer lugar antes de ser definido.
Este também terá que passar pelo array. Ele apenas terá que passar por dois
arrays e, à medida que passarmos por cada um, adicionaremos à string resultante.
Vamos criar algumas variáveis locais, que só podemos usar dentro desta função,
int I e j.
E então vamos usar um loop for
para percorrer o array. Vamos dizer que para I é igual a 0.
Devo dizer que Str sub 1 ou sub não é
igual ao terminador nulo e,
a seguir, também incrementa I.
Estamos familiarizados com nossa sintaxe de
loop for, onde temos o identificador de loop como a primeira coisa.
Antes do primeiro ponto e vírgula, a condição em que saltamos antes do segundo
ponto e vírgula e, em
seguida, modificamos a variável de controle do loop para garantir que não tenhamos um loop infinito.
Tudo o que fazemos aqui é salvar os
resultados, sub I é igual a str um sub I.
Lembre-se, esses são caracteres, então é perfeitamente normal usar igual a uma atribuição aqui.
Não podemos fazer isso em
matrizes de caracteres porque matrizes de caracteres não podem ser atribuídas a uma matriz.
Teríamos que usar uma cópia str.
Então, isso está copiando a primeira string.
E agora queremos concatenar a segunda string
aos resultados, então faríamos algo muito semelhante, exceto que vamos olhar
o segundo array e vamos ter certeza de colocá-lo no lugar certo no resultado.
Então faríamos algo assim. Iríamos de j para
zero, str para j não é igual ao terminador nulo ++ j.
E você verá que o resultado é apenas dizer I mais j, então o que quer que eu terminei.
Se eu adicionar dez caracteres, agora começará
no décimo caractere porque é baseado em zero e apenas adicionará
j a ele, então 10 mais 0, 10 mais 1 e assim por diante.
E é isso.
Uma última coisa que você precisa fazer que é realmente importante é adicionar esse terminador nulo.
Portanto, queremos dizer resultado, I mais j e, em seguida, adicionar
um único caractere, o terminador nulo, que
é a barra invertida zero dentro de uma aspa simples.
E essa é a nossa função.
Não temos que retornar nada desta função
porque estamos apenas copiando em str um para str dois.
Então, vamos testar isso.
O que eu esperava ser capaz de fazer neste aqui é testá-lo com alguns personagens.
Usaremos os caracteres existentes que temos e vamos
apenas concatenar alguns.
Portanto, precisamos criar um outro
resultado. Então, vamos
apenas dizer resultado apenas para limpá-lo.
Aqui, vamos dizer que teremos
que especificar um tamanho para o primeiro.
Então, vamos apenas especificar um tamanho de 50. Nós vamos limitar isso.
Portanto, esses caracteres constantes devem funcionar.
Agora vamos apenas dizer printf, vamos
imprimir uma string.
Então vamos dizer por cento se depois vamos dizer concat,
que é como o chamamos. Vamos passar os resultados e
depois a palavra um e a palavra dois.
Então, o que isso deve exibir como
saída, e vamos nos certificar de colocá-lo em algumas linhas novas.
Isso deve ser exibido como saída Jason okay. Portanto, concat não retorna nenhum dado, então
não posso colocá-lo diretamente no printf.
O que tenho que fazer é chamá-lo e depois exibir o resultado.
Então chamamos concat.
Tudo é colocado no resultado e nós exibimos o resultado.
Então, novamente, quando executarmos isso, devemos
ver Jason bem e veremos.
A terceira função
que queremos implementar é uma função de comparação para verificar se duas strings são iguais.
Esta função deve retornar um booleano.
Portanto, queremos incluir nosso bool padrão.
Portanto, podemos usar valores booleanos e verdadeiros e falsos.
E isso será realmente definido como strings iguais.
Isso vai levar um array de caracteres constantes, s1 e
outro para verificar se duas
strings são iguais.
Apenas para ter certeza de incluir o cabeçalho correto, vou tentar
construir isso e acho que fiz porque agora posso
usar a palavra-chave bool porque incluí isso e também posso usar true false.
Então, vamos implementar essas strings iguais.
Isso vai ser praticamente o
mesmo, apenas percorrer o array e verificar cada caractere.
Então, vamos criar algumas
variáveis locais I igual a 0 para nosso loop inicializado 0.
Em um booleano, isso apenas nos
diz se eles são iguais porque é isso que vamos retornar, algo como é igual. E poderíamos inicializar isso como falso.
O que queremos fazer primeiro, na verdade, é obter a contagem.
Queremos ver o quão grande
ambos são. Portanto, podemos ter um loop
while porque precisamos da contagem para ver o
tamanho, basicamente, apenas para verificar
a terminação nula.
Portanto, vamos assumir que as strings que passamos são do mesmo tamanho.
Portanto, podemos escrever um loop while simples. Você também pode escrever declarações if.
Eu meio que incorporei tudo
em um loop while minhas comparações usando os operadores lógicos.
Você não precisa usar operadores lógicos. Você poderia usar uma instrução if e simplesmente
percorrer toda uma segunda string.
Mas aqui o que eu fiz foi dizer que enquanto
s1 sub I é igual a igual a s2 sub
I e eles não são iguais a terminadores nulos.
Porque se eles são iguais
a terminadores nulos, queremos pular se algum deles for um terminador nulo.
Então agora dizemos mais mais eu. E a última coisa que precisamos fazer é
verificar se esses terminadores são nulos. E se estiverem, você pode definir sua variável
booleana para retornar os dados corretos.
Então aqui podemos dizer se s1 sub I é igual
a um terminador nulo e s2
sub é igual a um terminador nulo, defina nossa variável
booleana como igual e então queremos retornar isso.
E então basta dizer que o retorno é igual.
E para testar isso, teremos que testar uma string boa e uma string ruim.
Então, vamos prosseguir e dizer strings iguais.
Vou imprimir apenas o valor inteiro do booleano, então,
por cento d e vamos dizer strings iguais aqui, isso retorna algo para
que possamos colocar
isso na expressão de impressão string igual. Eu só quero ter certeza de
que as cordas
são iguais e então passaremos Jason por vírgula Jason.
E vamos chamá-lo e desta
vez diremos Jason.
E o primeiro deve retornar um, o segundo para
retornar zero, um representa verdadeiro, zero representa falso.
Quando executamos isso, vemos um e
zero. Um para verdadeiro e zero para falso, exceto
que é difícil de ler porque não temos uma alimentação de linha. Então, vamos adicionar um feed de
linha e apenas para mostrar a você novamente.
Agora vemos um zero,
verdadeiro falso. Jason Jason é igual um ao outro.
O Jason de Jason não é igual.
Estas são algumas funções rápidas com
as quais você pode aprender agora, aprender basicamente sobre as matrizes de caracteres
e como as strings são representadas com este conceito.
Obrigada. Também vou fornecer o arquivo de origem, para que você possa examiná-lo com mais detalhes.
Esperançosamente, isso ajudou em sua tarefa.