Hola y bienvenido de nuevo.
En esta conferencia, quiero hablar sobre algunos errores comunes que cometerá
al programar en c.
Es posible que esté familiarizado con algunos de ellos debido a
sus desafíos anteriores, y ya se ha encontrado con estos errores, pero
estos son los tipos de errores más comunes.
El primero es muy, muy obvio. Falta un punto y coma.
Recuerde que todos los enunciados de c terminarán en punto y coma.
Si no lo tiene allí, el compilador se va a quejar.
Entonces, perder un punto y coma o perder un punto y coma por completo
es un error muy común. En este caso, estamos perdiendo un punto y coma.
Tenemos una declaración if. Ponemos un punto y coma al final de la instrucción if.
Y esto en realidad hace que el comportamiento del programa sea completamente diferente.
Esto realmente se compilará.
Cuando omita un punto y coma y ni siquiera lo tiene incluido, no se compilará.
Pero en este caso, el valor de j siempre se establecerá en cero porque
se colocó el punto y coma en la instrucción if.
Entonces, el punto y coma es perfectamente válido para tenerlo después de la instrucción if.
En realidad, representa la declaración nula.
Y por lo tanto, no tiene un error
del compilador, pero esto causará un problema porque j nunca se establecerá en cero.
Y este tipo de error también puede ser común en los bucles.
Cuando tienes un bucle y pones el punto y
coma al final del bucle for y luego puedes tener un corchete, donde
no tienes el corchete porque tendrás un error si tienes el corchete, muy común.
Otro es confundir el operador igual con el operador igual a igual.
Se mencionó específicamente que el operador igual a
igual no está comparando cadenas. Entonces, si usa es igual a igual cuando
está comparando cadenas, eso no es válido. Solo va a comparar las referencias.
Pero si realmente quiere asignar un valor a una variable y,
en su lugar, usa igual a igual, tendrá un compilador.
Ahora, si intenta comparar dos elementos, como dos enteros dentro
de una declaración if y en su lugar usa el operador de
asignación, en realidad no tendrá un error de
compilación, pero esa expresión siempre se evaluará como verdadera.
Entonces, cuando usa los iguales y no usa los iguales es
igual, esto generalmente se hace en la instrucción if while do, dentro de la expresión booleana.
Y esto es válido excepto que tiene
el efecto de asignar algo en lugar de ejecutar algo.
Entonces, en este
ejemplo, si tenemos si a es igual a 2, está asignando 2 a a.
Siempre se establece en verdadero porque es una afirmación verdadera porque nunca
falla cuando se realiza una asignación. Y así, printf siempre se ejecutará.
Lo que realmente quería hacer aquí es decir si a es igual a.
Por lo tanto, es muy común usar iguales en lugar de iguales iguales
y luego no tener un error de compilación.
Si usa los iguales es igual en la
situación incorrecta, es posible que
también tenga un comportamiento inesperado, pero tendrá un
error de compilador si lo está usando incorrectamente para la asignación.
Pero tenga cuidado con esto con los iguales en lugar de los iguales iguales.
Omitir declaraciones de prototipos.
Mencioné que es realmente importante declarar siempre sus funciones en
la parte superior del archivo antes de usarlas.
Sin embargo, esto no siempre sucede y es un error muy común.
Y, por lo general, lo que sucederá es que obtendrá un error de declaración implícito
en el compilador.
En este ejemplo, si tiene la raíz cuadrada definida más
adelante en el programa que donde la está invocando o
en otro archivo y
no la declaró explícitamente, tendrá algunas advertencias.
El compilador asumirá que la función devuelve un int.
Siempre es más seguro incluir esa declaración de prototipo en la parte
superior para todas las funciones
que llame, ya sea
explícita o implícitamente al incluir el archivo de encabezado correcto en su programa.
Pero cuando no incluye eso, esas declaraciones de prototipos pueden
tener errores.
No incluir el archivo de encabezado que incluye la definición de una función de
biblioteca de programación c que se utiliza en el programa.
Entonces, en este caso, desea reutilizar algún código. Tal vez tenga la función
printf que desea mostrar alguna salida, pero no incluye el archivo de encabezado lib estándar.
Eso es un error. Y eso normalmente te lo dirá el compilador.
Habrá un problema de vinculación
con esa función.
Entonces, en este caso, tenemos una respuesta doble igual al valor de raíz cuadrada 1.
Si este programa no incluye las matemáticas. archivo de encabezado, esto
generará un error de que la raíz cuadrada no está definida.
Intentará vincular los archivos objeto. No tendrá matemáticas. o.
Y dirá, oye, estás llamando a la raíz cuadrada, pero no hay implementación para ello.
Así que asegúrese de incluir los encabezados correctos
para todas sus invocaciones de funciones, especialmente de la biblioteca estándar.
Confundir una constante de carácter en una cadena de caracteres.
Entonces, aquí, si tenemos texto es igual a comillas simples internas, ese
es un carácter único que se asigna al texto.
Si tenemos una variable llamada texto y la asignamos entre comillas dobles,
ese es un puntero a la cadena de caracteres.
Eso no es válido para un
solo carácter.
Y esto en realidad, hemos hablado de
constantes de cadena y su asignación a matrices de caracteres.
Y cómo no puedes hacer eso con los iguales y tienes
que hacerlo con la copia estrella.
En este caso, cuando decimos que el texto es igual a a, está asignando un puntero y
esto en realidad tampoco es válido y vea
lo que tendría que hacer es que tendría que hacer que el texto
de la estrella sea igual a una o la copia de la estrella si no lo
hace. No quiero asignarlo directamente así.
Pero entiendes la esencia.
Usar un dentro de comillas simples versus un carácter entre
comillas dobles completamente diferente, carácter versus cadena.
En el primer caso, el texto normalmente se declara como una variable char.
Y en el segundo caso, debería declararse como un puntero de tipo a un char.
Y si desea asignar un valor a ese puntero que
no sea el puntero en sí, tendrá que desreferenciarlo.
En realidad, esto es incorrecto porque si es un
puntero en lugar de asignar una dirección, le está asignando una cadena, por lo
que no tiene sentido.
Usando los límites incorrectos para una matriz, excepción de matriz fuera de límites.
Aquí, estamos declarando una matriz entera de tamaño 100 y luego un
par de variables I y suma con solo algunas inicializadas.
Y revisamos nuestro ciclo, decimos que I es igual a 1 I es menor que igual a 100.
Eso es incorrecto porque el tamaño de cien significa que hay cien
elementos en la matriz. Pero las matrices tienen una base cero.
Entonces el primer elemento es cero. El índice máximo que
puede asignar o acceder en una matriz es 99.
Esto va a ser menos que igual.
Entonces, va a tener un error fuera de los límites aquí.
Este no es un
subíndice válido porque este ciclo llegará hasta 100.
Probablemente también sea incorrecto porque está comenzando en 1.
Si realmente quisiera el primer elemento de esta matriz, comenzaría en 0.
Olvidar reservar una ubicación adicional en una matriz para el
carácter nulo de terminación de una cadena
también es un problema común.
Al declarar sus matrices de caracteres, deben ser lo suficientemente grandes para contener el carácter de terminación solo.
Es por eso que le sugiero que no
ponga un tamaño en una matriz cuando la cree si la está inicializando.
Solo pondría el tamaño allí si no lo está inicializando.
Si está creando la inicialización en la misma línea, deje que c
haga el trabajo por usted, automáticamente pondrá el tamaño correcto e incluirá ese terminador nulo.
Entonces, por ejemplo, si tiene una cadena de caracteres llamada hola,
esto es más de cinco ubicaciones de memoria, son seis debido a ese terminador nulo al final.
No olvide el tamaño de sus matrices.
Este es un problema común con los punteros del que no hemos hablado mucho,
pero solo quería mencionarlo porque es muy común.
En los punteros, cuando desee acceder o incluso instruir, cuando
desee acceder a algo
mediante un puntero, debe utilizar el símbolo de guión mayor que.
Eso se usa cuando accedes a un elemento de puntero.
Entonces, si tiene un puntero que apunta a una estructura, así es como accede a él.
Si tiene una estructura, no es
un puntero, entonces accede a ella usando un operador de punto.
Muchas veces, este operador de punto y este guión son mayores
que se utilizan incorrectamente.
Punto para no punteros, punteros guión mayor que, esto quedará claro
en más de nuestros ejemplos.
Omitir el ampersand antes de las variables que no son puntero en una llamada scanf.
Así que recuerde que nuestra llamada a scanf espera un puntero como segundo argumento,
y eso significa una dirección.
Cuando declaramos un tipo de datos como una variable de tipo int, eso no
es un puntero.
Entonces, para permitir que scanf almacene esos datos en nuestra variable int, tenemos que pasarle el
ampersand para decir que es una dirección.
Entonces esto es incorrecto,
no tener el signo comercial antes del número y escanear f ya
que el segundo argumento no es válido. La única vez que no tiene el ampersand es si está usando un
puntero, como una matriz de caracteres.
Todos los argumentos que aparecen después de la cadena de formato y scanf deben ser punteros.
Usando una variable de puntero antes de que se inicialice.
Así que aquí hay un ejemplo de cómo crear un puntero y luego intentar asignarlo.
Y esta es la asignación correcta en la que le está asignando un valor que le quita la referencia.
Pero lo que no hemos hecho aquí es que hemos inicializado el puntero para
tener realmente memoria asignada y no
puede hacer esto en c.
Solo puede aplicar el operador de indirección, que
es el asterisco antes de un punto
o variable después de haber establecido la variable apuntando a algún lugar.
Así que tiene que apuntar a alguna parte, ahora mismo es nulo, no apunta a ninguna parte
porque no asignó memoria.
Por lo tanto, el puntero char nunca está configurado para apuntar a nada, por lo que la asignación no es significativa.
En realidad, esto causaría una falla de segmentación.
Otro error común es omitir la instrucción break al final de un caso en una instrucción switch.
Si la ruptura no se incluye al final de un caso, la ejecución continúa con el siguiente caso.
Así que esto es lo que mencioné cuando tienes un caso, se evalúa.
Y si no tiene esa ruptura allí, va directamente
al siguiente caso y ejecutará el código dentro del siguiente caso.
Por lo tanto, siempre desea tener descansos dentro de las declaraciones de su caso.
Hay ocasiones en las que desea tener un caso de seguimiento a otro
caso y ellos hacen exactamente lo mismo, en ese
caso no tendría nada dentro de la declaración del caso.
Insertar un punto y coma al final de una definición de preprocesador.
Las definiciones de preprocesador recuerden comenzar con el
número, el símbolo de libra. El preprocesador se ejecuta antes que el compilador
normalmente para su optimización.
La sintaxis correcta para las definiciones de preprocesador no debe incluir un punto y coma.
Sin embargo, en c, adquieres el hábito de poner siempre un punto y coma después de todo.
Pero debe recordar que si define algunos datos constantes que no necesita
el punto y coma, esto es incorrecto.
Esto conducirá a un error de sintaxis si
se usa una expresión como esa.
como eso. Entonces, si realmente intentas usar
eso para encontrar, estará bien tener ese punto y coma al final.
Pero cuando el preprocesador se ejecute, insertará exactamente lo que está definido.
Por lo tanto, servirá al final de los datos de 999 dos puntos.
Esto es lo que verá el compilador y en realidad causará un error, que
sería un error de sintaxis.
Omitir un paréntesis de cierre o comillas de cierre en
cualquier declaración, muy común. Entonces, esto también está directamente relacionado
con los corchetes, tener una llave inicial y luego no terminar la llave, lo
mismo con los paréntesis. En este caso,
tenemos dos paréntesis izquierdos iniciales o tres, pero solo
tenemos dos paréntesis finales. Nos falta un paréntesis derecho final.
Eso sería un error de sintaxis que encontraría el compilador.
Entonces, cuando usa incrustar entre paréntesis para separar cada parte de una ecuación, crea
una línea de código más legible.
Quieres usar paréntesis.
Sin embargo, desea asegurarse de que todos
coincidan, comience un paréntesis, debe tener un paréntesis de cierre final, lo mismo con las llaves.
Empiezas con una llave rizada, tiene que tener una llave final.
Entonces, o tiene demasiados o tiene muy poco, pero
el compilador se va a quejar, y esto es muy, muy común.
Entonces, a la segunda línea aquí también le falta una comilla de cierre, esta declaración impresa.
No tenemos una cita final.
El compilador se quejará de eso.
Ambos generarán un error de compilación.
A veces, aunque el compilador es muy engañoso porque en realidad
no sabe dónde ocurre el error. Cree que el error podría haber ocurrido en una línea posterior.
Entonces, la línea que le dice el error puede ser engañosa.
Entonces, dependiendo de si el
compilador usa un paréntesis o una comilla en
una línea subsiguiente, realmente completará esa expresión.
Entonces moverá el error a otra línea.
Y eso es lo que se quejará y dirá que ahí es donde está el error. Pero el error
real está más arriba de donde pretendía colocarlo.
Estos son algunos errores comunes que veo que cometen muchos programadores
de c.
Son fáciles de arreglar. Y si los comprende
y estudia esto,
sabrá que no debe hacerlos. Está bien hacerlos como
principiante, pero a medida que codifica cada vez
más y adquiere más práctica, se dará cuenta, oye, olvidé
un paréntesis, olvidé un corchete, no usé los iguales y los iguales son
iguales correctamente , Estoy usando punteros incorrectamente, no asigné memoria.
Todas estas cosas vendrán como una segunda naturaleza. Gracias.