Sintaxis de C

Los tipos enteros 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 suele tener 8 bits de ancho. (Aunque charpuede representar cualquier carácter "básico", puede ser necesario un tipo más amplio para conjuntos de caracteres internacionales). La mayoría de los tipos enteros tienen variedades con y sin signo , designadas por las palabras clave signedy unsigned. Los tipos enteros con signo siempre usan la representación de complemento a dos , desde C23 ^{[ 3 ]} (y en la práctica antes; en versiones anteriores a C23 la representación podría haber sido alternativamente el complemento a uno , o signo y magnitud , pero en la práctica ese no ha sido el caso durante décadas en el hardware moderno). En muchos casos, hay 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 espacio de almacenamiento pero no se incluyen en el ancho. La siguiente tabla enumera los tipos enteros utilizando el nombre más corto posible e indicando el ancho mínimo en bits.

El chartipo es distinto de y signed char, unsigned charpero se garantiza que tendrá la misma representación que uno de ellos. Los tipos _Booly están estandarizados desde 1999 y es posible que no sean compatibles con compiladores más antiguos. El tipo se suele acceder mediante el nombre definido por el encabezado estándar <stdbool.h> , sin embargo, desde C23 el tipo se ha renombrado y se ha descontinuado.long long_Booltypedefbool_Boolbool<stdbool.h>

En general, el ancho y el esquema de representación implementados para cada plataforma se eligen en función de la arquitectura de la máquina, teniendo en cuenta la facilidad de importación del código fuente desarrollado para otras plataformas. El ancho del inttipo varía especialmente entre traductores; a menudo corresponde al tamaño de palabra más "natural" para una plataforma. El archivo de cabecera estándar <limits.h> define macros para los valores mínimos y máximos representables de los tipos enteros estándar implementados en cada plataforma específica.

Además de los tipos enteros estándar, puede haber otros tipos enteros "extendidos", que se pueden usar para typedefs en los 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 pueden especificarse en el código fuente de varias maneras. Los valores numéricos pueden especificarse 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 para las constantes de carácter, 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 puede ser anulado agregando un modificador explícito de longitud y/o signo; por ejemplo, 12lutiene tipo unsigned long. No hay constantes enteras negativas, pero el mismo efecto a menudo puede obtenerse usando un operador de negación unario " -".

El tipo enumerado , 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 representar valores a través de una serie de constantes con nombre. Cada una de las constantes enumeradas tiene el tipo int. Cada enumtipo en sí es compatible con charo un 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 de tipo enumerado se le asigna un valor que no es una de sus constantes. Sin embargo, a dicho objeto se le pueden asignar valores dentro del rango de su tipo compatible, y enumlas constantes se pueden usar en cualquier lugar donde se espere un entero. Por esta razón, enuma menudo se utilizan valores en lugar de #definedirectivas de preprocesador para crear constantes con nombre. Estas constantes son generalmente más seguras que las macros, ya que residen dentro de un espacio de nombres de identificadores específico.

Un tipo enumerado se declara con el enumespecificador y un nombre (o etiqueta ) opcional para la enumeración, seguido de una lista de una o más constantes 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. Por defecto, a la primera constante de una enumeración se le asigna el valor cero, y cada valor subsiguiente se incrementa en uno con respecto a la constante anterior. También se pueden asignar valores específicos a las constantes en la declaración, y a partir de ese momento, a cualquier constante subsiguiente sin valores específicos se le asignarán valores incrementados. Por ejemplo, considere la siguiente declaración:

enum Color { ROJO , VERDE , AZUL = 5 , AMARILLO } color_pintura ;

Esto declara el enum Colortipo; 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 Colorvariable 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_color, o a cualquier otra variable de tipo enum Color.

A diferencia de C++, las enumeraciones en C no tienen ámbito, ya que C no tiene el concepto de espacios de nombres. En C, enumlas enumeraciones se pueden convertir implícitamente a tipos numéricos, lo cual no es seguro en cuanto a tipos.

typedef enum Color { ROJO , NARANJA , AMARILLO , VERDE , AZUL , ÍNDIGO , VIOLETA } Color ;Color c = ROJO ; // en C Color d = Color :: ROJO ; // en C++, pero no en C

Desde C23, es posible especificar manualmente el tipo subyacente para el enum, como en C++.

enum CardSuit : char { CORAZONES , TRÉBOLES , PICAS , DIAMANTES };

La notación de punto flotante se utiliza para representar números con una parte fraccionaria. Sin embargo, no representa la mayoría de los números racionales con exactitud; en cambio, es una aproximación cercana. Existen tres tipos estándar de valores reales, indicados por sus especificadores (y desde C23, tres tipos decimales adicionales): precisión simple ( float), precisión doble ( double) y precisión doble extendida ( long double). Cada uno de estos puede representar valores en un formato diferente, a menudo uno de los formatos de punto flotante IEEE .

Las constantes de punto flotante pueden escribirse en notación decimal , p. ej 1.23. . La notación científica decimal puede usarse agregando eo Eseguido de un exponente decimal, también conocido como notación E , p. ej . 1.23e2(que tiene el valor 1.23 × 10 ² = 123.0). Se requiere un punto decimal o un exponente (de lo contrario, el número se analiza como una constante entera). Las constantes de punto flotante hexadecimales siguen reglas similares, excepto que deben ir precedidas de 0xy usar po Ppara especificar un exponente binario, p. ej. 0xAp-2(que tiene el valor 2.5, ya que A _h × 2 ⁻² = 10 × 2 ⁻² = 10 ÷ 4). Tanto las constantes de punto flotante decimales como hexadecimales pueden ir sufijadas por fo Fpara indicar una constante de tipo float, por l(letra l) o Lpara indicar el tipo long double, o dejarse sin sufijo para una doubleconstante.

El archivo de cabecera estándar <float.h> define los valores mínimo y máximo de los tipos de punto flotante de la implementación , , y . También define otros límites que son relevantes para el procesamiento de números de punto flotante.floatdoublelong double

C23 introduce tres tipos de punto flotante reales decimales_Decimal32 (a diferencia de los binarios) adicionales: , _Decimal64, y _Decimal128.

NOTA: C no especifica una base para float, double, y long double. Una implementación puede elegir que la representación de float, double, y long doublesea la misma que la de los tipos de punto flotante decimal. ^{[ 4 ]}

A pesar de ello, la base históricamente ha sido binaria (base 2), lo que significa que números como 1/2 o 1/4 son exactos, pero no 1/10, 1/100 o 1/3. Con el punto flotante decimal, todos los mismos números son exactos, además de números como 1/10 y 1/100, pero aún no, por ejemplo, 1/3. Ninguna implementación conocida opta por la base decimal para los tipos que antes se sabía que eran binarios. Dado que la mayoría de las computadoras ni siquiera tienen el hardware para los tipos decimales, y las pocas que sí lo tienen (por ejemplo, las computadoras centrales de IBM desde el IBM System z10 ), pueden usar los tipos explícitamente decimales.

Cuando se declara un puntero no estático, este tiene un valor no especificado. Si se intenta desreferenciarlo sin asignarle previamente un valor, el comportamiento será indefinido.

El &operador especifica la dirección del objeto de datos a continuación. En el siguiente ejemplo, ptrse le asigna la dirección de a:

int a = 0 ; int * ptr = &a a ;

Un asterisco delante del nombre de una variable (cuando no está en una declaración o expresión matemática) desreferencia un puntero para permitir el acceso al valor al que apunta. En el siguiente ejemplo, la variable entera bse establece al valor de la variable entera a, que es 10:

int a = 10 ; int * p ; p = &a a ; int b = * p ;

Los arreglos almacenan elementos consecutivos del mismo tipo. El siguiente código declara un arreglo de 100 elementos, llamado a, de tipo int.

int a [ 100 ];

Si se declara fuera de una función (de forma global), el tamaño debe ser un valor constante. Si se declara dentro de una función, el tamaño del array puede ser una expresión no constante.

El número de elementos está disponible como , pero si el valor se pasa a otra función, el número de elementos no está disponible a través de la variable de parámetro formal.sizeof(a)/sizeof(int)

