Fuente original: https://github.com/pulkomandy/programming-with-haiku
Nuestro primer par de programas no fue tan útil, pero a medida que avanzamos, descubrirá que puede hacer más y más con sus programas. Esta vez veremos dos conceptos principales: los comentarios y las diferentes etapas que atraviesa el compilador para generar su programa, y también aprenderemos un poco acerca de la depuración de su código.
Los comentarios son notas que usted pone en el código. Tienen muchos usos, como aclarar una determinada sección del código, proporcionar advertencias o deshabilitar temporalmente una sección del código. Vea el ejemplo a continuación para ver cómo se pueden usar.
/
This is a one-line comment.
//
So is this. Everything after the two forward slashes is considered
part of it.
int
main(void)
{
PushTheRedButton(); //
This code doesn't work.
return
1;
}
Heredado de C losl comentarios multilínea. Comienzan con / * y terminan con * / de forma similar a paréntesis o llaves con una diferencia: no puedes poner un comentario de varias líneas dentro de otra.
/*-----------------------------------------------------------------------
RedButton.cpp
This
code is an example of how the compiler will complain if you use
a
function that it doesn't recognize.
------------------------------------------------------------------------*/
//
This is a one-line comment.
//
So is this. Everything after the two forward slashes is considered
part of it.
int
main(void)
{
PushTheRedButton(); //
This code doesn't work.
return
1;
}
Ahora vamos a dar un paso atrás y observar el proceso por el que pasa el compilador cuando construye su programa. Es importante entender esto porque hay diferentes tipos de errores que se pueden cometer al escribir código y saber algo sobre el proceso lo ayudará a encontrarlos más fácilmente.
Cuando un programa se crea a partir del código fuente, hay cuatro herramientas que lo operan antes de que sea un ejecutable: el preprocesador, el compilador, el ensamblador y el enlazador.
Etapa 1: El preprocesador
El preprocesador acepta el código fuente en bruto como entrada y realiza un pequeño masaje antes de enviar el código al compilador. Elimina los comentarios y maneja las directivas #include insertando el contenido del archivo de encabezado incluido en el código. Hay otras directivas que maneja que serán discutidas más adelante.Etapa 2: El compilador
El compilador traduce el código C ++ al lenguaje ensamblador. El ensamblaje es mucho, mucho más cercano a las instrucciones que la computadora entiende mientras aún se puede leer. También es mucho más difícil escribir programas y es específico para el procesador para el que está escrito.Etapa 3: El ensamblador
El ensamblador crea código de objeto a partir del código de ensamblaje creado por el compilador y los coloca en archivos de objeto que tienen una extensión .o. El código de objeto es las instrucciones reales ejecutables por la máquina que usa la computadora para ejecutar su programa. Sin embargo, no está del todo listo para correr. En este estado, los archivos de objetos utilizados para hacer su programa son muy parecidos a un conjunto de piezas de rompecabezas que están listas para armarse.Etapa 4: El enlazador
El vinculador une los archivos de objetos junto con las bibliotecas que utilizan en un programa ejecutable.Depuración
Por naturaleza, los programadores son humanos, cometen errores y muchos de ellos. Escribir código y depurar van de la mano y a menudo se hacen al mismo tiempo. Como tal, aprenderemos sobre cómo depurar programas a medida que aprendamos sobre cómo escribirlos.Los errores vienen en dos tipos: sintáctico y semántico. Los errores sintácticos son fáciles de encontrar porque el compilador los encuentra para nosotros. Estos son problemas como errores de mayúsculas, paréntesis faltantes o adicionales, y nombres de funciones mal escritos. Los errores semánticos suelen ser más difíciles de encontrar porque son errores en la lógica de un código perfectamente legal. Un error semántico en inglés sería "El censor de oxígeno en mi auto necesitaba ser reemplazado": la oración es perfectamente legal y está correctamente construida, pero la palabra necesaria es sensor, no censura. Los ejemplos de errores semánticos son puntos y coma adicionales en ciertos lugares, agregar la cantidad incorrecta a un número y hacer suposiciones sobre el valor de retorno de una función.
Echemos un vistazo a algunos ejemplos simplificados de errores comunes:
Ejemplo 1
Code
#include
<stdio.h>
int
main(void)
{
return
1;
}
}
Errors
foo.cpp:6:
error: expected declaration before ‘}’ token
Lo que tenemos aquí es una llave extra. gcc nos ha dado un error bastante críptico, como siempre, pero también nos ha dado dos pistas: el nombre del archivo y el número de línea. El número de línea dado por gcc y la ubicación real del error no siempre son iguales, pero en este caso lo son.
En este punto, es posible que se pregunte: "¿Qué en el mundo es un token, genio?" Un token es cualquier elemento del idioma. Así como un lenguaje escrito regular tiene palabras y puntuación, también lo hacen los lenguajes de computadora. Así como dos comas seguidas son un error de puntuación en el idioma inglés, tener una llave extra es un error de puntuación de C ++.
Example 2
Code
/*-----------------------------------------------------------------------
RedButton.cpp
/*This
code is an example of how the compiler will complain if you use
a
function that it doesn't recognize.*/
------------------------------------------------------------------------*/
//
This is a one-line comment.
//
So is this. Everything after the two forward slashes is considered
part of it.
int
main(void)
{
PushTheRedButton(); //
This code doesn't work.
return
1;
}
Errors
foo.cpp:7:
error: expected unqualified-id before ‘--’ token
Este es un ejemplo de cómo el número de línea para el error no es el mismo lugar que el error real. La queja es sobre los guiones al final del comentario de varias líneas en la parte superior. Es causada, sin embargo, al anidar un comentario multilínea dentro de otro. El preprocesador elimina todos los comentarios, por lo que el compilador ve esto:
------------------------------------------------------------------------*/
int
main(void)
{
PushTheRedButton();
return
1;
}
El compilador no sabe qué hacer con la línea discontinua y se queja.
Example 3
Code
int
Main(void)
{
return
1;
}
Errors
/usr/lib/gcc/i486-linux-gnu/4.4.1/../../../../lib/crt1.o:
In function `_start':
/build/buildd/eglibc-2.10.1/csu/../sysdeps/i386/elf/start.S:115:
undefined reference to `main'
/tmp/ccv39Cuo.o:(.eh_frame+0x12):
undefined reference to `__gxx_personality_v0'
collect2:
ld returned 1 exit status
Este es un error de un tipo diferente. ¿Recuerda que main () debe definirse en cada programa? No lo hicimos, definimos Main (). De lo contrario, el programa es válido, por lo que se compiló bien, pero cuando el enlazador intentó unirlo todo, no pudo encontrar la única función requerida y lanzó un hissyfit. Cada vez que vea un error que contenga una referencia indefinida, tendrá un error de vinculador.
Resolver errores del enlazador de referencia indefinido no es generalmente difícil. Por lo general, significa una de dos cosas: olvidó enlazar en una biblioteca que usó o un archivo de código fuente se omitió accidentalmente cuando se creó el programa.