C++
Compilando y construyendo

Introducción

Observaciones

Compilando con GCC

Asumiendo un único archivo fuente llamado main.cpp , el comando para compilar y vincular un ejecutable no optimizado es el siguiente (Compilar sin optimización es útil para el desarrollo inicial y la depuración, aunque oficialmente se recomienda -Og para las versiones más recientes de GCC).

g++ -o app -Wall main.cpp -O0

Para producir un ejecutable optimizado para su uso en la producción, utilizar una de las -O opciones (véase: -O1 , -O2 , -O3 , -Os , -Ofast ):

g++ -o app -Wall -O2 main.cpp

Si se omite la opción -O, se utiliza -O0, que significa que no hay optimizaciones, como valor predeterminado (la especificación de -O sin un número se resuelve en -O1).

Alternativamente, use las marcas de optimización de los grupos O (o más optimizaciones experimentales) directamente. El siguiente ejemplo construye con la optimización de -O2 , más un indicador del nivel de optimización de -O3 :

g++ -o app -Wall -O2 -ftree-partial-pre main.cpp

Para producir un ejecutable optimizado específico de la plataforma (para su uso en producción en la máquina con la misma arquitectura), use:

g++ -o app -Wall -O2 -march=native main.cpp

Cualquiera de los anteriores producirá un archivo binario que puede ejecutarse con .\app.exe en Windows y ./app en Linux, Mac OS, etc.

La bandera -o también se puede omitir. En este caso, GCC creará una salida ejecutable predeterminada a.exe en Windows y a.out en sistemas similares a Unix. Para compilar un archivo sin vincularlo, use la opción -c :

g++ -o file.o -Wall -c file.cpp

Esto produce un archivo de objeto llamado file.o que luego puede vincularse con otros archivos para producir un binario:

g++ -o app file.o otherfile.o

Puede encontrar más información sobre las opciones de optimización en gcc.gnu.org . De particular interés son: -Og (optimización con énfasis en la experiencia de depuración, recomendada para el ciclo estándar de edición-compilación-depuración) y -Ofast (todas las optimizaciones, incluidas las que no tienen en cuenta el estricto cumplimiento de estándares).

La bandera -Wall habilita advertencias para muchos errores comunes y siempre debe usarse. Para mejorar la calidad del código, a menudo también se recomienda utilizar -Wextra y otros indicadores de advertencia que no están habilitados automáticamente por -Wall y -Wextra .

Si el código espera un estándar de C ++ específico, especifique qué estándar usar incluyendo la -std= . Los valores admitidos corresponden al año de finalización de cada versión del estándar ISO C ++. A partir de GCC 6.1.0, los valores válidos para el indicador std= son c++98 / c++03 , c++11 , c++14 y c++17 / c++1z . Los valores separados por una barra diagonal son equivalentes.

g++ -std=c++11 <file>

GCC incluye algunas extensiones específicas del compilador que están deshabilitadas cuando entran en conflicto con un estándar especificado por el -std= . Para compilar con todas las extensiones habilitadas, se puede utilizar el valor gnu++XX , donde XX es cualquiera de los años utilizados por los valores de c++ enumerados anteriormente.

El estándar predeterminado se utilizará si no se especifica ninguno. Para las versiones de GCC anteriores a 6.1.0, el valor predeterminado es -std=gnu++03 ; en GCC 6.1.0 y superior, el valor predeterminado es -std=gnu++14 .

Tenga en cuenta que debido a errores en GCC, el indicador -pthread debe estar presente en la compilación y enlace para que GCC admita la funcionalidad de subprocesamiento estándar C ++ introducida con C ++ 11, como std::thread y std::wait_for . Omitirlo cuando se usan funciones de subprocesamiento puede generar advertencias pero resultados no válidos en algunas plataformas.

Vinculación con bibliotecas:

Use la opción -l para pasar el nombre de la biblioteca:

g++ main.cpp -lpcre2-8
#pcre2-8 is the PCRE2 library for 8bit code units (UTF-8)