La principal herramienta para acceder a los elementos de un array es el operador de subíndice. Por ejemplo, a[i]accede al elemento en el índice idel array a. La indexación del array comienza en 0 , por lo que el último índice es igual al número de elementos menos 1. Dado que el estándar no contempla la comprobación de límites de indexación , especificar un índice fuera de rango produce un comportamiento indefinido.

Debido a que los arreglos y los punteros son intercambiables, la dirección de cada elemento se puede expresar mediante aritmética de punteros . La siguiente tabla ilustra ambos métodos para el mismo arreglo:

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 se usa raramente.

C99 estandarizó el arreglo de longitud variable (VLA) en el ámbito de bloque, que producía un arreglo cuyo tamaño dependía de la información de tiempo de ejecución (no de un valor constante), pero con un tamaño fijo hasta el final del bloque. ^{[ 2 ]} A partir de C11 , esta característica ya no requiere ser implementada por el compilador.

int n = 20 ; // n puede ser cualquier valor arbitrario int a [ n ]; a [ 3 ] = 10 ;

El lenguaje admite matrices multidimensionales , almacenadas en orden de filas, que es esencialmente una matriz unidimensional cuyos elementos son matrices. Dado que ROWS y COLUMNS son constantes, la siguiente declaración crea una matriz bidimensional de longitud ROWS , donde cada elemento es una matriz de enteros COLUMNS .

int array2d [ FILAS ][ COLUMNAS ];

El siguiente es un ejemplo de cómo acceder a un elemento entero:

array2d [ 4 ][ 3 ]

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, que luego se indexa con [3] para acceder al cuarto entero.

Las matrices de dimensiones superiores se pueden declarar de manera similar.

No se debe confundir una matriz multidimensional con una matriz de punteros a matrices (también conocida como vector de Iliffe o, a veces, matriz de matrices ). La primera es siempre rectangular (todas las submatrices deben tener el mismo tamaño) y ocupa una región contigua de memoria. La segunda es una matriz unidimensional de punteros, cada uno de los cuales puede apuntar al primer elemento de una submatriz ubicada en una posición diferente de la memoria, y las submatrices no tienen por qué tener el mismo tamaño.

Una cadena literal es un texto de código rodeado de comillas dobles, como por ejemplo "Hello world!". Una cadena literal se compila en una matriz de los charvalores especificados con un carácter nulo de terminación para marcar el final de la cadena.

El lenguaje admite la concatenación de literales de cadena : los literales de cadena adyacentes se tratan como unidos en tiempo de compilación. Esto permite dividir cadenas largas en varias líneas y también permite agregar literales de cadena de macros de preprocesador a cadenas en tiempo de compilación. Por ejemplo, el código fuente:

printf ( __FILE__ ": %d: Hola " "mundo \n " );

se convierte en lo siguiente después de que el preprocesador se expande __FILE__:

printf ( "helloworld.c" ": %d: Hola " "mundo \n " );

lo cual es equivalente a:

printf ( "helloworld.c: %d: Hola mundo \n " );

El literal de carácter, llamado constante de carácter, está entre comillas simples, por ejemplo 'A', , y tiene el tipo int. Para ilustrar la diferencia entre un literal de cadena y una constante de carácter, considere que "A"son dos caracteres, 'A'y '\0', mientras que 'A'representa un solo carácter (65 en ASCII).

Una constante de caracteres no puede estar vacía (es decir, ''la sintaxis es inválida). Las constantes de varios caracteres (por ejemplo, 'xy') son válidas, aunque rara vez útiles: permiten almacenar varios caracteres en un entero (por ejemplo, 4 caracteres ASCII caben en un entero de 32 bits, 8 en uno de 64 bits). Dado que el orden en que se empaquetan los caracteres en una constante intno está especificado (queda a criterio de la implementación), el uso portable de constantes de varios caracteres es difícil.

