Preprocesador de C

Los siguientes tokens son reconocidos por el preprocesador en el contexto de las directivas del preprocesador.

Hasta C++26 , las palabras clave de C++ import, export, y moduletambién eran manejadas parcialmente por el preprocesador.

El lenguaje de programación Haskell también acepta directivas de preprocesador de C, que se invocan escribiendo {-# LANGUAGE CPP #-}al principio del archivo. Las directivas de preprocesador aceptadas coinciden con las del estándar C/C++.

Aunque C#, F# ^{[ 4 ]} y Visual J# no tienen un preprocesador separado, estas directivas se procesan como si lo tuvieran.

C# no utiliza un preprocesador para gestionar estas directivas, por lo que no son gestionadas ni eliminadas por un preprocesador, sino que son leídas directamente por el compilador de C# como una característica del lenguaje.

Los siguientes tokens son reconocidos por el preprocesador en el contexto de las directivas del preprocesador.

Los siguientes tokens, denominados "directivas del compilador", son detectados por el compilador. No son exactamente iguales a las directivas del preprocesador de C, pero tienen la misma estructura y sintaxis.

En el preprocesador de C existen dos directivas para incluir el contenido de los archivos:

• #include, utilizado para incluir directamente el contenido de un archivo en el mismo lugar (normalmente contiene algún tipo de código)
• #embed, utilizado para incluir o incrustar directamente el contenido de un recurso binario en el mismo lugar.

#include <stdio.h>int main ( void ) { printf ( "Hola, Mundo! \n " ); return 0 ; }

constexpr char ICON_DISPLAY_DATA [] = { #embed "art.png" };// especifique cualquier tipo que pueda inicializarse a partir de expresiones constantes enteras lo hará constexpr char RESET_BLOB [] = { #embed "data.bin" };// los atributos funcionan igual de bien alignas ( 8 ) constexpr char ALIGNED_DATA_STRING [] = { #embed "attributes.xml" };int main () { return #embed </dev/urandom> limit(1) ; }

La compilación condicional es compatible mediante las directivas principales if-else#if , #else, #elif, y #endify con las directivas de contracción #ifdefy #ifndef, que representan #if defined(...)y #if !defined(...), respectivamente. En el siguiente código de ejemplo, la printf()llamada solo se incluye para la compilación si VERBOSEestá definida.

#ifdef VERBOSE printf ( "mensaje de seguimiento" ); #endif

Lo siguiente demuestra una lógica más compleja:

#if !(defined __LP64__ || defined __LLP64__) || defined _WIN32 && !defined _WIN64 // código para un sistema de 32 bits #else // código para un sistema de 64 bits #endif

Se puede eliminar una definición de macro del contexto del preprocesador de #undeftal manera que la referencia posterior al token de macro no se expanda. Por ejemplo:

#define VALOR 15// hacer cosas con VALOR...#undef VALUE // El token 'VALUE' ya no se expande desde aquí...

El preprocesador proporciona automáticamente algunas definiciones de macros. El estándar C especifica que __FILE__se expande al nombre del archivo que se está procesando y __LINE__se expande al número de la línea que contiene la directiva. La siguiente macro, DEBUGPRINT, formatea e imprime un mensaje con el nombre del archivo y el número de línea.

#define DEBUGPRINT(_fmt, ...) printf("[%s:%d]: " _fmt, __FILE__, __LINE__, __VA_ARGS__)

Para el código de ejemplo que aparece a continuación, en la línea 30 del archivo util.c y con un valor de conteo de 123, la salida es: .[util.c:30]: count=123

DEBUGPRINT ( "count=%d \n " , count );

El primer estándar C especificaba que __STDC__se expandiera a "1" si la implementación se ajustaba al estándar ISO y a "0" en caso contrario, y que __STDC_VERSION__se expandiera a un literal numérico que especificara la versión del estándar compatible con la implementación. Los compiladores estándar de C++ admiten la __cplusplusmacro. Los compiladores que se ejecutan en modo no estándar no deben establecer estas macros o deben definir otras para indicar las diferencias.

Otras macros estándar incluyen __DATE__, la fecha actual, y __TIME__, la hora actual.

La segunda edición del estándar C, C99 , agregó soporte para __func__, que contiene el nombre de la definición de la función dentro de la cual está contenida, pero debido a que el preprocesador es agnóstico a la gramática de C, esto debe hacerse en el compilador mismo usando una variable local a la función.

Un patrón de uso poco conocido del preprocesador de C se conoce como X-Macros . ^{[ 9 ] [ 10 ] [ 11 ]} Una X-Macro es un archivo de cabecera . Comúnmente, estos usan la extensión .def en lugar de la tradicional .h . Este archivo contiene una lista de llamadas a macros similares, que pueden denominarse "macros de componentes". El archivo de inclusión se referencia repetidamente.

Muchos compiladores definen macros adicionales no estándar. Una referencia común para estas macros es el proyecto Pre-defined C/C++ Compiler Macros , que enumera "varias macros de compilador predefinidas que se pueden usar para identificar estándares, compiladores, sistemas operativos, arquitecturas de hardware e incluso bibliotecas básicas de tiempo de ejecución en tiempo de compilación".

La mayoría de los compiladores que se dirigen a Microsoft Windows definen implícitamente _WIN32. ^{[ 12 ]} Esto permite que el código, incluidos los comandos del preprocesador, se compile solo cuando se dirige a sistemas Windows. Algunos compiladores definen WIN32en su lugar. Para aquellos compiladores que no definen implícitamente la _WIN32macro, se puede especificar en la línea de comandos del compilador, usando -D_WIN32.

#ifdef __unix__ // __unix__ suele estar definido por compiladores que se dirigen a sistemas Unix #include <unistd.h> #elifdef _WIN32 // _WIN32 suele estar definido por compiladores que se dirigen a sistemas Windows de 32 o 64 bits #include <windows.h> #endif#ifdef __linux__ #define CURRENT_PLATFORM "Linux" #elifdef __APPLE__ #define CURRENT_PLATFORM "Apple" #elifdef _WIN32 #define CURRENT_PLATFORM "Windows" #else #define CURRENT_PLATFORM "Other" #endif

El código de ejemplo comprueba si se ha definido una macro __unix__. Si es así, <unistd.h>se incluye el archivo. De lo contrario, comprueba si _WIN32se ha definido otra macro. Si es así, <windows.h>también se incluye el archivo. Del mismo modo, dependiendo de la macro definida, se define CURRENT_PLATFORMcomo una cadena con el nombre de la plataforma del sistema.

Los valores de las macros predefinidas __FILE__se __LINE__pueden establecer para una línea posterior mediante la #linedirectiva. En el código siguiente, __LINE__se expande a 314 y __FILE__a " pi.c ".

#línea 314 "pi.c" printf ( "línea=%d archivo=%s \n " , __LINE__ , __FILE__ );

El preprocesador es capaz de interpretar operadores y evaluar expresiones muy básicas, como constantes enteras, operadores aritméticos, operadores de comparación, operadores lógicos, operaciones bit a bit, el definedoperador y el #operador de conversión a cadena. Esto permite al preprocesador realizar evaluaciones como:

// si X es igual a 10, el preprocesador ve #if 10 == 10 #if X == 10

#si está definido(MI_MACRO) #si está definido MI_MACRO

#define STR(s) #s

#define XSTR(s) STR(s) #define STR(s) #s #define FOO 4

#define GETTER(type, method, name) \  type get##method() const noexcept { \  return this->name; \  }#define SETTER(type, method, name) \  void set##method(type value) noexcept { \  this->name = value; \  }usando std :: string ;clase Estudiante { privado : string nombre ; int edad ; double promedio de calificaciones ; público : // constructores...GETTER ( cadena , Nombre , nombre ) SETTER ( cadena , Nombre , nombre ) GETTER ( entero , Edad , edad ) SETTER ( entero , Edad , edad ) GETTER ( doble , Gpa , gpa ) SETTER ( doble , Gpa , gpa )// más métodos... };

El procesamiento puede interrumpirse mediante la #errordirectiva. Por ejemplo:

#if RUBY_VERSION == 190 #error La versión 1.9.0 de Ruby no es compatible #endif

A partir de C23 ^{[ 14 ]} y C++23 , ^{[ 15 ]} se proporciona una directiva de advertencia, #warning, para imprimir un mensaje sin abortar. Algunos usos típicos son advertir sobre el uso de funcionalidad obsoleta . Por ejemplo:

Antes de C23 y C++23, esta directiva existía en muchos compiladores como una característica no estándar, como los compiladores C de GNU, Intel, Microsoft e IBM. Debido a que no era estándar, la macro de advertencia tenía diferentes formas:

// GNU, Intel e IBM #advertencia "No utilice ABC, que está obsoleto. Utilice XYZ en su lugar."// Microsoft #pragma message("No utilice ABC, que está obsoleto. Utilice XYZ en su lugar.")

La #pragmadirectiva está definida por lenguajes estándar, pero con pocos o ningún requisito de sintaxis después de su nombre, de modo que los compiladores tienen libertad para definir la sintaxis posterior y el comportamiento asociado. Por ejemplo, una directiva pragma se usa a menudo para permitir la supresión de mensajes de error, gestionar la depuración de la pila y el montón, etc.

C99 introdujo algunas pragmas estándar, con la forma #pragma STDC ..., que se utilizan para controlar la implementación de punto flotante. _Pragma(...)También se añadió la forma alternativa, similar a una macro.

Uno de los usos más populares de la #pragmadirectiva es #pragma once , que se comporta de la misma manera que una directiva #include , condensada en una sola directiva ubicada al principio del archivo. A pesar de no ser estándar, es compatible con la mayoría de los compiladores.

Muchas implementaciones no admiten trigrafos o no los reemplazan por defecto.

Algunos preprocesadores de Unix proporcionaban una función de aserción , que tiene poca similitud con las aserciones de la biblioteca estándar. ^{[ 16 ]}

GCC permite #include_nextencadenar encabezados con el mismo nombre. ^{[ 17 ]}

Por ejemplo, si se sobrescribe el archivo <stdio.h>, intentar incluir la biblioteca estándar <stdio.h>provocaría una recursión infinita de inclusión si se utiliza #include, ya que se volvería a incluir a sí mismo. #include_nextresuelve esto incluyendo el siguiente <stdio.h>encontrado.

// override_stdio/stdio.h #ifndef MY_STDIO_H #define MY_STDIO_H// Anulaciones personalizadas #define printf(...) my_custom_printf(__VA_ARGS__)// Incluir el siguiente stdio.h en la ruta de búsqueda #include_next <stdio.h> #endif

A diferencia de C y C++, Objective-C incluye una #importdirectiva que es similar #includepero que hace que un archivo se incluya solo una vez , eliminando la necesidad de protecciones de inclusión y #pragma once. Es una parte estándar de Objective-C.

#importar <Foundation/Foundation.h> #importar "MyClass.h"

En Microsoft Visual C++ (MSVC), también existe una #importdirectiva de preprocesador, utilizada para importar bibliotecas de tipos. ^{[ 18 ]} Es una directiva no estándar.

#import "C:\\Archivos de programa\\Archivos comunes\\Sistema\\ado\\msado15.dll" no_namespace rename("EOF", "ADOEOF")

No deben confundirse con la palabra clave de C++ import, que se utiliza para importar módulos de C++ (desde C++20 ) y no es una directiva del preprocesador.

La directiva nula, que consiste únicamente en el #carácter, solo en una sola línea, es una directiva no estándar en Microsoft Visual C++. No tiene ningún efecto. ^{[ 19 ]}

La #nullabledirectiva en C# se utiliza para habilitar y deshabilitar tipos de referencia anulables. Para habilitarlos, use #nullable enable, y #nullable disablepara deshabilitarlos.

# habilitar anulablecadena? nombre = null ; // OK cadena nombrecompleto = null ; // Advertencia: posible asignación nula# deshabilitar anulablecadena de prueba = null ; // Sin advertencia

Esta directiva no existe en C/C++.

Las directivas `expand` #regiony #endregion`contraer` en C# se utilizan para expandir/contraer secciones de código en entornos de desarrollo integrados (IDE) y no afectan la compilación del programa. Su uso principal es la organización y legibilidad del código.

usando el sistema ;#region Métodos auxiliaresvoid Log ( string mensaje ) { Console.WriteLine ( mensaje ) ; }​#fin de la región

Si bien esta directiva no existe en C/C++, MSVC y Visual Studio tienen en su lugar #pragma regiony #pragma endregion. ^{[ 20 ]} Por lo tanto, el código C++ equivalente sería:

usando std :: string_view ;#pragma region Métodos auxiliaresvoid log ( string_view message ) { std :: println ( message ); }#pragma endregion

C++/CLI tiene la #usingdirectiva, que se utiliza para importar metadatos a un programa desde un archivo de lenguaje intermedio de Microsoft (como un archivo .dll ). ^{[ 21 ]}

# usando < MyComponent.dll > # usando " AssemblyA.dll " # usando " AssemblyB.dll "usando el espacio de nombres Sistema ;public ref class B { public void Test ( A a ) { // ... } };int main ( array < String ^>^ args ) { A a ; B b ; B . Test ( a ); }

La sustitución de texto tiene un riesgo relativamente alto de causar un error de software en comparación con otras construcciones de programación. ^{[ 25 ] [ 26 ]}

En particular, las macros del preprocesador de C carecen de conciencia sintáctica y no logran preservar la estructura léxica, a diferencia de las macros sintácticas que se ven en lenguajes tipo Lisp , Scala ^{[ 27 ]} o Rust ^{[ 28 ]} .

#define MAX(a, b) (((a) > (b)) ? (a) : (b))

#define DOUBLE(x) 2 * x

#define DOUBLE(x) (2 * (x))

El preprocesador de C no es Turing-completo , pero se acerca bastante. Se pueden especificar cálculos recursivos, pero con un límite superior fijo en la cantidad de recursión realizada. ^{[ 29 ]} Sin embargo, el preprocesador de C no está diseñado para ser, ni funciona bien como, un lenguaje de programación de propósito general. Dado que el preprocesador de C no tiene características de otros preprocesadores, como macros recursivas, expansión selectiva según las comillas y evaluación de cadenas en condicionales, es muy limitado en comparación con un procesador de macros más general como m4 .

Durante mucho tiempo, una macro de preprocesador fue la forma preferida de definir un valor constante. Una alternativa siempre ha sido definir una constvariable, pero esto conlleva el consumo de memoria en tiempo de ejecución. Una construcción de lenguaje más reciente (desde C++11 y C23), constexprpermite declarar un valor constante en tiempo de compilación que no necesita consumir memoria en tiempo de ejecución. ^{[ 30 ]}

// Con preprocesador: #define MAX_NUMBER_OF_RETRIES 3 #define EARTH_GRAVITATIONAL_ACCELERATION 9.8// Usando constexpr: constexpr int MAX_NUMBER_OF_RETRIES = 3 ; constexpr double EARTH_GRAVITATIONAL_ACCELERATION = 9.8 ;

Durante mucho tiempo, una macro con comportamiento de función fue la única forma de definir un comportamiento similar al de una función sin generar sobrecarga en las llamadas a funciones en tiempo de ejecución. Gracias a la inlinepalabra clave `inline` y a los compiladores optimizadores que insertan código automáticamente, algunas funciones pueden invocarse sin sobrecarga en las llamadas.

// Con preprocesador: #define MAX(a, b) ((a) > (b) ? (a) : (b))// Con inline: inline constexpr auto max ( auto a , auto b ) noexcept { return ( a > b ) ? a : b ; }

La directiva include limita la estructura del código ya que solo permite incluir el contenido de un archivo en otro. Los lenguajes más modernos admiten un concepto de módulo que tiene símbolos públicos que otros módulos importan , en lugar de incluir el contenido del archivo. Muchos sostienen que el código resultante tiene menos repetición y es más fácil de mantener ya que solo hay un archivo para un módulo, no un encabezado y un cuerpo. C++20 agrega módulos y una importinstrucción que no se maneja a través del preprocesamiento. ^{[ 31 ] [ 32 ]} Los módulos en C++ compilan más rápido y enlazan más rápido que los encabezados tradicionales, ^{[ 33 ]} y eliminan la necesidad de guardas #include o #pragma once . Hasta C++26, , , y las palabras clave eran manejadas parcialmente por el preprocesador.importexportmodule

// Con include: #include "wikipedia/examples/utils.h"// Con importación: import wikipedia . examples . utils ;

Para bases de código que no pueden migrar a módulos de inmediato, C++ también ofrece "unidades de encabezado" como una característica, que permite importar archivos de encabezado de la misma manera que un módulo. A diferencia de los módulos, las unidades de encabezado pueden generar macros, lo que ofrece una mínima ruptura durante la migración. Las unidades de encabezado están diseñadas como una solución transitoria antes de migrar completamente a módulos. ^{[ 34 ]} Por ejemplo, se puede escribir en lugar de , o en lugar de . Paradójicamente, la mayoría de los sistemas de compilación, como CMake , no admiten actualmente esta característica.import<string>;#include<string>import"MyHeader.hpp";#include"MyHeader.hpp"

En Clang , se ofrece una característica de módulo no estándar para C , que permite importar encabezados como módulos. ^{[ 35 ]}