La sintaxis del lenguaje de programación C es el conjunto de reglas que rigen la escritura de software en C. Está diseñada para permitir programas que son extremadamente concisos, tienen una estrecha relación con el código objeto resultante y, sin embargo, proporcionan una abstracción de datos de nivel relativamente alto. . C fue el primer lenguaje de alto nivel de gran éxito para el desarrollo de sistemas operativos portátiles .
La sintaxis de C utiliza el principio de munch máximo .
El lenguaje de programación C representa números en tres formas: integral , real y complejo . Esta distinción refleja distinciones similares en la arquitectura del conjunto de instrucciones de la mayoría de las unidades centrales de procesamiento . Los tipos de datos integrales almacenan números en el conjunto de números enteros , mientras que los números reales y complejos representan números (o pares de números) en el conjunto de números reales en forma de punto flotante .
Todos los tipos de enteros C tienen signedvariantes unsigned. Si signedno unsignedse especifica explícitamente, en la mayoría de las circunstancias signedse supone. Sin embargo, por razones históricas, la llanura chares un tipo distinto de ambos signed chary unsigned char. Puede ser un tipo con signo o sin signo, según el compilador y el juego de caracteres (C garantiza que los miembros del juego de caracteres básico de C tengan valores positivos). Además, los tipos de campos de bits especificados como simples intpueden estar firmados o sin firmar, según el compilador.
Los tipos de enteros de C vienen en diferentes tamaños fijos, capaces de representar varios rangos de números. El tipo charocupa exactamente un byte (la unidad de almacenamiento direccionable más pequeña), que normalmente tiene 8 bits de ancho. (Aunque charpuede representar cualquiera de los caracteres "básicos" de C, es posible que se requiera un tipo más amplio para los conjuntos de caracteres internacionales). La mayoría de los tipos de enteros tienen variedades con y sin signo , designadas por las palabras clave signedy unsigned. Los tipos de enteros con signo pueden utilizar una representación en complemento a dos , complemento a uno o signo y magnitud . En muchos casos, existen múltiples formas equivalentes de designar el tipo; por ejemplo, y son sinónimos.signed short intshort
La representación de algunos tipos puede incluir bits de "relleno" no utilizados, que ocupan almacenamiento pero no están incluidos en el ancho. La siguiente tabla proporciona una lista completa de los tipos de enteros estándar y sus anchos mínimos permitidos (incluido cualquier bit de signo).
El chartipo es distinto de ambos signed chary unsigned char, pero se garantiza que tendrá la misma representación que uno de ellos. Los tipos _Booly long longestán estandarizados desde 1999 y es posible que no sean compatibles con compiladores de C más antiguos. _BoolGeneralmente se accede al tipo a través del typedefnombre booldefinido por el encabezado estándar stdbool.h.
En general, los anchos y el esquema de representación implementado para cualquier plataforma determinada se eligen en función de la arquitectura de la máquina, teniendo en cuenta la facilidad de importar el código fuente desarrollado para otras plataformas. El ancho del inttipo varía especialmente entre las implementaciones de C; a menudo corresponde al tamaño de palabra más "natural" para la plataforma específica. El encabezado estándar limites.h define macros para los valores mínimos y máximos representables de los tipos de enteros estándar implementados en cualquier plataforma específica.
Además de los tipos de enteros estándar, puede haber otros tipos de enteros "extendidos", que se pueden utilizar para typedefs en encabezados estándar. Para una especificación más precisa del ancho, los programadores pueden y deben usar typedefs del encabezado estándar stdint.h .
Las constantes enteras se pueden especificar en el código fuente de varias maneras. Los valores numéricos se pueden especificar como decimal (ejemplo: 1022), octal con cero ( 0) como prefijo ( 01776) o hexadecimal con 0x(cero x) como prefijo ( 0x3FE). Un carácter entre comillas simples (ejemplo: 'R'), llamado "constante de carácter", representa el valor de ese carácter en el conjunto de caracteres de ejecución, con tipo int. Excepto en el caso de las constantes de caracteres, el tipo de una constante entera está determinado por el ancho requerido para representar el valor especificado, pero siempre es al menos tan ancho como int. Esto se puede anular agregando una longitud explícita y/o un modificador de firma; por ejemplo, 12lutiene tipo unsigned long. No existen constantes enteras negativas, pero a menudo se puede obtener el mismo efecto utilizando un operador de negación unario " -".
El tipo enumerado en C, especificado con la enumpalabra clave, y a menudo llamado simplemente "enum" (generalmente pronunciado / ˈ iː n ʌ m / EE -num o / ˈ iː n uː m / EE -noom ), es un tipo diseñado para representan valores en una serie de constantes nombradas. Cada una de las constantes enumeradas tiene tipo int. Cada enumtipo en sí es compatible con charun tipo entero con o sin signo, pero cada implementación define sus propias reglas para elegir un tipo.
Algunos compiladores advierten si a un objeto con tipo enumerado se le asigna un valor que no es una de sus constantes. Sin embargo, a dicho objeto se le puede asignar cualquier valor en el rango de su tipo compatible, y enumse pueden usar constantes en cualquier lugar donde se espere un número entero. Por esta razón, enumlos valores se utilizan a menudo en lugar de #definedirectivas de preprocesador para crear constantes con nombre. Estas constantes son generalmente más seguras de usar que las macros, ya que residen dentro de un espacio de nombres de identificador específico.
Un tipo enumerado se declara con el enumespecificador y un nombre opcional (o etiqueta ) para la enumeración, seguido de una lista de una o más constantes contenidas entre llaves y separadas por comas, y una lista opcional de nombres de variables. Las referencias posteriores a un tipo enumerado específico utilizan la enumpalabra clave y el nombre de la enumeración. De forma predeterminada, a la primera constante de una enumeración se le asigna el valor cero y cada valor posterior se incrementa en uno sobre la constante anterior. También se pueden asignar valores específicos a las constantes en la declaración, y cualquier constante posterior sin valores específicos recibirá valores incrementados a partir de ese momento. Por ejemplo, considere la siguiente declaración:
colores de enumeración { ROJO , VERDE , AZUL = 5 , AMARILLO } color_pintura ; Esto declara el enum colorstipo; las intconstantes RED(cuyo valor es 0), GREEN(cuyo valor es uno mayor que RED, 1), BLUE(cuyo valor es el valor dado, 5) y YELLOW(cuyo valor es uno mayor que BLUE, 6); y la enum colorsvariable paint_color. Las constantes se pueden usar fuera del contexto de enum(donde se permite cualquier valor entero) y se pueden asignar valores distintos de las constantes a paint_coloro cualquier otra variable de tipo enum colors.
La forma de punto flotante se utiliza para representar números con un componente fraccionario. Sin embargo, no representan exactamente la mayoría de los números racionales; son más bien una aproximación cercana. Hay tres tipos de valores reales, indicados por sus especificadores: precisión simple ( float), precisión doble ( double) y precisión doble extendida ( long double). Cada uno de estos puede representar valores en una forma diferente, a menudo uno de los formatos de punto flotante IEEE .
Las constantes de punto flotante se pueden escribir en notación decimal , por ejemplo 1.23. La notación científica decimal se puede utilizar sumando eo Eseguido de un exponente decimal, también conocido como notación E , por ejemplo 1.23e2(que tiene el valor 1,23 × 10 2 = 123,0). Se requiere un punto decimal o un exponente (de lo contrario, el número se analiza como una constante entera). Las constantes hexadecimales de punto flotante siguen reglas similares, excepto que deben tener el prefijo 0xy usar po Ppara especificar un exponente binario, por ejemplo 0xAp-2(que tiene el valor 2,5, ya que A h × 2 −2 = 10 × 2 −2 = 10 ÷ 4 ). Tanto las constantes de punto flotante decimal como hexadecimal pueden tener el sufijo fo Fpara indicar una constante de tipo float, l(letra l) o Lpara indicar tipo long double, o dejarse sin sufijo para una doubleconstante.
El archivo de encabezado estándar float.hdefine los valores mínimo y máximo de los tipos de punto flotante de la implementación float, doubley long double. También define otros límites que son relevantes para el procesamiento de números de punto flotante.
Cada objeto tiene una clase de almacenamiento. Esto especifica básicamente la duración del almacenamiento, que puede ser estático (predeterminado para global), automático (predeterminado para local) o dinámico (asignado), junto con otras características (vinculación y sugerencia de registro).
malloc()y free().Las variables declaradas dentro de un bloque de forma predeterminada tienen almacenamiento automático, al igual que aquellas declaradas explícitamente con [nota 2] o especificadores de clase de almacenamiento. Los especificadores y sólo pueden usarse dentro de funciones y declaraciones de argumentos de funciones; como tal, el especificador siempre es redundante. Los objetos declarados fuera de todos los bloques y aquellos declarados explícitamente con el especificador de clase de almacenamiento tienen una duración de almacenamiento estático. El compilador inicializa las variables estáticas a cero de forma predeterminada .
autoregisterautoregisterautostatic
Los objetos con almacenamiento automático son locales del bloque en el que fueron declarados y se descartan cuando se sale del bloque. Además, registerel compilador puede dar mayor prioridad a los objetos declarados con la clase de almacenamiento para acceder a los registros ; aunque el compilador puede optar por no almacenar ninguno de ellos en un registro. Los objetos con esta clase de almacenamiento no se pueden utilizar con el operador unario dirección de ( &). Los objetos con almacenamiento estático persisten durante toda la duración del programa. De esta manera, una función puede acceder al mismo objeto a través de múltiples llamadas. Los objetos con una duración de almacenamiento asignada se crean y destruyen explícitamente con malloc, freey funciones relacionadas.
El externespecificador de clase de almacenamiento indica que el almacenamiento de un objeto se ha definido en otro lugar. Cuando se usa dentro de un bloque, indica que el almacenamiento ha sido definido mediante una declaración fuera de ese bloque. Cuando se usa fuera de todos los bloques, indica que el almacenamiento se ha definido fuera de la unidad de compilación. El externespecificador de clase de almacenamiento es redundante cuando se usa en una declaración de función. Indica que la función declarada se ha definido fuera de la unidad de compilación.
El especificador de clase de almacenamiento _Thread_local( thread_localen C++ , desde C23 , y en versiones anteriores de C si <threads.h>se incluye el encabezado), introducido en C11 , se utiliza para declarar una variable local de subproceso. Se puede combinar con statico externpara determinar la vinculación.
Tenga en cuenta que los especificadores de almacenamiento se aplican sólo a funciones y objetos; otras cosas, como las declaraciones de tipo y enumeración, son privadas para la unidad de compilación en la que aparecen. Los tipos, por otro lado, tienen calificadores (ver más abajo).
Los tipos pueden calificarse para indicar propiedades especiales de sus datos. El calificador de tipo constindica que un valor no cambia una vez que se ha inicializado. Intentar modificar un constvalor calificado genera un comportamiento indefinido, por lo que algunos compiladores de C los almacenan en rodata o (para sistemas integrados) en memoria de solo lectura (ROM). El calificador de tipo volatileindica a un compilador de optimización que no puede eliminar lecturas o escrituras aparentemente redundantes, ya que el valor puede cambiar incluso si no fue modificado por ninguna expresión o declaración, o pueden ser necesarias múltiples escrituras, como para I mapeado en memoria. /O .
Un tipo incompleto es una estructura o tipo de unión cuyos miembros aún no se han especificado, un tipo de matriz cuya dimensión aún no se ha especificado o el voidtipo (el voidtipo no se puede completar). No se puede crear una instancia de dicho tipo (se desconoce su tamaño), ni se puede acceder a sus miembros (ellos también son desconocidos); sin embargo, se puede utilizar el tipo de puntero derivado (pero no eliminar la referencia).
A menudo se utilizan con punteros, ya sea como declaraciones directas o externas. Por ejemplo, el código podría declarar un tipo incompleto como este:
estructura cosa * pt ; Esto se declara ptcomo un puntero struct thing y el tipo incompleto struct thing. Los punteros a datos siempre tienen el mismo ancho de bytes independientemente de a qué apunten, por lo que esta declaración es válida por sí misma (siempre que ptno se elimine la referencia). El tipo incompleto se puede completar más adelante en el mismo ámbito redeclarándolo:
estructura cosa { int num ; }; /* el tipo de estructura de cosa ahora está completo */ Los tipos incompletos se utilizan para implementar estructuras recursivas ; el cuerpo de la declaración de tipo podrá trasladarse a una etapa posterior en la unidad de traducción:
estructura typedef Bert Bert ; estructura typedef Wilma Wilma ; estructura Bert { Wilma * wilma ; }; estructura Wilma { Bert * bert ; }; Los tipos incompletos también se utilizan para ocultar datos ; el tipo incompleto se define en un archivo de encabezado y el cuerpo solo dentro del archivo fuente relevante.
En las declaraciones, el modificador de asterisco ( *) especifica un tipo de puntero. Por ejemplo, donde el especificador intse referiría al tipo de número entero, el especificador int*se refiere al tipo "puntero a número entero". Los valores de puntero asocian dos piezas de información: una dirección de memoria y un tipo de datos. La siguiente línea de código declara una variable de puntero a entero llamada ptr :
int * ptr ; Cuando se declara un puntero no estático, tiene un valor no especificado asociado. La dirección asociada con dicho puntero debe cambiarse mediante asignación antes de usarlo. En el siguiente ejemplo, ptr se configura para que apunte a los datos asociados con la variable a :
int a = 0 ; int * ptr = &a ; Para lograr esto, &se utiliza el operador "dirección de" (unario). Produce la ubicación de memoria del objeto de datos que sigue.
Se puede acceder a los datos señalados a través de un valor de puntero. En el siguiente ejemplo, la variable entera b se establece en el valor de la variable entera a , que es 10:
int a = 10 ; int * p ; p = &a ; int b = * p ; Para realizar esa tarea, se utiliza el operador unario de desreferencia , indicado por un asterisco (*). Devuelve los datos a los que apunta su operando, que debe ser de tipo puntero. Por tanto, la expresión * p denota el mismo valor que a . Eliminar la referencia a un puntero nulo es ilegal.
Las matrices se utilizan en C para representar estructuras de elementos consecutivos del mismo tipo. La definición de una matriz (de tamaño fijo) tiene la siguiente sintaxis:
matriz int [ 100 ]; que define una matriz llamada matriz para contener 100 valores del tipo primitivo int. Si se declara dentro de una función, la dimensión de la matriz también puede ser una expresión no constante, en cuyo caso se asignará memoria para el número especificado de elementos. En la mayoría de los contextos de uso posterior, una mención de la matriz de variables se convierte en un puntero al primer elemento de la matriz. El sizeofoperador es una excepción: sizeof arrayproduce el tamaño de toda la matriz (es decir, 100 veces el tamaño de an inty sizeof(array) / sizeof(int)devolverá 100). Otra excepción es el operador & (dirección de), que genera un puntero a toda la matriz, por ejemplo
int ( * ptr_to_array ) [ 100 ] = & matriz ; La función principal para acceder a los valores de los elementos de una matriz es el operador de subíndice de la matriz. Para acceder al elemento indexado por i de la matriz , la sintaxis sería array[i], que se refiere al valor almacenado en ese elemento de la matriz.
La numeración de subíndices de matriz comienza en 0 (consulte Indexación basada en cero ). Por lo tanto, el subíndice de matriz más grande permitido es igual al número de elementos de la matriz menos 1. Para ilustrar esto, considere una matriz declarada con 10 elementos; el primer elemento sería a[0]y el último elemento sería a[9].
C no proporciona ninguna posibilidad para la verificación automática de límites para el uso de la matriz. Aunque lógicamente el último subíndice de una matriz de 10 elementos sería 9, los subíndices 10, 11, etc. podrían especificarse accidentalmente, con resultados indefinidos.
Debido a que las matrices y los punteros son intercambiables, las direcciones de cada uno de los elementos de la matriz se pueden expresar en aritmética de punteros equivalente . La siguiente tabla ilustra ambos métodos para la matriz existente:
Dado que la expresión a[i]es semánticamente equivalente a *(a+i), que a su vez es equivalente a *(i+a), la expresión también se puede escribir como i[a], aunque esta forma rara vez se usa.
C99 estandarizó matrices de longitud variable (VLA) dentro del alcance del bloque. Estas variables de matriz se asignan en función del valor de un valor entero en tiempo de ejecución al ingresar a un bloque y se desasignan al final del bloque. [1] A partir de C11, ya no es necesario que el compilador implemente esta característica.
int n = ...; int a [ n ]; a [ 3 ] = 10 ; Esta sintaxis produce una matriz cuyo tamaño es fijo hasta el final del bloque.
Se pueden producir matrices cuyo tamaño se puede cambiar dinámicamente con la ayuda de la biblioteca estándar de C. La mallocfunción proporciona un método simple para asignar memoria. Se necesita un parámetro: la cantidad de memoria a asignar en bytes. Tras una asignación exitosa, mallocdevuelve un voidvalor de puntero genérico (), que apunta al comienzo del espacio asignado. El valor del puntero devuelto se convierte implícitamente a un tipo apropiado mediante asignación. Si no se pudo completar la asignación, mallocdevuelve un puntero nulo . Por lo tanto, el siguiente segmento tiene una función similar a la declaración deseada anterior:
#include <stdlib.h> /* declara malloc */ ... int * a = malloc ( n * sizeof * a ); a [ 3 ] = 10 ; El resultado es un "puntero a int" variable ( a ) que apunta al primero de nint objetos contiguos ; debido a la equivalencia entre matriz y puntero, esto se puede usar en lugar de un nombre de matriz real, como se muestra en la última línea. La ventaja de usar esta asignación dinámica es que la cantidad de memoria que se le asigna se puede limitar a lo que realmente se necesita en tiempo de ejecución, y esto se puede cambiar según sea necesario (usando la función de biblioteca estándar realloc).
Cuando la memoria asignada dinámicamente ya no es necesaria, debe liberarse nuevamente al sistema de ejecución. Esto se hace con una llamada a la freefunción. Se necesita un único parámetro: un puntero a la memoria previamente asignada. Este es el valor devuelto por una llamada anterior a malloc.
Como medida de seguridad, algunos programadores [ ¿quién? ] luego establezca la variable de puntero en NULL:
gratis ( un ); a = NULO ; Esto garantiza que nuevos intentos de eliminar la referencia al puntero, en la mayoría de los sistemas, bloquearán el programa. Si no se hace esto, la variable se convierte en un puntero colgante que puede provocar un error de uso después de la liberación. Sin embargo, si el puntero es una variable local, configurarlo en NULLno impide que el programa use otras copias del puntero. Los errores locales de uso después de la liberación suelen ser fáciles de reconocer para los analizadores estáticos . Por lo tanto, este enfoque es menos útil para punteros locales y se usa más a menudo con punteros almacenados en estructuras de larga duración. Sin embargo, en general, establecer indicadores NULLes una buena práctica [ ¿según quién? ] ya que permite al programador verificar NULLlos punteros antes de eliminar la referencia, lo que ayuda a prevenir fallas.
Recordando el ejemplo de la matriz, también se podría crear una matriz de tamaño fijo mediante asignación dinámica:
int ( * a ) [ 100 ] = malloc ( tamaño de * a ); ...Lo que produce un puntero a matriz.
El acceso al puntero a la matriz se puede realizar de dos maneras:
( * a )[ índice ];índice [ * a ];La iteración también se puede realizar de dos maneras:
para ( int i = 0 ; i < 100 ; i ++ ) ( * a )[ i ]; para ( int * i = a [ 0 ]; i < a [ 1 ]; i ++ ) * i ; La ventaja de utilizar el segundo ejemplo es que no se requiere el límite numérico del primer ejemplo, lo que significa que el puntero a la matriz podría ser de cualquier tamaño y el segundo ejemplo se puede ejecutar sin modificaciones.
Además, C admite matrices de múltiples dimensiones, que se almacenan en orden de fila principal . Técnicamente, los arreglos multidimensionales en C son solo arreglos unidimensionales cuyos elementos son arreglos. La sintaxis para declarar matrices multidimensionales es la siguiente:
int array2d [ FILAS ][ COLUMNAS ]; donde FILAS y COLUMNAS son constantes. Esto define una matriz bidimensional. Al leer los subíndices de izquierda a derecha, array2d es una matriz de longitud FILAS , cada elemento del cual es una matriz de COLUMNAS enteros.
Para acceder a un elemento entero en esta matriz multidimensional, se usaría
matriz2d [ 4 ][ 3 ]Nuevamente, leyendo de izquierda a derecha, se accede a la quinta fila y al cuarto elemento de esa fila. La expresión array2d[4]es una matriz, a la que luego le subíndicamos [3] para acceder al cuarto número entero.
Las matrices de dimensiones superiores se pueden declarar de manera similar.
Una matriz multidimensional no debe confundirse con una matriz de punteros a matrices (también conocida como vector de Iliffe o, a veces, matriz de matrices ). El primero es siempre rectangular (todos los subarreglos deben tener el mismo tamaño) y ocupa una región contigua de memoria. Este último es un conjunto unidimensional de punteros, cada uno de los cuales puede apuntar al primer elemento de un subconjunto en un lugar diferente de la memoria, y los subconjuntos no tienen que ser del mismo tamaño. Este último puede crearse mediante múltiples usos de malloc.
En C, los literales de cadena están entre comillas dobles ( ") (por ejemplo, "Hello world!") y se compilan en una matriz de los charvalores especificados con un código de carácter final nulo adicional (valor 0) para marcar el final de la cadena.
Los literales de cadena no pueden contener nuevas líneas incrustadas; esta proscripción simplifica un poco el análisis del lenguaje. Para incluir una nueva línea en una cadena, \nse puede utilizar el escape de barra invertida, como se muestra a continuación.
Hay varias funciones de biblioteca estándar para operar con datos de cadena (no necesariamente constantes) organizados como una matriz charusando este formato terminado en nulo; vea abajo.
La sintaxis literal de cadena de C ha sido muy influyente y se ha abierto camino en muchos otros lenguajes, como C++, Objective-C, Perl, Python, PHP, Java, JavaScript, C# y Ruby. Hoy en día, casi todos los lenguajes nuevos adoptan o se basan en la sintaxis de cadenas de estilo C. Los lenguajes que carecen de esta sintaxis tienden a preceder a C.
Debido a que ciertos caracteres no pueden ser parte directamente de una expresión de cadena literal, en su lugar se identifican mediante una secuencia de escape que comienza con una barra invertida ( \). Por ejemplo, las barras invertidas "This string contains \"double quotes\"."indican (al compilador) que el par interno de comillas está pensado como una parte real de la cadena, en lugar de la lectura predeterminada como un delimitador (punto final) de la cadena misma.
Se pueden utilizar barras invertidas para ingresar varios caracteres de control, etc., en una cadena:
El uso de otros escapes de barra invertida no está definido por el estándar C, aunque los proveedores de compiladores a menudo proporcionan códigos de escape adicionales como extensiones del lenguaje. Una de ellas es la secuencia de escape \epara el carácter de escape con valor hexadecimal ASCII 1B que no se agregó al estándar C debido a que falta representación en otros conjuntos de caracteres (como EBCDIC ). Está disponible en GCC , clang y tcc .
C tiene concatenación de cadenas literales , lo que significa que las cadenas literales adyacentes se concatenan en el momento de la compilación; esto permite dividir cadenas largas en varias líneas y también permite agregar literales de cadena resultantes de las definiciones del preprocesador de C y macros a las cadenas en el momento de la compilación:
printf ( __FILE__ ": %d: Hola " "mundo \n " , __LINE__ ); se expandirá a
printf ( "holamundo.c" ": %d: Hola " "mundo \n " , 10 ); que es sintácticamente equivalente a
printf ( "holamundo.c: %d: Hola mundo \n " , 10 ); Las constantes de caracteres individuales están entre comillas simples, por ejemplo 'A', y tienen tipo int(en C++, char). La diferencia es que "A"representa una matriz terminada en nulo de dos caracteres, 'A' y '\0', mientras que 'A'representa directamente el valor del carácter (65 si se usa ASCII). Se admiten los mismos escapes de barra invertida que para las cadenas, excepto que (por supuesto) "se puede usar válidamente como un carácter sin escapar, mientras que 'ahora se debe escapar.
Una constante de carácter no puede estar vacía (es decir, ''su sintaxis no es válida), aunque una cadena puede estarlo (todavía tiene el carácter de terminación nulo). Las constantes de varios caracteres (p. ej. 'xy') son válidas, aunque rara vez útiles: permiten almacenar varios caracteres en un número entero (p. ej., 4 caracteres ASCII pueden caber en un entero de 32 bits, 8 en uno de 64 bits). Dado que no se especifica el orden en el que se empaquetan los caracteres en un int(se deja que la implementación lo defina), el uso portátil de constantes de varios caracteres es difícil.
Sin embargo, en situaciones limitadas a una plataforma específica y la implementación del compilador, las constantes de varios caracteres encuentran su utilidad para especificar firmas. Un caso de uso común es OSType , donde la combinación de compiladores clásicos de Mac OS y su big-endianness inherente significa que los bytes en el número entero aparecen en el orden exacto de los caracteres definidos en el literal. De hecho, la definición de las "implementaciones" populares es consistente: en GCC, Clang y Visual C++ , '1234'se produce en ASCII. [3] [4]0x31323334
Al igual que los literales de cadena, las constantes de caracteres también se pueden modificar mediante prefijos; por ejemplo, L'A'tiene tipo wchar_ty representa el valor de carácter de "A" en la codificación de caracteres anchos.
Dado que el tipo chartiene 1 byte de ancho, un único charvalor normalmente puede representar como máximo 255 códigos de caracteres distintos, lo que no es suficiente para todos los caracteres que se utilizan en todo el mundo. Para proporcionar una mejor compatibilidad con los caracteres internacionales, el primer estándar C (C89) introdujo caracteres anchos (codificados en tipo wchar_t) y cadenas de caracteres anchas, que se escriben comoL"Hello world!"
Los caracteres anchos suelen tener 2 bytes (utilizando una codificación de 2 bytes como UTF-16 ) o 4 bytes (normalmente UTF-32 ), pero el estándar C no especifica el ancho wchar_t, dejando la elección al implementador. Microsoft Windows generalmente usa UTF-16, por lo que la cadena anterior tendría una longitud de 26 bytes para un compilador de Microsoft; el mundo Unix prefiere UTF-32, por lo que compiladores como GCC generarían una cadena de 52 bytes. Un ancho de 2 bytes wchar_tsufre la misma limitación que char, en el sentido de que ciertos caracteres (aquellos fuera del BMP ) no se pueden representar en un solo wchar_t; pero debe representarse mediante parejas sustitutas .
El estándar C original especificaba sólo funciones mínimas para operar con cadenas de caracteres anchas; En 1995, el estándar se modificó para incluir un soporte mucho más amplio, comparable al de charlas cuerdas. La mayoría de las funciones relevantes reciben el nombre de sus charequivalentes, con la adición de una "w" o la sustitución de "str" por "wcs"; se especifican en <wchar.h>y <wctype.h>contienen funciones de mapeo y clasificación de caracteres amplios.
El método ahora generalmente recomendado [nota 3] para admitir caracteres internacionales es a través de UTF-8 , que se almacena en matrices y se puede escribir directamente en el código fuente si se utiliza un editor UTF-8, porque UTF-8 es un ASCIIchar directo. extensión .
Una alternativa común wchar_tes utilizar una codificación de ancho variable , mediante la cual un carácter lógico puede extenderse a varias posiciones de la cadena. Las cadenas de ancho variable se pueden codificar en literales palabra por palabra, a riesgo de confundir al compilador, o utilizar barras invertidas numéricas (por ejemplo, "\xc3\xa9"para "é" en UTF-8). La codificación UTF-8 fue diseñada específicamente (según el Plan 9 ) para ser compatible con las funciones de cadena de biblioteca estándar; Las características de apoyo de la codificación incluyen la falta de nulos incrustados, la falta de interpretaciones válidas para las subsecuencias y la resincronización trivial. Es probable que las codificaciones que carezcan de estas características resulten incompatibles con las funciones estándar de la biblioteca; En tales casos, a menudo se utilizan funciones de cadena que reconocen la codificación.
Las cadenas , tanto constantes como variables, se pueden manipular sin utilizar la biblioteca estándar . Sin embargo, la biblioteca contiene muchas funciones útiles para trabajar con cadenas terminadas en nulo.
Las estructuras y uniones en C se definen como contenedores de datos que constan de una secuencia de miembros nombrados de varios tipos. Son similares a los registros en otros lenguajes de programación. Los miembros de una estructura se almacenan en ubicaciones consecutivas en la memoria, aunque el compilador puede insertar relleno entre o después de los miembros (pero no antes del primer miembro) para mayor eficiencia o como relleno necesario para una alineación adecuada de la arquitectura de destino. El tamaño de una estructura es igual a la suma de los tamaños de sus miembros, más el tamaño del acolchado.
Las uniones en C están relacionadas con estructuras y se definen como objetos que pueden contener (en diferentes momentos) objetos de diferentes tipos y tamaños. Son análogos a registros variantes en otros lenguajes de programación. A diferencia de las estructuras, todos los componentes de una unión se refieren a la misma ubicación en la memoria. De esta manera, una unión se puede utilizar en varios momentos para contener diferentes tipos de objetos, sin necesidad de crear un objeto separado para cada nuevo tipo. El tamaño de una unión es igual al tamaño de su tipo de componente más grande.
Las estructuras se declaran con la structpalabra clave y las uniones se declaran con la unionpalabra clave. La palabra clave especificadora va seguida de un nombre de identificador opcional, que se utiliza para identificar la forma de la estructura o unión. El identificador va seguido de la declaración de la estructura o cuerpo de la unión: una lista de declaraciones de miembros, contenidas entre llaves, con cada declaración terminada en un punto y coma. Finalmente, la declaración concluye con una lista opcional de nombres de identificadores, que se declaran como instancias de la estructura o unión.
Por ejemplo, la siguiente declaración declara una estructura denominada sque contiene tres miembros; también declarará una instancia de la estructura conocida como tee:
estructura s { int x ; flotar y ; carbón * z ; } camiseta ; Y la siguiente declaración declarará una unión similar nombrada uy una instancia de la misma nombrada n:
unión tu { int x ; flotar y ; carbón * z ; } norte ; Los miembros de estructuras y sindicatos no pueden tener un tipo de función o incompleto. Por lo tanto, los miembros no pueden ser una instancia de la estructura o unión que se declara (porque está incompleta en ese momento), pero pueden ser indicadores del tipo que se declara.
Una vez declarada y nombrada una estructura u organismo de unión, se puede considerar un nuevo tipo de datos utilizando el especificador structo union, según corresponda, y el nombre. Por ejemplo, la siguiente declaración, dada la declaración de estructura anterior, declara una nueva instancia de la estructura sdenominada r:
estructura s r ; También es común utilizar el typedefespecificador para eliminar la necesidad de la palabra clave structo unionen referencias posteriores a la estructura. El primer identificador después del cuerpo de la estructura se toma como el nuevo nombre para el tipo de estructura (en este contexto no se pueden declarar instancias de estructura). Por ejemplo, la siguiente declaración declarará un nuevo tipo conocido como s_type que contendrá alguna estructura:
estructura typedef {...} s_type ; Las declaraciones futuras pueden usar el especificador s_type (en lugar del structespecificador expandido...) para referirse a la estructura.
Se accede a los miembros utilizando el nombre de la instancia de una estructura o unión, un punto ( .) y el nombre del miembro. Por ejemplo, dada la declaración de tee anterior, se puede acceder al miembro conocido como y (de tipo ) utilizando la siguiente sintaxis:float
camiseta . yNormalmente se accede a las estructuras a través de punteros. Considere el siguiente ejemplo que define un puntero a tee , conocido como ptr_to_tee :
estructura s * ptr_to_tee = & tee ; Luego se puede acceder al miembro y de tee eliminando la referencia a ptr_to_tee y utilizando el resultado como operando izquierdo:
( * ptr_to_tee ). yLo cual es idéntico al más simple tee.yanterior siempre que ptr_to_tee apunte a tee . Debido a la precedencia del operador ("." es mayor que "*"), el más corto *ptr_to_tee.yes incorrecto para este propósito, por lo que se analiza como *(ptr_to_tee.y)y, por lo tanto, los paréntesis son necesarios. Como esta operación es común, C proporciona una sintaxis abreviada para acceder a un miembro directamente desde un puntero. Con esta sintaxis, el nombre de la instancia se reemplaza por el nombre del puntero y el punto se reemplaza por la secuencia de caracteres ->. Por tanto, el siguiente método para acceder a y es idéntico a los dos anteriores:
ptr_to_tee -> ySe accede a los miembros de los sindicatos de la misma manera.
Esto puede estar encadenado; por ejemplo, en una lista vinculada, se puede hacer referencia n->next->nextal segundo nodo siguiente (suponiendo que n->nextno sea nulo).
Asignar valores a miembros individuales de estructuras y uniones es sintácticamente idéntico a asignar valores a cualquier otro objeto. La única diferencia es que el valor l de la asignación es el nombre del miembro, al que se accede mediante la sintaxis mencionada anteriormente.
Una estructura también se puede asignar como unidad a otra estructura del mismo tipo. Las estructuras (y punteros a estructuras) también se pueden utilizar como parámetros de función y tipos de retorno.
Por ejemplo, la siguiente declaración asigna el valor de 74 (el punto del código ASCII para la letra 't') al miembro llamado x en la estructura tee , desde arriba:
camiseta . x = 74 ; Y la misma tarea, usando ptr_to_tee en lugar de tee , quedaría así:
ptr_to_tee -> x = 74 ; La tarea con los miembros de los sindicatos es idéntica.
Según el estándar C, las únicas operaciones legales que se pueden realizar en una estructura son copiarla, asignarla como una unidad (o inicializarla), tomar su dirección con la dirección del &operador unario () y acceder a sus miembros. . Los sindicatos tienen las mismas restricciones. Una de las operaciones implícitamente prohibidas es la comparación: las estructuras y uniones no se pueden comparar utilizando las funciones de comparación estándar de C ( ==, >, <, etc.).
C también proporciona un tipo especial de miembro conocido como campo de bits , que es un número entero con un número de bits especificado explícitamente. Un campo de bits se declara como miembro de una estructura (o unión) de tipo int, signed int, unsigned into _Bool, [nota 4] después del nombre del miembro mediante dos puntos ( :) y el número de bits que debe ocupar. El número total de bits en un campo de un solo bit no debe exceder el número total de bits en su tipo declarado (sin embargo, esto está permitido en C++, donde los bits adicionales se usan para relleno).
Como excepción especial a las reglas habituales de sintaxis de C, la implementación define si un campo de bits declarado como tipo int, sin especificar signedo unsigned, está firmado o sin firmar. Por lo tanto, se recomienda especificar explícitamente signedo unsigneden todos los miembros de la estructura para la portabilidad.
También se permiten campos sin nombre que constan solo de dos puntos seguidos de varios bits; Estos indican relleno . Se utiliza especificar un ancho de cero para un campo sin nombre para forzar la alineación con una nueva palabra. [5] Dado que todos los miembros de una unión ocupan la misma memoria, los campos de bits sin nombre de ancho cero no hacen nada en las uniones; sin embargo, los campos de bits sin nombre de ancho distinto de cero pueden cambiar el tamaño de la unión ya que tienen que caber en ella.
Los miembros de los campos de bits no tienen direcciones y, como tales, no se pueden utilizar con el &operador unario dirección de (). El sizeofoperador no puede aplicarse a campos de bits.
La siguiente declaración declara un nuevo tipo de estructura conocido como fy una instancia del mismo conocida como g. Los comentarios proporcionan una descripción de cada uno de los miembros:
estructura f { bandera int sin firmar : 1 ; /* una bandera de bit: puede estar activada (1) o desactivada (0) */ firmado int num : 4 ; /* un campo de 4 bits firmado; rango -7...7 o -8...7 */ int con signo : 3 ; /* 3 bits de relleno para redondear a 8 bits */ } g ; La inicialización predeterminada depende del especificador de clase de almacenamiento, descrito anteriormente.
Debido a la gramática del lenguaje, un inicializador escalar puede estar encerrado entre cualquier número de pares de llaves. Sin embargo, la mayoría de los compiladores emiten una advertencia si hay más de uno de esos pares.
int x = 12 ; int y = {23} ; _ //Legal, sin advertencia int z = { { 34 } }; //Legal, espera una advertencia Las estructuras, uniones y matrices se pueden inicializar en sus declaraciones utilizando una lista de inicializadores. A menos que se utilicen designadores, los componentes de un inicializador se corresponden con los elementos en el orden en que se definen y almacenan, por lo que todos los valores anteriores deben proporcionarse antes del valor de cualquier elemento en particular. Cualquier elemento no especificado se establece en cero (excepto las uniones). Mencionar demasiados valores de inicialización produce un error.
La siguiente declaración inicializará una nueva instancia de la estructura conocida como pi :
estructura s { int x ; flotar y ; carbón * z ; }; estructura s pi = { 3 , 3.1415 , "Pi" }; Los inicializadores designados permiten inicializar miembros por nombre, en cualquier orden y sin proporcionar explícitamente los valores anteriores. La siguiente inicialización es equivalente a la anterior:
estructura s pi = { . z = "Pi" , . x = 3 , . y = 3,1415 }; El uso de un designador en un inicializador mueve el "cursor" de inicialización. En el siguiente ejemplo, si MAXes mayor que 10, habrá algunos elementos con valor cero en medio de a; si es menor que 10, algunos de los valores proporcionados por los primeros cinco inicializadores serán anulados por los segundos cinco (si MAXes menor que 5, habrá un error de compilación):
int a [ MAX ] = { 1 , 3 , 5 , 7 , 9 , [ MAX -5 ] = 8 , 6 , 4 , 2 , 0 }; En C89 , se inicializó una unión con un valor único aplicado a su primer miembro. Es decir, la unión u definida anteriormente solo podría tener inicializado su miembro int x :
valor de unión u = { 3 }; Al utilizar un inicializador designado, el miembro que se va a inicializar no tiene que ser el primer miembro:
valor de unión u = { . y = 3,1415 }; Si una matriz tiene un tamaño desconocido (es decir, la matriz era de un tipo incompleto), el número de inicializadores determina el tamaño de la matriz y su tipo se completa:
int x [] = { 0 , 1 , 2 } ; Los designadores compuestos se pueden utilizar para proporcionar una inicialización explícita cuando las listas de inicializadores sin adornos puedan malinterpretarse. En el siguiente ejemplo, wse declara como una matriz de estructuras, cada estructura consta de un miembro a(una matriz de 3 int) y un miembro b(un int). El inicializador establece el tamaño de wen 2 y establece los valores del primer elemento de cada uno a:
estructura { int a [ 3 ], b ; } w [] = { [ 0 ]. a = {1} , [ 1 ] . un [ 0 ] = 2 }; Esto equivale a:
estructura { int a [ 3 ], b ; } w [] = { { { 1 , 0 , 0 }, 0 }, { { 2 , 0 , 0 }, 0 } }; No hay forma de especificar la repetición de un inicializador en el estándar C.
Es posible tomar prestada la metodología de inicialización para generar estructuras compuestas y literales de matriz:
// puntero creado a partir de una matriz literal. int * ptr = ( int []){ 10 , 20 , 30 , 40 }; // puntero a la matriz. flotador ( * foo ) [ 3 ] = & ( flotante []) { 0.5f , 1.f , -0.5f }; estructura s pi = ( estructura s ) { 3 , 3.1415 , "Pi" }; Los literales compuestos a menudo se combinan con inicializadores designados para hacer la declaración más legible: [1]
pi = ( estructura s ){ . z = "Pi" , . x = 3 , . y = 3,1415 }; C es un lenguaje de forma libre .
El estilo de refuerzo varía de un programador a otro y puede ser objeto de debate. Consulte Estilo de sangría para obtener más detalles.
En los elementos de esta sección, cualquier <declaración> se puede reemplazar con una declaración compuesta . Las declaraciones compuestas tienen la forma:
{ < opcional - declaración - lista > < opcional - declaración - lista > } y se utilizan como cuerpo de una función o en cualquier lugar donde se espere una sola declaración. La lista de declaraciones declara las variables que se utilizarán en ese ámbito , y la lista de declaraciones son las acciones que se realizarán. Los corchetes definen su propio alcance y las variables definidas dentro de esos corchetes se desasignarán automáticamente en el corchete de cierre. Las declaraciones y los enunciados se pueden mezclar libremente dentro de una declaración compuesta (como en C++ ).
C tiene dos tipos de declaraciones de selección : la ifdeclaración y la switchdeclaración .
La ifdeclaración tiene la forma:
if ( < expresión > ) < declaración1 > else < declaración2 > En la ifdeclaración, si el valor <expression>entre paréntesis es distinto de cero (verdadero), el control pasa a <statement1>. Si la elsecláusula está presente y <expression>es cero (falso), el control pasará a <statement2>. La else <statement2>parte es opcional y, si está ausente, un false <expression>simplemente resultará en omitir el archivo <statement1>. An elsesiempre coincide con el anterior no coincidente más cercano if; Se pueden usar llaves para anular esto cuando sea necesario o para mayor claridad.
La switchsentencia hace que el control se transfiera a una de varias sentencias dependiendo del valor de una expresión , la cual debe ser de tipo integral . La subsentencia controlada por un interruptor suele ser compuesta. Cualquier declaración dentro de la subdeclaración puede etiquetarse con una o más caseetiquetas, que constan de la palabra clave caseseguida de una expresión constante y luego dos puntos (:). La sintaxis es la siguiente:
switch ( < expresión > ) { case <etiqueta1> : < declaraciones 1 > case <etiqueta2> : < declaraciones 2 > break ; _ _ _ _ predeterminado : < declaraciones 3 > } No es posible que dos de las constantes de caso asociadas con el mismo interruptor tengan el mismo valor. Puede haber como máximo una defaultetiqueta asociada a un interruptor. Si ninguna de las etiquetas de caso es igual a la expresión entre paréntesis a continuación switch, el control pasa a la defaultetiqueta o, si no hay ninguna defaultetiqueta, la ejecución se reanuda justo después de toda la construcción.
Los interruptores pueden estar anidados; una etiqueta caseo defaultestá asociada a la más interna switchque la contiene. Las declaraciones de cambio pueden "fallar", es decir, cuando una sección del caso ha completado su ejecución, las declaraciones continuarán ejecutándose hacia abajo hasta que break;se encuentre una declaración. La caída es útil en algunas circunstancias, pero generalmente no es deseada. En el ejemplo anterior, si <label2>se alcanza, <statements 2>se ejecutan las sentencias y nada más entre llaves. Sin embargo, si <label1>se alcanza, se ejecutan ambos <statements 1>y <statements 2>ya que no hay forma breakde separar las dos declaraciones de caso.
Es posible, aunque inusual, insertar las switchetiquetas en los subbloques de otras estructuras de control. Ejemplos de esto incluyen el dispositivo de Duff y la implementación de corrutinas de Simon Tatham en Putty . [6]
C tiene tres formas de declaración de iteración :
hacer < declaración > mientras ( < expresión > ) ; mientras ( < expresión > ) < declaración > for ( < expresión > ; < expresión > ; < expresión > ) < declaración > En las declaraciones whiley do, la subdeclaración se ejecuta repetidamente siempre que el valor de la expressionsigue siendo distinto de cero (equivalente a verdadero). Con while, la prueba, incluidos todos los efectos secundarios de <expression>, ocurre antes de cada iteración (ejecución de <statement>); con do, la prueba ocurre después de cada iteración. Por lo tanto, una dodeclaración siempre ejecuta su subdeclaración al menos una vez, mientras que whilepuede no ejecutar la subdeclaración en absoluto.
La declaración:
para ( e1 ; e2 ; e3 ) s ; es equivalente a:
e1 ; mientras ( e2 ) { s ; continuo : e3 ; } excepto por el comportamiento de una continue;declaración (que en el forbucle salta a e3en lugar de e2). Si e2está en blanco, habría que sustituirlo por un 1.
forSe puede omitir cualquiera de las tres expresiones del bucle. Una segunda expresión faltante hace que la whileprueba sea siempre distinta de cero, creando un bucle potencialmente infinito.
Desde C99 , la primera expresión puede tomar la forma de una declaración, que normalmente incluye un inicializador, como por ejemplo:
for ( int i = 0 ; i < límite ; ++ i ) { // ... } El alcance de la declaración está limitado a la extensión del forbucle.
Las declaraciones de salto transfieren el control incondicionalmente. Hay cuatro tipos de declaraciones de salto en C: goto, continue, breaky return.
La gotodeclaración se ve así:
ir a <identificador> ; _ El identificador debe ser una etiqueta (seguida de dos puntos) ubicada en la función actual. El control se transfiere a la declaración etiquetada.
Una continuedeclaración puede aparecer sólo dentro de una declaración de iteración y hace que el control pase a la parte de continuación del bucle de la declaración de iteración más interna. Es decir, dentro de cada una de las declaraciones
while ( expresión ) { /* ... */ cont : ; } hacer { /* ... */ cont : ; } mientras ( expresión ); for ( expr1 ; expr2 ; expr3 ) { /* ... */ cont :; } una continuedeclaración no contenida dentro de una iteración anidada es lo mismo que goto cont.
La breakdeclaración se utiliza para finalizar un forbucle, whilebucle, dobucle o switchdeclaración. El control pasa a la declaración que sigue a la declaración terminada.
Una función regresa a su llamador mediante la returndeclaración. Cuando returnva seguido de una expresión, el valor se devuelve a la persona que llama como el valor de la función. Encontrar el final de la función equivale a a returnsin expresión. En ese caso, si se declara que la función devuelve un valor y la persona que llama intenta utilizar el valor devuelto, el resultado no está definido.
GCC extiende el lenguaje C con un &&operador unario que devuelve la dirección de una etiqueta. Esta dirección se puede almacenar en un void*tipo de variable y se puede usar más adelante en una gotoinstrucción. Por ejemplo, lo siguiente se imprime "hi "en un bucle infinito:
vacío * ptr = && J1 ; J1 : printf ( "hola" ); ir a * ptr ; Esta característica se puede utilizar para implementar una tabla de salto .
La definición de la función AC consta de un tipo de retorno ( voidsi no se devuelve ningún valor), un nombre único, una lista de parámetros entre paréntesis y varias declaraciones:
< tipo - retorno > nombre-función ( < lista - parámetros > ) { < sentencias > retorno < expresión de tipo tipo - retorno > ; } Una función con voidtipo sin retorno debe incluir al menos una returndeclaración. Los parámetros vienen dados por <parameter-list>, una lista de declaraciones de parámetros separadas por comas, donde cada elemento de la lista es un tipo de datos seguido de un identificador: <data-type> <variable-identifier>, <data-type> <variable-identifier>, ....
El tipo de retorno no puede ser un tipo de matriz o un tipo de función.
intf ( )[ 3 ]; // Error: función que devuelve una matriz int ( * g ())[ 3 ]; // OK: función que devuelve un puntero a una matriz. vacío h ()(); // Error: función que devuelve una función void ( * k ())(); // OK: función que devuelve un puntero de función Si no hay parámetros, se <parameter-list>puede dejar vacío o, opcionalmente, especificarse con una sola palabra void.
Es posible definir una función para que tome un número variable de parámetros proporcionando la ...palabra clave como último parámetro en lugar de un tipo de datos y un identificador de variable. Una función comúnmente utilizada que hace esto es la función de biblioteca estándar printf, que tiene la declaración:
int printf ( const char * , ...); La manipulación de estos parámetros se puede realizar utilizando las rutinas en el encabezado de la biblioteca estándar <stdarg.h>.
Un puntero a una función se puede declarar de la siguiente manera:
<retorno-tipo> ( * < función - nombre > ) ( < parámetro - lista > ) ; _ El siguiente programa muestra el uso de un puntero de función para seleccionar entre suma y resta:
#incluir <stdio.h> int ( * operación )( int x , int y ); int agregar ( int x , int y ) { retorno x + y ; } int restar ( int x , int y ) { return x - y ; } int principal ( int argc , char * args []) { int foo = 1 , barra = 1 ; operación = sumar ; printf ( "%d + %d = %d \n " , foo , barra , operación ( foo , barra )); operación = restar ; printf ( "%d - %d = %d \n " , foo , barra , operación ( foo , barra )); devolver 0 ; } Después del preprocesamiento, en el nivel más alto un programa C consta de una secuencia de declaraciones en el ámbito del archivo. Estos pueden dividirse en varios archivos fuente separados, que pueden compilarse por separado; Los módulos de objetos resultantes luego se vinculan junto con los módulos de soporte de tiempo de ejecución proporcionados por la implementación para producir una imagen ejecutable.
Las declaraciones introducen funciones , variables y tipos . Las funciones de C son similares a las subrutinas de Fortran o los procedimientos de Pascal .
Una definición es un tipo especial de declaración. Una definición de variable reserva almacenamiento y posiblemente lo inicializa, una definición de función proporciona su cuerpo.
Una implementación de C que proporciona todas las funciones de biblioteca estándar se denomina implementación alojada . Los programas escritos para implementaciones alojadas deben definir una función especial llamada main, que es la primera función llamada cuando un programa comienza a ejecutarse.
Las implementaciones alojadas inician la ejecución del programa invocando la mainfunción, que debe definirse siguiendo uno de estos prototipos:
int principal () {...} int principal ( vacío ) {...} int principal ( int argc , char * argv []) {...} int principal ( int argc , char ** argv ) {.. .} Las dos primeras definiciones son equivalentes (y ambas son compatibles con C++). Probablemente dependa de la preferencia individual cuál se usa (el estándar C actual contiene dos ejemplos de main()y dos de main(void), pero el borrador del estándar C++ usa main()). El valor de retorno de main(que debería ser int) sirve como estado de terminación devuelto al entorno del host.
El estándar C define valores de retorno 0que EXIT_SUCCESSindican éxito y EXIT_FAILUREque indican fracaso. ( EXIT_SUCCESSy EXIT_FAILUREestán definidos en <stdlib.h>). Otros valores de retorno tienen significados definidos por la implementación; por ejemplo, en Linux , un programa eliminado por una señal genera un código de retorno del valor numérico de la señal más 128.
Un programa en C mínimamente correcto consiste en una mainrutina vacía, que no acepta argumentos y no hace nada:
int principal ( vacío ){} Como no returnhay ninguna declaración presente, maindevuelve 0 al salir. [1] (Ésta es una característica de caso especial introducida en C99 que se aplica únicamente a main.)
La mainfunción normalmente llamará a otras funciones para ayudarla a realizar su trabajo.
Algunas implementaciones no están alojadas, generalmente porque no están diseñadas para usarse con un sistema operativo . Estas implementaciones se denominan independientes en el estándar C. Una implementación independiente es libre de especificar cómo maneja el inicio del programa; en particular, no es necesario que requiera un programa para definir una mainfunción.
Las funciones pueden ser escritas por el programador o proporcionadas por bibliotecas existentes. Las interfaces para este último generalmente se declaran incluyendo archivos de encabezado (con la #include directiva de preprocesamiento ) y los objetos de la biblioteca se vinculan a la imagen ejecutable final. Ciertas funciones de la biblioteca, como printf, están definidas por el estándar C; éstas se conocen como funciones de biblioteca estándar .
Una función puede devolver un valor a la persona que llama (generalmente otra función C o el entorno de alojamiento de la función main). La printffunción mencionada anteriormente devuelve cuántos caracteres se imprimieron, pero este valor a menudo se ignora.
En C, los argumentos se pasan a funciones por valor , mientras que otros lenguajes pueden pasar variables por referencia . Esto significa que la función receptora obtiene copias de los valores y no tiene forma directa de alterar las variables originales. Para que una función altere una variable pasada desde otra función, la persona que llama debe pasar su dirección (un puntero a ella), que luego se puede desreferenciar en la función receptora. Consulte Consejos para obtener más información.
vacío incInt ( int * y ) { ( * y ) ++ ; // Aumenta el valor de 'x', en 'principal' a continuación, en uno } int principal ( vacío ) { int x = 0 ; incInt ( & x ); // pasa una referencia a la var 'x' return 0 ; } La función scanf funciona de la misma manera:
intx ; _ scanf ( "%d" , & x ); Para pasar un puntero editable a una función (por ejemplo, con el fin de devolver una matriz asignada al código de llamada), debe pasar un puntero a ese puntero: su dirección.
#incluir <stdio.h> #incluir <stdlib.h> void allocate_array ( int ** const a_p , const int A ) { /* asignar matriz de A ints asignando a *a_p altera la 'a' en main() */ * a_p = malloc ( sizeof ( int ) * A ); } int principal ( vacío ) { int * a ; /* crea un puntero a una o más entradas, esta será la matriz */ /* pasa la dirección de 'a' */ allocate_array ( &a , 42 ); /* 'a' ahora es una matriz de longitud 42 y se puede manipular y liberar aquí */ gratis ( un ); devolver 0 ; } El parámetro int **a_pes un puntero a un puntero a an int, que es la dirección del puntero pdefinido en la función principal en este caso.
Los parámetros de función de tipo matriz pueden, a primera vista, parecer una excepción a la regla de paso por valor de C. El siguiente programa imprimirá 2, no 1:
#incluir <stdio.h> void setArray ( int matriz [], int índice , int valor ) { matriz [ índice ] = valor ; } int principal ( vacío ) { int a [ 1 ] = {1} ; _ setArray ( a , 0 , 2 ); printf ( "a[0]=%d \n " , a [ 0 ]); devolver 0 ; } Sin embargo, existe una razón diferente para este comportamiento. De hecho, un parámetro de función declarado con un tipo de matriz se trata como uno declarado como un puntero. Es decir, la declaración anterior de setArrayequivale a lo siguiente:
void setArray ( int * matriz , int índice , int valor ) Al mismo tiempo, las reglas de C para el uso de matrices en expresiones hacen que el valor de aen la llamada a setArrayse convierta en un puntero al primer elemento de la matriz a. Por lo tanto, de hecho esto sigue siendo un ejemplo de paso por valor, con la salvedad de que es la dirección del primer elemento de la matriz la que se pasa por valor, no el contenido de la matriz.
Desde C99, el programador puede especificar que una función tome una matriz de cierto tamaño usando la palabra clave static. En void setArray(int array[static 4], int index, int value)el primer parámetro debe haber un puntero al primer elemento de una matriz de longitud al menos 4. También es posible agregar calificadores ( const, volatiley restrict) al tipo de puntero al que se convierte la matriz colocándolos entre paréntesis.
Las siguientes palabras están reservadas y no pueden usarse como identificadores:
Las implementaciones pueden reservar otras palabras clave, como asm, aunque las implementaciones normalmente proporcionan palabras clave no estándar que comienzan con uno o dos guiones bajos.
Los identificadores C distinguen entre mayúsculas y minúsculas (por ejemplo, foo, FOOy Fooson los nombres de diferentes objetos). Algunos enlazadores pueden asignar identificadores externos a un solo caso, aunque esto es poco común en la mayoría de los enlazadores modernos.
El texto que comienza con el token /* se trata como un comentario y se ignora. El comentario termina en el siguiente */; puede ocurrir dentro de expresiones y puede abarcar varias líneas. La omisión accidental del terminador de comentarios es problemática porque el terminador de comentarios construido correctamente del siguiente comentario se utilizará para terminar el comentario inicial y todo el código entre los comentarios se considerará un comentario. Los comentarios de estilo C no se anidan; es decir, colocar accidentalmente un comentario dentro de otro comentario tiene resultados no deseados:
/*Esta línea será ignorada./*Aquí se puede producir una advertencia del compilador. Estas líneas también serán ignoradas.El token de apertura del comentario anterior no inició un nuevo comentario,y el token de cierre de comentario a continuación cerrará el comentario iniciado en la línea 1.*/Esta línea y la línea debajo de ella no serán ignoradas . Es probable que ambos produzcan errores de compilación . */Los comentarios de línea de estilo C++ comienzan //y se extienden hasta el final de la línea. Este estilo de comentario se originó en BCPL y se convirtió en sintaxis C válida en C99 ; no está disponible en el K&R C original ni en ANSI C :
// esta línea será ignorada por el compilador/* estas líneas serán ignoradas por el compilador */x = * p /*q; /* este comentario comienza después de la 'p' */ Los parámetros proporcionados en una línea de comando se pasan a un programa C con dos variables predefinidas: el recuento de los argumentos de la línea de comando y los argumentosargc individuales como cadenas de caracteres en la matriz de punteros . Entonces el comando:argv
mifiltro p1 p2 p3
resulta en algo como:
Si bien las cadenas individuales son matrices de caracteres contiguos, no hay garantía de que las cadenas se almacenen como un grupo contiguo.
El nombre del programa, argv[0]puede ser útil al imprimir mensajes de diagnóstico o para hacer que un binario sirva para múltiples propósitos. Se puede acceder a los valores individuales de los parámetros con argv[1], argv[2]y argv[3], como se muestra en el siguiente programa:
#incluir <stdio.h> int main ( int argc , char * argv []) { printf ( "argc \t = %d \n " , argc ); for ( int i = 0 ; i < argc ; i ++ ) printf ( "argv[%i] \t = %s \n " , i , argv [ i ]); } En cualquier expresión razonablemente compleja, surge la elección del orden en el que evaluar las partes de la expresión: puede evaluarse en el orden , , , , o en el orden , , , . Formalmente, un compilador de C conforme puede evaluar expresiones en cualquier orden entre puntos de secuencia (esto permite al compilador realizar cierta optimización). Los puntos de secuencia están definidos por:(1+1)+(3+3)(1+1)+(3+3)(2)+(3+3)(2)+(6)(8)(1+1)+(3+3)(1+1)+(6)(2)+(6)(8)
&&, que se puede leer y luego ) y lógico o ( ||, que se puede leer o si no ).?:): este operador evalúa primero su primera subexpresión y luego la segunda o la tercera (nunca ambas) en función del valor de la primera.Las expresiones anteriores a un punto de secuencia siempre se evalúan antes que aquellas posteriores a un punto de secuencia. En el caso de evaluación de cortocircuito, es posible que la segunda expresión no se evalúe dependiendo del resultado de la primera expresión. Por ejemplo, en la expresión , si el primer argumento se evalúa como distinto de cero (verdadero), el resultado de toda la expresión no puede ser más que verdadero, por lo que no se evalúa. De manera similar, en la expresión , si el primer argumento se evalúa como cero (falso), el resultado de toda la expresión no puede ser más que falso, por lo que no se evalúa.(a() || b())b()(a() && b())b()
Los argumentos de una llamada a una función se pueden evaluar en cualquier orden, siempre y cuando todos estén evaluados en el momento en que se ingresa la función. La siguiente expresión, por ejemplo, tiene un comportamiento indefinido:
printf ( "%s %s \n " , argv [ i = 0 ], argv [ ++ i ]); Un aspecto del estándar C (no exclusivo de C) es que se dice que el comportamiento de cierto código es "indefinido". En la práctica, esto significa que el programa producido a partir de este código puede hacer cualquier cosa, desde funcionar como pretendía el programador hasta fallar cada vez que se ejecuta.
Por ejemplo, el siguiente código produce un comportamiento indefinido, porque la variable b se modifica más de una vez sin que intervenga ningún punto de secuencia:
#incluir <stdio.h> int principal ( vacío ) { int b = 1 ; int a = b ++ + b ++ ; printf ( "%d \n " , a ); } Debido a que no hay un punto de secuencia entre las modificaciones de b en " b ++ + b ++", es posible realizar los pasos de evaluación en más de un orden, lo que da como resultado una declaración ambigua. Esto se puede solucionar reescribiendo el código para insertar un punto de secuencia con el fin de imponer un comportamiento inequívoco, por ejemplo:
a = b ++ ; a += b ++ ; long longmodificador se introdujo en el estándar C99 .