Sin embargo, en situaciones limitadas a una plataforma específica y a la implementación del compilador, las constantes multicaracteres sí se utilizan para especificar firmas. Un caso de uso común es OSType , donde la combinación de los compiladores de Mac OS clásico y su inherente big-endianidad implica que los bytes del entero aparecen en el orden exacto de los caracteres definidos en el literal. La definición de las implementaciones más populares es, de hecho, consistente: en GCC, Clang y Visual C++ , '1234'produce bajo ASCII. ^{[ 7 ] [ 8 ]}0x31323334

Al igual que los literales de cadena, las constantes de caracteres también pueden modificarse mediante prefijos; por ejemplo, L'A'tiene el tipo wchar_ty representa el valor del carácter "A" en la codificación de caracteres anchos.

Los caracteres de control no pueden incluirse directamente en una cadena o literal de carácter. En su lugar, pueden codificarse mediante una secuencia de escape que comienza con una barra invertida ( \). Por ejemplo, las barras invertidas en "This string contains \"double quotes\"."indican que el par de comillas internas se consideran parte de la cadena, en lugar de interpretarse como un delimitador (punto final) de la misma.

Las secuencias de escape incluyen:

El uso de otras secuencias de escape con barra invertida no está definido por el estándar, aunque los compiladores suelen proporcionar códigos de escape adicionales como extensiones del lenguaje. Por ejemplo, la secuencia de escape \epara el carácter de escape con valor hexadecimal ASCII 1B, que no se añadió al estándar por carecer de representación en otros conjuntos de caracteres (como EBCDIC ), está disponible en GCC , clang y tcc .

Tenga en cuenta que la función de la biblioteca estándar printf()se utiliza %%para representar el %carácter literal.

Dado que el tipo chartiene un ancho de 1 byte, un solo charvalor normalmente puede representar como máximo 255 códigos de caracteres distintos, lo cual no es suficiente para todos los caracteres diferentes que se utilizan en todo el mundo. Para brindar un mejor soporte para los caracteres internacionales, el primer estándar (C89) introdujo caracteres anchos (codificados en el tipo wchar_t) y cadenas de caracteres anchos, que se escriben comoL"Hello world!"

Los caracteres anchos suelen ser de 2 bytes (usando una codificación de 2 bytes como UTF-16 ) o de 4 bytes (normalmente UTF-32 ), pero el estándar C no especifica el ancho para wchar_t, dejando la elección al implementador. Microsoft Windows generalmente usa UTF-16, por lo que la cadena anterior tendría 26 bytes de longitud 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 (los que están fuera del BMP ) no se pueden representar en un solo wchar_t, y deben representarse usando pares sustitutos .

El estándar original especificaba solo funciones mínimas para operar con cadenas de caracteres anchos; en 1995, el estándar se modificó para incluir un soporte mucho más extenso, comparable al de las charcadenas. Las funciones relevantes se nombran en su mayoría según sus charequivalentes, con la adición de una "w" o la sustitución de "str" ​​por "wcs"; se especifican en <wchar.h>, que <wctype.h>contiene funciones de clasificación y mapeo de caracteres anchos.

El método generalmente recomendado ahora ^{[ 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 una extensiónchar directa de ASCII .

Una alternativa común es wchar_tusar una codificación de ancho variable , donde un carácter lógico puede extenderse a lo largo de varias posiciones de la cadena. Las cadenas de ancho variable se pueden codificar en literales tal cual, con el riesgo de confundir al compilador, o usar secuencias de escape numéricas con barra invertida (por ejemplo, "\xc3\xa9"para " é " en UTF-8). La codificación UTF-8 se diseñó específicamente (en el Plan 9 ) para ser compatible con las funciones de cadena de la biblioteca estándar; entre las características que la respaldan se incluyen la ausencia de caracteres nulos incrustados, la ausencia de interpretaciones válidas para subsecuencias y una resincronización trivial. Es probable que las codificaciones que carecen de estas características resulten incompatibles con las funciones de la biblioteca estándar; en estos casos, se suelen usar funciones de cadena que tienen en cuenta la codificación.

Se accede a un miembro utilizando la notación de punto. Por ejemplo, dada la declaración teeanterior, yse puede acceder al miembro como tee.y.

Se suele acceder a una estructura mediante un puntero. Consideremos que define un puntero a , llamado . Se puede acceder a un miembro de desreferenciando y usando el resultado como operando izquierdo como . ^{[ b ]} Debido a que esta operación es común, el lenguaje proporciona una sintaxis abreviada para acceder a un miembro directamente desde un puntero, (por ejemplo, ).structMyStruct*ptee=&teeteepteeyteeptee(*ptee).y->ptee->y

Asignar un valor a un miembro es similar a asignar un valor a una variable. La única diferencia radica en que el lvalue (valor del lado izquierdo) de la asignación es el nombre del miembro, según la sintaxis anterior.

Una estructura también puede asignarse como un todo a otra estructura del mismo tipo, pasándose por copia como argumento de función o valor de retorno. Por ejemplo, tee.x = 74asigna el valor 74 al miembro llamado x en la estructura tee , y ptee->x = 74hace lo mismo para ptee .

Las operaciones admitidas para una estructura son: inicializar, copiar, obtener la dirección y acceder a un campo. Cabe destacar que el lenguaje no admite la comparación del valor de dos estructuras, salvo mediante código personalizado para comparar cada campo.

El lenguaje proporciona un tipo especial de miembro conocido como campo de bits , que es un entero con un tamaño especificado en bits. Un campo de bits se declara como un miembro de tipo ( signed/ unsigned) int, bool, o _BitInt(N) . ^{[ nota 4 ]} más un sufijo después del nombre del miembro que consiste en dos puntos y un número de bits. El número total de bits en un solo campo de bits no debe exceder el número total de bits de su tipo base. Contrariamente a las reglas de sintaxis habituales de C, depende de la implementación si un campo de bits es con signo o sin signo si no se especifica explícitamente. Por lo tanto, la mejor práctica es especificar o .signedunsigned

Los campos sin nombre indican relleno y consisten simplemente en dos puntos seguidos de una cantidad de bits. Especificar un ancho de cero para un campo sin nombre se utiliza para forzar la alineación a una nueva palabra. ^{[ 9 ]} 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 deben caber en ella.

Los campos de bits están limitados en comparación con los campos normales, ya que no se admiten los operadores de dirección ( &) ni .sizeof

A continuación se declara un tipo de estructura llamado FlagStatusy una instancia de la misma llamada g. El primer campo, flag, es un indicador de un solo bit, que solo puede ser 1 o 0. El segundo campo, num, es un campo con signo de 4 bits; rango -7...7 o -8...7. El último campo agrega 3 bits de relleno para completar la estructura a 8 bits.

struct FlagStatus { unsigned int flag : 1 ; signed int num : 4 ; signed int : 3 ; } g ;

A diferencia de C++ y Java, C no ofrece soporte nativo para espacios de nombres . Esto provoca conflictos entre los nombres de los símbolos en C. Sin embargo, es posible utilizar estructuras anónimas para emular espacios de nombres.

Matemáticas.h :

#pragma una vezconst struct { double PI ; double ( * sin )( double ); } Math ;

Matemáticas.c :

#include <math.h>static double _sin ( double arg ) { return sin ( arg ); }const struct { double PI ; double ( * sin )( double ); } Math = { M_PI , _sin };

Main.c :

#include <stdio.h> #include "Math.h"int main () { printf ( "sin(0) = %d \n " , Math . sin ( 0 )); printf ( "pi es %f \n " , Math . PI ); }

Inicializar una variable, además de declararla, implica agregar un signo de igual y luego una construcción compatible con el tipo de dato. El siguiente ejemplo inicializa un entero:

entero x = 12 ;

Debido a la gramática del lenguaje, un inicializador escalar puede estar encerrado entre cualquier número de pares de llaves. La mayoría de los compiladores emiten una advertencia si hay más de un par de llaves. Los siguientes ejemplos son válidos, aunque posiblemente inusuales:

int y = { 23 }; int z = { { 34 } };

Las estructuras, las uniones y los arreglos se pueden inicializar después de una declaración mediante una lista de inicialización.

Dado que los elementos no coincidentes se establecen en 0, una lista vacía establece todos los elementos en 0. Por ejemplo, lo siguiente establece todos los elementos de la matriz a y todos los campos de s en 0:

int a [ 10 ] = {}; struct MyStruct s = {};

Si se declara un array sin un tamaño explícito, el array es un tipo incompleto . El número de inicializadores determina el tamaño del array y completa el tipo. Por ejemplo:

int x [] = { 0 , 1 , 2 };

Por defecto, los elementos de una lista de inicialización se corresponden con los elementos en el orden en que se definen. Incluir demasiados valores produce un error. La siguiente instrucción inicializa una instancia de la estructura MyStruct llamada pi :

struct MyStruct { int x ; float y ; char * z ; };struct MyStruct pi = { 3 , 3.1415 , "Pi" };

Los inicializadores designados permiten inicializar los miembros por nombre, en cualquier orden y sin proporcionar explícitamente valores previos. La siguiente inicialización es funcionalmente equivalente a la anterior:

struct MyStruct pi = { . z = "Pi" , . x = 3 , . y = 3.1415 };

El uso de un designador en un inicializador mueve el "cursor" de inicialización. En el ejemplo siguiente, 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 sobrescritos por los siguientes 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 , una unión se inicializaba con un único valor aplicado a su primer miembro. Es decir, la unión MyUnion definida anteriormente solo podía tener su miembro x inicializado:

unión MyUnion valor = { 3 };

Utilizando un inicializador designado, el miembro que se va a inicializar no tiene por qué ser el primer miembro:

unión MyUnion valor = { . y = 3.1415 };

Los designadores compuestos se pueden usar para proporcionar una inicialización explícita cuando las listas de inicialización simples podrían malinterpretarse. En el ejemplo siguiente, 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 a:

struct { int a [ 3 ], b ; } w [] = { [ 0 ]. a = { 1 }, [ 1 ]. a [ 0 ] = 2 };

Esto es equivalente a:

struct { int a [ 3 ], b ; } w [] = { { { 1 , 0 , 0 }, 0 }, { { 2 , 0 , 0 }, 0 } };

Es posible tomar prestada la metodología de inicialización para generar estructuras compuestas y literales de matriz:

// puntero creado a partir de un literal de matriz. int * ptr = ( int []){ 10 , 20 , 30 , 40 };// puntero a la matriz. float ( * foo )[ 3 ] = & ( float []){ 0.5f , 1.f , -0.5f };struct MyStruct pi = ( struct MyStruct ){ 3 , 3.1415 , "Pi" };

Los literales compuestos a menudo se combinan con inicializadores designados para hacer que la declaración sea más legible: ^{[ 2 ]}

pi = ( struct MyStruct ){ . z = "Pi" , . x = 3 , . y = 3.1415 };

Los parámetros de función de tipo matriz pueden parecer a primera vista una excepción a la regla de paso por valor, como lo demuestra el siguiente programa que imprime 123, no 1:

#include <stdio.h>void setArray ( int a [], int index ) { array [ index ] = 123 ; }int main ( void ) { int a [ 1 ] = {1} ; setArray ( a , 0 ) ; printf ( "a[0]=%d \n " , a [ 0 ]); return 0 ; }

Sin embargo, existe otra razón para este comportamiento. Un parámetro de matriz se trata como un puntero. El siguiente prototipo es equivalente al prototipo de función anterior:

void setArray ( int * a , int index );

Al mismo tiempo, las reglas para el uso de arreglos en expresiones hacen que el valor ase trate como un puntero al primer elemento. Por lo tanto, sigue siendo paso por valor, con la salvedad de que se pasa por valor la dirección del primer elemento del arreglo, no su contenido.

Desde C99, el programador puede especificar que una función acepte un array de un tamaño determinado mediante la palabra clave ` static.`. El primer parámetro debe ser un puntero al primer elemento de un array de longitud mínima 4. También es posible usar calificadores ( , y ) para especificar el tipo de puntero al que se convierte el array.voidsetArray(intarray[static4],intindex)constvolatilerestrict