Si la biblioteca no está en la ruta de la biblioteca estándar, agregue la ruta con la opción -L :

g++ main.cpp -L/my/custom/path/ -lmylib

Se pueden vincular varias bibliotecas entre sí:

g++ main.cpp -lmylib1 -lmylib2 -lmylib3

Si una biblioteca depende de otra, ponga la biblioteca dependiente antes de la biblioteca independiente:

g++ main.cpp -lchild-lib -lbase-lib

O deje que el enlazador determine el pedido a través de --start-group y --end-group (nota: esto tiene un costo de rendimiento significativo):

g++ main.cpp -Wl,--start-group -lbase-lib -lchild-lib -Wl,--end-group

Compilando con Visual C ++ (Línea de Comando)

Para los programadores que vienen de GCC o Clang a Visual Studio, o los programadores que se sienten más cómodos con la línea de comandos en general, puede usar el compilador de Visual C ++ desde la línea de comandos así como el IDE.

Si desea compilar su código desde la línea de comandos en Visual Studio, primero debe configurar el entorno de línea de comandos. Esto se puede hacer abriendo la línea de Visual Studio Command Prompt / Developer Command Prompt / x86 Native Tools Command Prompt / x64 Native Tools Command Prompt o similar (según lo provisto por su versión de Visual Studio), o en la línea de comandos, navegando a el subdirectorio VC directorio de instalación del compilador (normalmente \Program Files (x86)\Microsoft Visual Studio x\VC , donde x es el número de versión (como 10.0 para 2010 o 14.0 para 2015) y ejecuta el archivo por lotes VCVARSALL con una parámetro de línea de comando especificado aquí .

Tenga en cuenta que a diferencia de GCC, Visual Studio no proporciona un front-end para el vinculador ( link.exe ) a través del compilador ( cl.exe ), sino que proporciona el vinculador como un programa separado, al que el compilador llama cuando sale. cl.exe y link.exe se pueden usar por separado con diferentes archivos y opciones, o se puede indicar a cl que pase archivos y opciones para link si ambas tareas se realizan juntas. Cualquier opción de enlace especificada para cl se convertirá en opciones para link , y cualquier archivo que no sea procesado por cl pasará directamente al link . Como esta es principalmente una guía simple para compilar con la línea de comandos de Visual Studio, los argumentos para el link no se describirán en este momento; Si necesita una lista, vea aquí .

Tenga en cuenta que los argumentos para cl distinguen entre mayúsculas y minúsculas, mientras que los argumentos para link no lo son.

[Tenga en cuenta que algunos de los siguientes ejemplos utilizan la variable "directorio actual" del shell de Windows, %cd% , al especificar nombres de ruta absolutos. Para cualquier persona que no esté familiarizada con esta variable, se expande al directorio de trabajo actual. Desde la línea de comandos, será el directorio en el que estaba cuando ejecutó cl , y se especifica en el símbolo del sistema de manera predeterminada (si su símbolo del sistema es C:\src> , por ejemplo, entonces %cd% es C:\src\ ).]

Suponiendo que un solo archivo de origen denominado main.cpp en la carpeta actual, el comando para compilar y vincular un ejecutable no optimizado (útil para el desarrollo inicial y la depuración) es (use uno de los siguientes):

cl main.cpp
// Generates object file "main.obj".
// Performs linking with "main.obj".
// Generates executable "main.exe".

cl /Od main.cpp
// Same as above.
// "/Od" is the "Optimisation: disabled" option, and is the default when no /O is specified.

Suponiendo un archivo fuente adicional "niam.cpp" en el mismo directorio, use lo siguiente:

cl main.cpp niam.cpp
// Generates object files "main.obj" and "niam.obj".
// Performs linking with "main.obj" and "niam.obj".
// Generates executable "main.exe".

También puedes usar comodines, como es de esperar:

cl main.cpp src\*.cpp
// Generates object file "main.obj", plus one object file for each ".cpp" file in folder
//  "%cd%\src".
// Performs linking with "main.obj", and every additional object file generated.
// All object files will be in the current folder.
// Generates executable "main.exe".

Para renombrar o reubicar el ejecutable, use uno de los siguientes:

cl /o name main.cpp
// Generates executable named "name.exe".

cl /o folder\ main.cpp
// Generates executable named "main.exe", in folder "%cd%\folder".

cl /o folder\name main.cpp
// Generates executable named "name.exe", in folder "%cd%\folder".

cl /Fename main.cpp
// Same as "/o name".

cl /Fefolder\ main.cpp
// Same as "/o folder\".

cl /Fefolder\name main.cpp
// Same as "/o folder\name".

Tanto /o como /Fe pasan su parámetro (llamémoslo o-param ) para link como /OUT:o-param , agregando la extensión apropiada (generalmente .exe o .dll ) para "nombrar" o-param según sea necesario. Mientras tanto /o y /Fe son, en mi opinión, idénticas en funcionalidad, esta última es la preferida para Visual Studio. /o está marcado como obsoleto y parece que se proporciona principalmente para programadores más familiarizados con GCC o Clang.

Tenga en cuenta que si bien el espacio entre /o y la carpeta y / o el nombre especificados es opcional, no puede haber un espacio entre /Fe y la carpeta y / o el nombre especificados.

De manera similar, para producir un ejecutable optimizado (para uso en producción), use:

cl /O1 main.cpp
// Optimise for executable size.  Produces small programs, at the possible expense of slower
//  execution.

cl /O2 main.cpp
// Optimise for execution speed.  Produces fast programs, at the possible expense of larger
//  file size.

cl /GL main.cpp other.cpp
// Generates special object files used for whole-program optimisation, which allows CL to
//  take every module (translation unit) into consideration during optimisation.
// Passes the option "/LTCG" (Link-Time Code Generation) to LINK, telling it to call CL during
//  the linking phase to perform additional optimisations.  If linking is not performed at this
//  time, the generated object files should be linked with "/LTCG".
// Can be used with other CL optimisation options.

Finalmente, para producir un ejecutable optimizado específico de la plataforma (para su uso en la producción en la máquina con la arquitectura especificada), elija el indicador de comando o el parámetro VCVARSALL para la plataforma de destino. link debe detectar la plataforma deseada desde los archivos de objetos; si no, use la opción /MACHINE para especificar explícitamente la plataforma de destino.

// If compiling for x64, and LINK doesn't automatically detect target platform:
cl main.cpp /link /machine:X64

Cualquiera de los anteriores producirá un ejecutable con el nombre especificado por /o o /Fe , o si no se proporciona ninguno, con un nombre idéntico al primer archivo de origen u objeto especificado para el compilador.

cl a.cpp b.cpp c.cpp
// Generates "a.exe".

cl d.obj a.cpp q.cpp
// Generates "d.exe".

cl y.lib n.cpp o.obj
// Generates "n.exe".

cl /o yo zp.obj pz.cpp
// Generates "yo.exe".

Para compilar un archivo (s) sin vincular, use:

cl /c main.cpp
// Generates object file "main.obj".

Esto le dice a cl que salga sin llamar al link , y produce un archivo objeto, que luego puede vincularse con otros archivos para producir un binario.

cl main.obj niam.cpp
// Generates object file "niam.obj".
// Performs linking with "main.obj" and "niam.obj".
// Generates executable "main.exe".

link main.obj niam.obj
// Performs linking with "main.obj" and "niam.obj".
// Generates executable "main.exe".

También hay otros parámetros de línea de comando valiosos, que sería muy útil para los usuarios saber:

cl /EHsc main.cpp
// "/EHsc" specifies that only standard C++ ("synchronous") exceptions will be caught,
//  and `extern "C"` functions will not throw exceptions.
// This is recommended when writing portable, platform-independent code.

cl /clr main.cpp
// "/clr" specifies that the code should be compiled to use the common language runtime,
//  the .NET Framework's virtual machine.
// Enables the use of Microsoft's C++/CLI language in addition to standard ("native") C++,
//  and creates an executable that requires .NET to run.

cl /Za main.cpp
// "/Za" specifies that Microsoft extensions should be disabled, and code should be
//  compiled strictly according to ISO C++ specifications.
// This is recommended for guaranteeing portability.

cl /Zi main.cpp
// "/Zi" generates a program database (PDB) file for use when debugging a program, without
//  affecting optimisation specifications, and passes the option "/DEBUG" to LINK.

cl /LD dll.cpp
// "/LD" tells CL to configure LINK to generate a DLL instead of an executable.
// LINK will output a DLL, in addition to an LIB and EXP file for use when linking.
// To use the DLL in other programs, pass its associated LIB to CL or LINK when compiling those
//  programs.

cl main.cpp /link /LINKER_OPTION
// "/link" passes everything following it directly to LINK, without parsing it in any way.
// Replace "/LINKER_OPTION" with any desired LINK option(s).

Para cualquiera que esté más familiarizado con los sistemas * nix y / o GCC / Clang, cl , link y otras herramientas de línea de comandos de Visual Studio puede aceptar parámetros especificados con un guión (como -c ) en lugar de una barra (como /c ). Además, Windows reconoce una barra diagonal o una barra diagonal inversa como un separador de ruta válido, por lo que también se pueden usar las rutas estilo * nix. Esto facilita la conversión de líneas de comando del compilador simple de g++ o clang++ a cl , o viceversa, con cambios mínimos.

g++ -o app src/main.cpp
cl  -o app src/main.cpp

Por supuesto, cuando se transfieren líneas de comando que usan opciones más complejas de g++ o clang++ , debe buscar comandos equivalentes en la documentación del compilador correspondiente y / o en los sitios de recursos, pero esto hace que sea más fácil comenzar con un tiempo mínimo de aprendizaje. Nuevos compiladores.

En caso de que necesite funciones de idioma específicas para su código, se requiere una versión específica de MSVC. Desde Visual C ++ 2015 Update 3 , es posible elegir la versión del estándar para compilar a través de la bandera /std . Los valores posibles son /std:c++14 y /std:c++latest ( /std:c++17 seguirá pronto).

Nota: en versiones anteriores de este compilador, las características específicas estaban disponibles, sin embargo, esto se utilizaba principalmente para las vistas previas de nuevas funciones.

Compilación con Visual Studio (interfaz gráfica) - Hello World

1. Descargue e instale Visual Studio Community 2015
2. Abrir la comunidad de Visual Studio
3. Haga clic en Archivo -> Nuevo -> Proyecto
4. Haga clic en Plantillas -> Visual C ++ -> Aplicación de consola Win32 y luego nombre el proyecto MyFirstProgram .
5. Haga clic en Aceptar
6. Haga clic en Siguiente en la siguiente ventana.
7. Marque la casilla Empty project y luego haga clic en Finalizar:
8. Haga clic derecho en la carpeta Archivo de origen y luego -> Agregar -> Nuevo elemento:
9. Seleccione Archivo C ++ y nombre el archivo main.cpp, luego haga clic en Agregar: 10: Copie y pegue el siguiente código en el nuevo archivo main.cpp:

#include <iostream>

int main()
{
    std::cout << "Hello World!\n";
    return 0;
}

Tu entorno debe verse como:

11. Haga clic en Depurar -> Iniciar sin depurar (o presione ctrl + F5):

12. Hecho. Deberías obtener la siguiente salida de consola:

Compilando con Clang

Como la interfaz de Clang está diseñada para ser compatible con GCC, la mayoría de los programas que se pueden compilar a través de GCC se compilarán cuando intercambies g++ por clang++ en los scripts de compilación. Si no se -std=version , se utilizará gnu11.

Los usuarios de Windows que están acostumbrados a MSVC pueden intercambiar cl.exe con clang-cl.exe . De forma predeterminada, clang intenta ser compatible con la versión más alta de MSVC que se ha instalado.

En el caso de compilar con visual studio, clang-cl puede usarse cambiando el Platform toolset de Platform toolset la Platform toolset en las propiedades del proyecto.

En ambos casos, clang solo es compatible a través de su interfaz, aunque también intenta generar archivos de objetos compatibles binarios. Los usuarios de clang-cl deben tener en cuenta que la compatibilidad con MSVC aún no está completa .

Para usar clang o clang-cl, uno podría usar la instalación predeterminada en ciertas distribuciones de Linux o las que vienen con IDE (como XCode en Mac). Para otras versiones de este compilador o en plataformas que no lo tienen instalado, se puede descargar desde la página de descarga oficial .

Si está utilizando CMake para compilar su código, generalmente puede cambiar el compilador configurando las variables de entorno CC y CXX esta manera:

mkdir build
cd build
CC=clang CXX=clang++ cmake ..
cmake --build .

Véase también la introducción a Cmake .

Compiladores en linea

Varios sitios web proporcionan acceso en línea a compiladores de C ++. El conjunto de funciones del compilador en línea varía significativamente de un sitio a otro, pero generalmente permiten hacer lo siguiente:

• Pega tu código en un formulario web en el navegador.
• Seleccione algunas opciones del compilador y compile el código.
• Recoger compilador y / o salida del programa.

El comportamiento del sitio web del compilador en línea suele ser bastante restrictivo, ya que permite que cualquier persona ejecute compiladores y ejecute código arbitrario en su servidor, mientras que la ejecución de código arbitrario a distancia se considera una vulnerabilidad.

Los compiladores en línea pueden ser útiles para los siguientes propósitos:

• Ejecute un pequeño fragmento de código desde una máquina que carece de compilador de C ++ (teléfonos inteligentes, tabletas, etc.).
• Asegúrese de que el código se compile correctamente con diferentes compiladores y se ejecute de la misma manera, independientemente del compilador con el que se compiló.
• Aprender o enseñar conceptos básicos de C ++.
• Conozca las funciones modernas de C ++ (C ++ 14 y C ++ 17 en un futuro próximo) cuando el compilador C ++ actualizado no esté disponible en la máquina local.
• Detecta un error en tu compilador en comparación con un gran conjunto de otros compiladores. Compruebe si se solucionó un error del compilador en futuras versiones, que no están disponibles en su máquina.
• Resolver problemas de jueces en línea.

Para qué compiladores en línea no se debe utilizar:

• Desarrolle aplicaciones completas (incluso pequeñas) utilizando C ++. Por lo general, los compiladores en línea no permiten enlazar con bibliotecas de terceros o descargar artefactos de compilación.
• Realizar cálculos intensivos. Los recursos informáticos del lado del servidor son limitados, por lo que cualquier programa proporcionado por el usuario se eliminará después de unos segundos de ejecución. El tiempo de ejecución permitido suele ser suficiente para la prueba y el aprendizaje.
• Atacar el servidor del compilador o cualquier otro host de terceros en la red.

Ejemplos:

Descargo de responsabilidad: los autores de la documentación no están afiliados a los recursos que se enumeran a continuación. Los sitios web están listados alfabéticamente.

• http://codepad.org/ Compilador en línea con código compartido. Editar código después de compilar con un código fuente de advertencia o error no funciona tan bien.
• http://coliru.stacked-crooked.com/ Compilador en línea para el que especifica la línea de comando. Proporciona compiladores de GCC y Clang para su uso.
• http://cpp.sh/ - Compilador en línea con soporte para C ++ 14. No le permite editar la línea de comandos del compilador, pero algunas opciones están disponibles a través de los controles GUI.
• https://gcc.godbolt.org/ : proporciona una amplia lista de versiones de compilador, arquitecturas y resultados de desensamblaje. Muy útil cuando necesitas inspeccionar lo que compila tu código por diferentes compiladores. GCC, Clang, MSVC ( CL ), compilador Intel ( icc ), ELLCC y Zapcc están presentes, con uno o más de estos compiladores disponibles para ARM, ARMv8 (como ARM64), AVR de Atmel, MIPS, MIPS64, MSP430, PowerPC , x86, y x64 architecutres. Los argumentos de la línea de comando del compilador pueden ser editados.
• https://ideone.com/ : se utiliza ampliamente en la red para ilustrar el comportamiento del fragmento de código. Proporciona GCC y Clang para su uso, pero no le permite editar la línea de comandos del compilador.
• http://melpon.org/wandbox - Admite numerosas versiones de compilador Clang y GNU / GCC.
• http://onlinegdb.com/ : un IDE extremadamente minimalista que incluye un editor, un compilador (gcc) y un depurador (gdb).
• http://rextester.com/ : proporciona compiladores de Clang, GCC y Visual Studio para C y C ++ (junto con compiladores para otros idiomas), con la biblioteca Boost disponible para su uso.
• http://tutorialspoint.com/compile_cpp11_online.php : shell UNIX con todas las funciones con GCC y un explorador de proyectos fácil de usar.
• http://webcompiler.cloudapp.net/ - Compilador en línea de Visual Studio 2015, proporcionado por Microsoft como parte de RiSE4fun.

El proceso de compilación de C ++.

Cuando desarrolle un programa en C ++, el siguiente paso es compilar el programa antes de ejecutarlo. La compilación es el proceso que convierte el programa escrito en lenguaje legible por humanos como C, C ++, etc., en un código de máquina, entendido directamente por la Unidad Central de Procesamiento. Por ejemplo, si tiene un archivo de código fuente de C ++ llamado prog.cpp y ejecuta el comando de compilación,

   g++ -Wall -ansi -o prog prog.cpp

Hay 4 etapas principales involucradas en la creación de un archivo ejecutable desde el archivo fuente.

1. El preprocesador de C ++ toma un archivo de código fuente de C ++ y se ocupa de los encabezados (#include), macros (#define) y otras directivas de preprocesador.

2. El archivo de código fuente expandido de C ++ producido por el preprocesador de C ++ se compila en el lenguaje ensamblador de la plataforma.

3. El código de ensamblador generado por el compilador se ensambla en el código de objeto para la plataforma.

4. El archivo de código de objeto producido por el ensamblador está vinculado entre sí
   con los archivos de código de objeto para cualquier función de biblioteca utilizada para producir una biblioteca o un archivo ejecutable.

Preprocesamiento

El preprocesador maneja las directivas del preprocesador, como #include y #define. Es un agnóstico de la sintaxis de C ++, por lo que debe usarse con cuidado.

Funciona en un archivo fuente de C ++ a la vez al reemplazar las directivas #include con el contenido de los archivos respectivos (que generalmente son solo declaraciones), al reemplazar las macros (# definir) y al seleccionar diferentes porciones de texto dependiendo de #if, #ifdef y #ifndef directivas.

El preprocesador trabaja en una secuencia de tokens de preprocesamiento. La sustitución de macros se define como la sustitución de tokens con otros tokens (el operador ## permite fusionar dos tokens cuando tiene sentido).

Después de todo esto, el preprocesador produce una salida única que es una secuencia de tokens resultantes de las transformaciones descritas anteriormente. También agrega algunos marcadores especiales que le dicen al compilador de dónde proviene cada línea para que pueda usarlos para producir mensajes de error razonables.

Algunos errores pueden producirse en esta etapa con un uso inteligente de las directivas #if y #error.

Al utilizar el indicador del compilador a continuación, podemos detener el proceso en la etapa de preprocesamiento.

g++ -E prog.cpp

Compilacion

El paso de compilación se realiza en cada salida del preprocesador. El compilador analiza el código fuente puro de C ++ (ahora sin directivas de preprocesador) y lo convierte en código de ensamblaje. Luego invoca el back-end subyacente (ensamblador en la cadena de herramientas) que ensambla ese código en un código de máquina produciendo un archivo binario real en algún formato (ELF, COFF, a.out, ...). Este archivo de objeto contiene el código compilado (en forma binaria) de los símbolos definidos en la entrada. Los símbolos en los archivos de objetos se denominan por nombre.

Los archivos de objetos pueden referirse a símbolos que no están definidos. Este es el caso cuando usa una declaración y no proporciona una definición para ella. Al compilador no le importa esto, y felizmente producirá el archivo de objeto siempre que el código fuente esté bien formado.

Los compiladores generalmente le permiten detener la compilación en este punto. Esto es muy útil porque con él puede compilar cada archivo de código fuente por separado. La ventaja que esto proporciona es que no necesita recompilar todo si solo cambia un solo archivo.

Los archivos de objetos producidos se pueden colocar en archivos especiales denominados bibliotecas estáticas, para luego reutilizarlos más fácilmente.

Es en esta etapa que se informan los errores "regulares" del compilador, como los errores de sintaxis o los errores de resolución de sobrecarga fallidos.

Para detener el proceso después del paso de compilación, podemos usar la opción -S:

g++ -Wall -ansi -S prog.cpp

Montaje

El ensamblador crea código objeto. En un sistema UNIX puede ver archivos con un sufijo .o (.OBJ en MSDOS) para indicar archivos de código de objeto. En esta fase, el ensamblador convierte esos archivos de objeto de código de ensamblaje en instrucciones a nivel de máquina y el archivo creado es un código de objeto reubicable. Por lo tanto, la fase de compilación genera el programa de objeto reubicable y este programa se puede utilizar en diferentes lugares sin tener que compilar nuevamente.

Para detener el proceso después del paso de ensamblaje, puede usar la opción -c:

g++ -Wall -ansi -c prog.cpp

Enlace

El enlazador es lo que produce la salida de compilación final de los archivos de objetos que produjo el ensamblador. Esta salida puede ser una biblioteca compartida (o dinámica) (y aunque el nombre es similar, no tienen mucho en común con las bibliotecas estáticas mencionadas anteriormente) o un archivo ejecutable.

Vincula todos los archivos de objetos reemplazando las referencias a símbolos no definidos con las direcciones correctas. Cada uno de estos símbolos se puede definir en otros archivos de objetos o en bibliotecas. Si están definidas en bibliotecas distintas de la biblioteca estándar, debe informar al vinculador sobre ellas.

En esta etapa, los errores más comunes son las definiciones faltantes o las definiciones duplicadas. Lo primero significa que las definiciones no existen (es decir, no están escritas), o que los archivos de objetos o las bibliotecas donde residen no se entregaron al vinculador. Lo último es obvio: el mismo símbolo se definió en dos archivos de objetos o bibliotecas diferentes.

Compilando con Code :: Blocks (interfaz gráfica)

1. Descargue e instale Code :: Blocks aquí . Si está en Windows, tenga cuidado de seleccionar un archivo cuyo nombre contenga mingw , los otros archivos no instalarán ningún compilador.

2. Abra Code :: Blocks y haga clic en "Crear un nuevo proyecto":

   

3. Seleccione "Aplicación de consola" y haga clic en "Ir":

   

4. Haga clic en "Siguiente", seleccione "C ++", haga clic en "Siguiente", seleccione un nombre para su proyecto y elija una carpeta para guardarlo, haga clic en "Siguiente" y luego haga clic en "Finalizar".

5. Ahora puedes editar y compilar tu código. Un código predeterminado que imprime "¡Hola mundo!" En la consola ya está ahí. Para compilar y / o ejecutar su programa, presione uno de los tres botones de compilar / ejecutar en la barra de herramientas:

   

   Para compilar sin correr, pulsa , para correr sin compilar nuevamente, presione y para compilar y luego correr, presiona .

   Compilando y ejecutando el predeterminado "¡Hola mundo!" El código da el siguiente resultado: