Hola y bienvenido de nuevo. Me gustaría proporcionar una demostración de una
solución a nuestro desafío anterior que tenía que ver con la comprensión de las matrices de caracteres.
Principalmente, vamos a escribir funciones para obtener la longitud de una cadena,
función para concatenar una cadena y una función para verificar
si dos cadenas son iguales.
Entonces voy a crear un proyecto. Solo voy a
nombrarlo entendiendo cadenas de caracteres.
Y lo primero que haremos es implementar esta función de longitud.
Vamos a crear tres declaraciones
de funciones en la parte superior.
Vamos a nombrar la primera longitud de una cadena.
Usaremos el caso de camello para nuestro nombre.
Esto solo tomará una cadena de caracteres constante.
Entonces, ¿cómo sabemos que es una cadena porque es una matriz de caracteres y luego
vamos a poner un punto y coma? Será el primero en crear, así que nos
detendremos allí por ahora.
Y vamos a crear
esta función, definirla
a continuación para que comprenda esa agradable palabra clave const.
Const significa que es una cadena de caracteres que no se puede cambiar, no se puede modificar.
La razón por la que usamos const
aquí es porque no queremos modificar la cadena dentro de la
función, solo queremos analizarla y luego devolver la longitud, devolver un número entero.
Esta función es bastante fácil de implementar porque solo estamos pasando por una matriz.
Entonces, en realidad, podemos decir que la cuenta es
igual a cero. Esta es una variable local.
Solo se puede utilizar dentro de esta función.
Ahora puede preguntarse por qué no podemos usar el tamaño del operador
porque el tamaño del operador nos dirá el tamaño de la cadena, no nos
dirá cuántos caracteres hay dentro de esa cadena.
Pero todo lo que tenemos que hacer es crear
un bucle y recorrer la matriz hasta que lleguemos al terminador nulo.
Entonces podemos mirar nuestra cadena. Podemos decir wow,
el recuento de cadenas no es igual al terminador nulo,
el terminador nulo se representa dentro de un solo
carácter como una barra invertida cero.
Y podemos usar el operador no es igual porque estamos comparando con caracteres.
Y solo tenemos una cosa en el cuerpo de esta instrucción while más más
recuento, simplemente incrementando el recuento.
Y luego queremos devolverlo, solo decimos el recuento de devoluciones y eso es todo.
Esa es la función de longitud de cadena completa. Es bastante fácil porque la
cadena de caracteres está dentro de una matriz
y la cadena termina con un terminador nulo.
Entonces, para probar esto, podemos comenzar
nuestro método principal y podemos crear
algunos caracteres constantes, solo diga
la palabra uno
Jason.
Así es como se crea una matriz de caracteres en c.
No es necesario que tenga la constante allí, pero no se está modificando.
Utilice la palabra clave char, el tipo de datos char, el identificador y luego los corchetes.
Es mejor no especificar el tamaño entre corchetes porque el
compilador c agregará automáticamente un terminador nulo.
Y luego, justo después del operador
de asignación, pones tu literal de cadena dentro de las comillas dobles.
Crearemos un par aquí para asegurarnos de que esté funcionando.
Podemos mostrar cadenas de caracteres muy fácilmente porque solo podemos usar el
símbolo de porcentaje s, excepto que lo que realmente queremos mostrar aquí
son las longitudes. Entonces usaremos el
porcentaje d.
Así que imprimiremos los enlaces de estas tres
cadenas, porcentaje d, y solo tendremos algunos espacios en el medio y luego agregaremos
un salto de línea.
Y esto solo va a llamar a la función de longitud de cadena
para cada palabra,
bastante simple aquí, y eso es todo. Entonces ahora podemos construir y probar y ver si esto realmente funciona.
Lo que deberíamos ver como salida es que deberíamos ver
la longitud de Jason, que es 5, la longitud de okay, que es 2, y
la longitud de lo que parece ser aproximadamente 8.
Así que aquí tenemos 5, 2 y 8, que se ve bien.
Así es como se puede escribir la longitud de una cadena. Pasemos a la función de concatenación.
La función de
concatenación solo tomará tres cadenas y dos constantes.
Y esto no va a devolver nada. Solo pondrá la
cadena resultante en el primer parámetro.
Así que lo llamaremos concat. Vamos a tener
un resultado, y vamos a tener
dos cadenas, una que queremos concatenar dos y luego otra que
queremos tener una sola cadena. Así que nombraremos la cadena uno, la cadena dos.
Y ahí vamos. Y esa es nuestra declaración de función.
Entonces podemos usar en cualquier lugar antes de que se defina.
Este también tendrá que pasar por la matriz. Solo tendrá que pasar por dos
matrices y, a medida que avanzamos, agreguemos a la cadena resultante.
Vamos a crear un par de variables locales, que solo podemos usar dentro de esta
función, int I y j.
Y luego usaremos un bucle for
para recorrer la matriz. Vamos a decir que yo es igual a 0.
Str sub 1 o sub debería decir que no
es igual al terminador nulo
y luego también incrementar I.
Estamos familiarizados con nuestra sintaxis de
bucle for donde tenemos el identificador de bucle como lo primero.
Antes del primer punto y coma, la condición en la que saltamos antes del
segundo punto y coma y luego
modificamos la variable de control de bucle para asegurarnos de que no tenemos un bucle infinito.
Todo lo que hacemos aquí es guardar los
resultados, sub I es igual a str uno sub I.
Recuerde, estos son caracteres, por lo que está perfectamente bien usar la asignación igual aquí.
No podemos hacer esto en
matrices de caracteres porque las matrices de caracteres no se pueden asignar a una matriz.
Tendríamos que usar una copia str.
Eso es copiar la primera cadena.
Y ahora queremos concatenar la segunda cadena a los
resultados, por lo que haríamos algo muy similar, excepto que vamos a buscar
en la segunda matriz y nos aseguraremos de ponerla en el lugar correcto en el resultado.
Entonces haríamos algo como esto. Pasaríamos de j a
cero, str a j no es igual al terminador nulo ++ j.
Y verá que el resultado solo dice I más j, así que sea lo que sea que termine.
Si agregué diez caracteres, ahora comenzará en
ese décimo carácter porque está basado en cero, y solo agregará
j, por lo que 10 más 0, 10 más 1 y así sucesivamente.
Y eso es.
Una última cosa que debe hacer que es realmente importante es agregar ese terminador nulo.
Entonces queremos decir resultado, I más j y luego agregar un
solo carácter, el terminador nulo, que es
una barra invertida cero dentro de una comilla simple.
Y esa es nuestra función.
No tenemos que devolver nada de esta función
porque solo estamos copiando la cadena uno a la cadena dos.
Así que probemos esto.
Lo que esperaría poder hacer en este es probarlo con un par de personajes.
Usaremos los personajes existentes que tenemos y solo vamos
a concatenar un par.
Entonces necesitamos crear otro
resultado. Así que
solo diremos el resultado para borrarlo.
Aquí, vamos a decir que
tendremos que especificar un tamaño para el primero.
Entonces, vamos a especificar un tamaño de 50. Lo vamos a limitar.
Entonces estos caracteres constantes deberían funcionar.
Ahora solo diremos printf,
imprimiremos una cadena.
Entonces vamos a decir porcentaje sy luego vamos a decir concat,
que es como lo llamamos. Vamos a pasar los resultados
y luego la palabra uno y la palabra dos.
Entonces, ¿qué debería mostrarse como salida?
Nos aseguraremos de ponerlo en un par de líneas nuevas.
Esto debería mostrarse como salida Jason bien. Entonces, concat en realidad no devuelve ningún dato, por
lo que no puedo ponerlo directamente en printf.
Lo que tengo que hacer es llamarlo y luego mostrar el resultado.
Entonces ahí lo llamamos concat.
Todo se pone en el resultado y mostramos el resultado.
Entonces, nuevamente, cuando ejecutemos esto, deberíamos ver
a Jason bien y lo hacemos.
La tercera función
que queremos implementar es una función de comparación para verificar si dos cadenas son iguales.
Esta función debería devolver un booleano.
Por eso queremos incluir nuestro bool estándar.
Entonces podemos usar valores booleanos y verdaderos y falsos.
Y esto en realidad se definirá como cadenas iguales.
Esto tomará una matriz de caracteres constante, s1 y otra
para verificar si dos cadenas
son iguales.
Solo para asegurarme de haber incluido el encabezado correcto, intentaré construirlo
y creo que lo hice porque ahora puedo usar
la palabra clave bool porque incluí esto y también puedo usar verdadero falso.
Así que implementemos estas cadenas iguales.
En realidad, esto va a ser
lo mismo simplemente pasando por la matriz y verificando cada carácter.
Así que vamos a crear
un par de variables locales I igual a 0 para nuestro ciclo inicializado en 0.
En un booleano, eso solo nos
dice si son iguales porque esto es lo que vamos a devolver, algo como es igual. Y de hecho podríamos inicializar esto en falso.
Lo que queremos hacer primero en realidad es conseguir el recuento.
Queremos ver qué tan grandes
son ambos. Entonces podemos tener un ciclo
while porque necesitamos el recuento para ver el
tamaño básicamente para verificar
esa terminación nula.
Entonces vamos a suponer que las cadenas que pasamos son del mismo tamaño.
Entonces podemos escribir un ciclo while simple. También puede escribir declaraciones if.
En cierto modo, incorporé todo en
un bucle while, son mis comparaciones mediante el uso de operadores lógicos.
No es necesario utilizar operadores lógicos. Puede usar una declaración if y simplemente pasar por la
totalidad de una segunda cadena.
Pero aquí lo que hice fue decir que mientras
s1 sub I es igual a s2 sub
I y no son iguales a terminadores nulos.
Porque si son iguales a
terminadores nulos, queremos saltar si alguno de ellos es un terminador nulo.
Así que ahora decimos más más yo. Y luego lo último que tenemos que hacer
es verificar si esos son terminadores nulos. Y si es así, puede configurar su variable booleana
para que devuelva los datos correctos.
Entonces, aquí podemos decir que si s1 sub I es
igual a un terminador nulo y
s2 sub es igual a un terminador nulo, establezcamos que nuestra
variable booleana sea igual y luego queremos devolver eso.
Y luego diga que el retorno es igual.
Y para probar esto, tendremos que probar una cuerda buena y una cuerda mala.
Así que sigamos adelante y digamos cadenas iguales.
Voy a imprimir solo el valor entero del booleano, por lo
que el porcentaje dy vamos a decir cadenas iguales aquí, esto devuelve algo para que
podamos poner esto en
la expresión de impresión es igual a cadena. Solo quiero asegurarme de que
las cadenas
sean iguales y luego pasaremos Jason coma Jason.
Y lo llamaremos y esta
vez diremos Jason.
Y el primero debe devolver uno, el segundo para
devolver cero, uno representa verdadero, cero representa falso.
Cuando ejecutamos esto, vemos uno y
cero. Uno para verdadero y cero para falso, excepto
que es difícil de leer porque no tenemos un avance de línea. Así que agreguemos un avance
de línea y solo para mostrárselo nuevamente.
Ahora vemos un cero,
verdadero falso. Jason Jason es igual entre sí.
Jason de Jason no es igual.
Estas son algunas funciones rápidas
de las que ahora puede aprender, aprender básicamente sobre las matrices de caracteres
y cómo se representan las cadenas con este concepto.
Gracias. También voy a proporcionar el archivo fuente, para que pueda verlo con más detalle.
Con suerte, esto ayudó con su tarea.