6.Datos en C.
6.Datos en C.
6.1.Introducción.6.2.Tipos de datos fundamentales. Variables.
6.3.Tipos de datos fundamentales. Constantes.
6.4.Cualificador const.
6.5.Tamaño de los datos en C.
6.1.Introducción.
El C, como cualquier otro lenguaje de programación, tiene posibilidad de trabajar con datos de distinta naturaleza: texto formado por caracteres alfanuméricos, números enteros, números reales con parte entera y parte fraccionaria, etc. Además, algunos de estos tipos de datos admiten distintos números de cifras (rango y/o precisión), posibilidad de ser sólo positivos o de ser positivos y negativos, etc. En este apartado se verán los tipos fundamentales de datos admitidos por el C. Más adelante se verá que hay otros tipos de datos, derivados de los fundamentales. Tipos de datos fundamentales del C:
| Tipos de datos fundamentales (notación completa) |
|||
Enteros |
char | signed char | unsigned char |
| signed short int | signed int | signed long int | |
| unsigned short int | unsigned int | unsigned long int | |
| Reales | float | double | long double |
La palabra char hace referencia a que se trata de un carácter (una letra mayúscula o minúscula, un dígito, un carácter especial, etc.).
La palabra int indica que se trata de un número entero.
La palabra float se refiere a un número real (también llamado de punto o coma flotante).
Los números enteros pueden ser positivos o negativos (signed), o bien no negativos (unsigned). Los caracteres tienen un tratamiento muy similar a los enteros y admiten estos mismos cualificadores. En los datos enteros, las palabras short y long hacen referencia al número de cifras o rango de dichos números.
En los datos reales las palabras double y long apuntan en esta misma dirección, aunque con un significado ligeramente diferente, como más adelante se verá.
Esta nomenclatura puede simplificarse: las palabras signed e int son las opciones por defecto para los números enteros y pueden omitirse, resultando la siguiente tabla, que indica la nomenclatura más habitual para los tipos fundamentales del C.
|
Tipos de datos fundamentales (notación abreviada). |
|||
Enteros |
char | signed char | unsigned char |
| short | int | long | |
| unsigned short | unsigned | unsigned long | |
| Reales | float | double | long double |
A continuación se va a explicar cómo puede ser y cómo se almacena en C un dato de cada tipo fundamental.
6.2.Tipos de datos fundamentales. Variables.
Recuérdese que en C es necesario declarar todas las variables que se vayan a utilizar. Una variable no declarada produce un mensaje de error en la compilación.
Cuando una variable es declarada se le reserva memoria de acuerdo con el tipo incluido en la declaración.
Es posible inicializar (dar un valor inicial) las variables en el momento de la declaración; ya se verá que en ciertas ocasiones el compilador da un valor inicial por defecto, mientras que en otros casos no se realiza esta inicialización y la memoria asociada con la variable correspondiente contiene basura informática (combinaciones sin sentido de unos y ceros, resultado de operaciones anteriores con esa zona de la memoria, para otros fines).
Según la máquina y el compilador que se utilice los tipos primitivos pueden ocupar un determinado tamaño en memoria. Lo que trataremos a continuación se aplica a la arquitectura x86.
Otras arquitecturas pueden requerir distintos tamaños de tipos de datos primitivos. ANSIC no dice nada acerca de cuál es el número de bits en un byte, ni del tamaño de estos tipos; más bien, ofrece solamente las siguientes "garantías de tipos":
- Un tipo char tiene el tamaño mínimo en bytes asignable por la máquina, y todos los bits de este espacio deben ser "accesibles".
- El tamaño reconocido de char es de 1. Es decir, sizeof(char) siempre devuelve 1.
- Un tipo short tiene al menos el mismo tamaño que un tipo char.
- Un tipo long tiene al menos el doble tamaño en bytes que un tipo short.
- Un tipo int tiene un tamaño entre el de short y el de long, ambos inclusive, preferentemente el tamaño de un apuntador de memoria de la máquina.
- Un tipo unsigned tiene el mismo tamaño que su versión signed.
6.2.1.Caracteres (tipo char).
Las variables carácter (tipo char) contienen un único carácter y se almacenan en un byte de memoria (8 bits, 256 valores diferentes entre 0 y 255 para variables sin signo, y de -128 a 127 para variables con signo, que es la opción por defecto.
La declaración de variables tipo carácter puede tener la forma:
char nombre;
char nombre1, nombre2, nombre3; |
Se puede declarar más de una variable de un tipo determinado en una sola sentencia.
Se puede también inicializar la variable en la declaración. Por ejemplo, para definir la variable carácter letra y asignarle el valor -a-, se puede escribir:
char letra = ’a’; |
A partir de ese momento queda definida la variable letra con el valor correspondiente a la letra a. Recuérdese que el valor ’a’ utilizado para inicializar la variable letra es una constante carácter. En realidad, letra se guarda en un solo byte como un número entero, el correspondiente a la letra a en el código ASCII.
En la variable letra, su contenido puede ser variado cuando se desee por medio de una sentencia que le asigne otro valor, por ejemplo:
letra = ’z’; |
También puede utilizarse una variable char para dar valor a otra variable de tipo char:
caracter = letra; /* Ahora carácter es igual a ’z’ */ |
Como una variable tipo char es un número entero pequeño (entre 0 y 255), se puede utilizar el contenido de una variable char de la misma forma que se utiliza un entero, por lo que están permitidas operaciones como:
letra = letra + 1;
letra_minus = letra_mayus + (’a’ - ’A’); |
En el primer ejemplo, si el contenido de letra era una a, al incrementarse en una unidad pasa a contener una b. El segundo ejemplo es interesante: puesto que la diferencia numérica entre las letras minúsculas y mayúsculas es siempre la misma (según el código ASCII), la segunda sentencia pasa una letra mayúscula a la correspondiente letra minúscula sumándole dicha diferencia numérica.
Recuérdese para concluir que las variables tipo char son y se almacenan como números enteros pequeños. Ya se verá más adelante que se pueden escribir como caracteres o como números según que formato de conversión se utilice en la llamada a la función de escritura.
6.2.2.Números enteros (tipo int).
Una variable tipo int se almacena en 4 bytes (32 bits).
Con 32 bits se pueden almacenar 4,294967,296 números enteros diferentes: de 0 a 4,294,967,295 para variables sin signo, y de -2,147,483,648 a 2,147,483,647 para variables con signo, que es la opción por defecto.
Una variable entera (tipo int) se declara, o se declara y se inicializa en la forma:
unsigned int numero;
int nota = 10; |
En este caso la variable numero podrá estar entre 0 y 4,294,967,295, mientras que nota deberá estar comprendida entre -2,147,483,648 y 2,147,483,647 .
Cuando a una variable int se le asigna en tiempo de ejecución un valor que queda fuera del rango permitido (situación de overflow o valor excesivo), se produce un error en el resultado de consecuencias tanto más imprevisibles cuanto que de ordinario el programa no avisa al usuario de dicha circunstancia.
Cuando el ahorro de memoria es muy importante puede asegurarse que el ordenador utiliza 2 bytes para cada entero declarándolo en una de las formas siguientes:
short numero;
short int numero; |
En este caso la variable numero podrá estar entre -32.768 y 32.767.
6.2.3.Números enteros (tipo long).
Existe la posibilidad de utilizar enteros con un rango mayor si se especifica como tipo long:
|
long int numero_grande; /*o, ya que la palabra clave int puede omitirse en este caso: */ long numero_grande; |
El rango de un entero long puede variar según el ordenador o el compilador que se utilice, en nuestro caso coincide con el tamaño de un entero, por lo que se pueden representar 4.294.967.296 números enteros diferentes. Si se utilizan números con signo, podrán representarse números entre -2.147.483.648 y 2.147.483.647.
También se pueden declarar enteros long que sean siempre positivos con la palabra unsigned:
unsigned long positivo_muy_grande;
|
En algunos ordenadores una variable int ocupa 2 bytes (coincidiendo con short) y en otros 4 bytes (coincidiendo con long). Lo que garantiza el ANSI C es que el rango de int no es nunca menor que el de short ni mayor que el de long.
6.2.4.Números reales (tipo float).
En muchas aplicaciones hacen falta variables reales, capaces de representar magnitudes que contengan una parte entera y una parte fraccionaria o decimal. Estas variables se llaman también de punto flotante o coma flotante.
De ordinario, en base 10 y con notación científica, estas variables se representan por medio de la mantisa, que es un número mayor o igual que 0.1 y menor que 1.0, y un exponente que representa la potencia de 10 por la que hay que multiplicar la mantisa para obtener el número considerado. Por ejemplo, pi se representa como 0.3141592654 · 101.
Tanto la mantisa como el exponente pueden ser positivos y negativos.
Los ordenadores trabajan en base 2. Por eso un número de tipo float se almacena en 4 bytes (32 bits), utilizando 24 bits para la mantisa (1 para el signo y 23 para el valor) y 8 bits para el exponente (1 para el signo y 7 para el valor).
Es interesante ver qué clase de números de coma flotante pueden representarse de esta forma. En este caso hay que distinguir el rango de la precisión.
La precisión hace referencia al número de cifras con las que se representa la mantisa: con 23 bits el número más grande que se puede representar es 8.388.608 lo cual quiere decir que se pueden representar todos los números decimales de 6 cifras y la mayor parte (aunque no todos) de los de 7 cifras (por ejemplo, el número 9.213.456 no se puede representar con 23 bits). Por eso se dice que las variables tipo float tienen entre 6 y 7 cifras decimales equivalentes de precisión.
Respecto al exponente por el que hay que multiplicar la mantisa, 7 bits, el número más grande que se puede representar es 127 que será el exponente en base dos (2127=1,7014e+38).
El rango vendrá definido por la combinación de mantisa y exponente. En la mayoría de los compiladores el rango de los números representables es de –3.4E+38 a –1.17E-38 y de 1.17E-38 a 3.4E+38.
Las variables tipo float se declaran de la forma:
float numero_real; |
Las variables tipo float pueden ser inicializadas en el momento de la declaración, de forma análoga a las variables tipo int.
6.2.5.Números reales (tipo double).
Las variables tipo float tienen un rango y (sobre todo) una precisión muy limitada, insuficiente para la mayor parte de los cálculos técnicos y científicos. Este problema se soluciona con el tipo double, que utiliza 8 bytes (64 bits) para almacenar una variable. Se utilizan 53 bits para la mantisa (1 para el signo y 52 para el valor) y 11 para el exponente (1 para el signo y 10 para el valor). La precisión es en este caso, 252 = 4.503.599.627.370.496 lo cual representa entre 15 y 16 cifras decimales equivalentes.
Con respecto al rango, con un exponente de 10 bits el número más grande que se puede representar será 1.7977 · 10308.
Las variables tipo double se declaran de forma análoga a las anteriores:
double real_grande; |
Por último, existe la posibilidad de declarar una variable como long double, aunque el ANSI C no garantiza un rango y una precisión mayores que las de double. Eso depende del compilador y del tipo de ordenador.
Estas variables se declaran en la forma:
long double real_pero_que_muy_grande; |
Cuyo rango y precisión no está normalizado. En nuestro caso se utilizan 12 bytes.
6.2.6.Duración y visibilidad de las variables: Modos de almacenamiento.
El tipo de una variable se refiere a la naturaleza de la información que contiene (ya se han visto los tipos char, int, long, float, double, etc.).
El modo de almacenamiento (storage class) es otra característica de las variables de C que determina cuándo se crea una variable, cuándo deja de existir y desde dónde se puede acceder a ella, es decir, desde dónde es visible.
En C existen 4 modos de almacenamiento fundamentales: auto, extern, static y register. Seguidamente se exponen las características de cada uno de estos modos.
6.2.6.1.auto (automático).
Es la opción por defecto para las variables que se declaran dentro de un bloque {...}, incluido el bloque que contiene el código de las funciones. En C la declaración debe estar siempre al comienzo del bloque. En C++ la declaración puede estar en cualquier lugar y hay autores que aconsejan ponerla justo antes del primer uso de la variable. No es necesario poner la palabra auto.
Cada variable auto es creada al comenzar a ejecutarse el bloque y deja de existir cuando el bloque se termina de ejecutar. Cada vez que se ejecuta el bloque, las variables auto se crean y se destruyen de nuevo.
Las variables auto son variables locales, es decir, sólo son visibles en el bloque en el que están definidas y en otros bloques anidados en él, aunque pueden ser ocultadas por una nueva declaración de una nueva variable con el mismo nombre en un bloque anidado.
No son inicializadas por defecto, y (antes de que el programa les asigne un valor) pueden contener basura informática (conjuntos aleatorios de unos y ceros, consecuencia de un uso anterior de esa zona de la memoria). A continuación se muestra un ejemplo de uso de variables de modo auto:
{
int i=1, j=2; /* se declaran e inicializan i y j */ { float a=7., j=3.; /* se declara una nueva variable j */ ... j=j+a; /* aqui j es float la variable int j es invisible la variable i=1 es visible */ } /* fuera del bloque, a ya no existe, la variable j=2 existe y es entera */ } /*fuera de los dos bloques no existen i, j y a */ |
6.2.6.2.Extern.
Son variables globales, que se definen fuera de cualquier bloque o función, por ejemplo antes de definir la función main(). Estas variables existen durante toda la ejecución del programa. Las variables extern son visibles por todas las funciones que están entre la definición y el fin del fichero. Para verlas desde otras funciones definidas anteriormente o desde otros ficheros, deben ser declaradas en ellos como variables extern. Por defecto, son inicializadas a cero.
Una variable extern es definida o creada (una variable se crea en el momento en el que se le reserva memoria y se le asigna un valor) una sola vez, pero puede ser declarada (es decir, reconocida para poder ser utilizada) varias veces, con objeto de hacerla accesible desde diversas funciones o ficheros.
También estas variables pueden ocultarse mediante la declaración de otra variable con el mismo nombre en el interior de un bloque.
Las variables extern permiten transmitir valores entre distintas funciones, pero ésta es una práctica considerada como peligrosa. A continuación se presenta un ejemplo de uso de variables extern:
int i=1, j, k; /* se declaran antes de main() */
main() { int i=3; /* i=1 se hace invisible */ int func1(int, int); /* j, k son visibles */ .... .... } int func1(int n, int m)
{ 1 int k=3; // k=0 se hace invisible ... // i=3 es invisible } |
6.2.6.3.Static.
Cuando ciertas variables son declaradas como static dentro de un bloque, conservan su valor entre distintas ejecuciones de ese bloque. Dicho de otra forma, las variables static se declaran dentro de un bloque como las auto, pero permanecen en memoria durante toda la ejecución del programa como las extern.
Cuando se llama varias veces sucesivas a una función (o se ejecuta varias veces un bloque) que tiene declaradas variables static, los valores de dichas variables se conservan entre dichas llamadas. La inicialización sólo se realiza la primera vez. Por defecto, son inicializadas a cero.
Las variables definidas como static extern son visibles sólo para las funciones y bloques comprendidos desde su definición hasta el fin del fichero. No son visibles desde otras funciones ni aunque se declaren como extern. Ésta es una forma de restringir la visibilidad de las variables.
Por defecto, y por lo que respecta a su visibilidad, las funciones tienen modo extern. Una función puede también ser definida como static, y entonces sólo es visible para las funciones que están definidas después de dicha función y en el mismo fichero. Con estos modos se puede controlar la visibilidad de una función, es decir, desde qué otras funciones puede ser llamada.
6.2.6.4.Register.
Este modo es una recomendación para el compilador, con objeto de que (si es posible) ciertas variables sean almacenadas en los registros de la CPU y los cálculos con ellas sean más rápidos. No existen los modos auto y register para las funciones.
6.2.7.Conversiones de tipo implícitas y explícitas(casting).
Más adelante se comentarán las conversiones implícitas de tipo que tienen lugar cuando en una expresión se mezclan variables de distintos tipos. Por ejemplo, para poder sumar dos variables hace falta que ambas sean del mismo tipo. Si una es int y otra float, la primera se convierte a float ( la variable del tipo de menor rango se convierte al tipo de mayor rango), antes de realizar la operación. A esta conversión automática e implícita de tipo (el programador no necesita intervenir, aunque sí conocer sus reglas), se le denomina promoción, pues la variable de menor rango es promocionada al rango de la otra.
Así pues, cuando dos tipos diferentes de constantes y/o variables aparecen en una misma expresión relacionadas por un operador, el compilador convierte los dos operandos al mismo tipo de acuerdo con los rangos, que de mayor a menor se ordenan del siguiente modo:
long double > double > float > unsigned long > long > unsigned int > int > char
Otra clase de conversión implícita tiene lugar cuando el resultado de una expresión es asignado a una variable, pues dicho resultado se convierte al tipo de la variable (en este caso, ésta puede ser de menor rango que la expresión, por lo que esta conversión puede perder información y ser peligrosa).
Por ejemplo, si i y j son variables enteras y x es double:
x = i*j – j + 1; |
En C existe también la posibilidad de realizar conversiones explícitas de tipo (llamadas casting, en la literatura inglesa). El casting es pues una conversión de tipo, forzada por el programador. Para ello basta preceder la constante, variable o expresión que se desea convertir por el tipo al que se desea convertir, encerrado entre paréntesis. En el siguiente ejemplo:
k = (int) 1.7 + (int) masa; |
La variable masa es convertida a tipo int, y la constante 1.7 (que es de tipo double) también. El casting se aplica con frecuencia a los valores de retorno de las funciones.
6.3.Tipos de datos fundamentales. Constantes.
Se entiende por constantes aquel tipo de información numérica o alfanumérica que no puede cambiar más que con una nueva compilación del programa. En el código de un programa en C pueden aparecer diversos tipos de constantes que se van a explicar a continuación.
6.3.1.Constantes numéricas.
6.3.1.1.Constantes enteras.
Una constante entera decimal está formada por una secuencia de dígitos del 0 al 9. Las constantes enteras decimales están sujetas a las mismas restricciones de rango que las variables tipo int y long, pudiendo también ser unsigned.
El tipo de una constante se puede determinar automáticamente según su magnitud, o de modo explícito posponiendo ciertos caracteres, como en los ejemplos que siguen:
- 23484 constante tipo int
- 45815 constante tipo long (es mayor que 32767)
- 25u ó 25U constante tipo unsigned int
- 739l ó 739L constante tipo long
- 58ul ó 58UL constante tipo unsigned long
- 011 constante octal (igual a 9 en base 10)
- 11 constante entera decimal (no es igual a 011)
- 0xA constante hexadecimal (igual a 10 en base 10)
- 0xFF constante hexadecimal (igual a 255 en base 10)
6.3.1.2.Constantes de coma flotante.
Como es natural, existen también constantes de coma flotante, que pueden ser de tipo float, double y long double. Una constante de punto flotante se almacena de la misma forma que la variable correspondiente del mismo tipo. Por defecto (si no se indica otra cosa) las constantes de punto flotante son de tipo double.
Para indicar que una constante es de tipo float se le añade una f o una F; para indicar que es de tipo long double, se le añade una l o una L. En cualquier caso, el punto decimal siempre debe estar presente si se trata de representar un número real.
Estas constantes se pueden expresar de varias formas. La más sencilla es un conjunto de dígitos del 0 al 9, incluyendo un punto decimal. Para constantes muy grandes o muy pequeñas puede utilizarse la notación científica; en este caso la constante tiene una parte entera, un punto decimal, una parte fraccionaria, una e o E, y un exponente entero (afectando a la base 10), con un signo opcional. Se puede omitir la parte entera o la fraccionaria, pero no ambas a la vez. Las constantes de punto flotante son siempre positivas. Puede anteponerse un signo (-), pero no forma parte de la constante, sino que con ésta constituye una expresión, como se verá más adelante. A continuación se presentan algunos ejemplos válidos:
- 1.23 constante tipo double (opción por defecto)
- 23.963f constante tipo float
- .00874 constante tipo double
- 23e2 constante tipo double (igual a 2300.0)
- .874e-2 constante tipo double en notación científica (=.00874)
- .874e-2f constante tipo float en notación científica
- 1,23 ERROR: la coma no esta permitida
- 23963f ERROR: no hay punto decimal ni carácter e ó E
- .e4 ERROR: no hay ni parte entera ni fraccionaria
- -3.14 ERROR: sólo el exponente puede llevar signo
6.3.2.Constantes carácter.
Una constante carácter es un carácter cualquiera encerrado entre apóstrofos (tal como ‘x’ o ‘t’). El valor de una constante carácter es el valor numérico asignado a ese carácter según el código ASCII. Conviene indicar que en C no existen constantes tipo char; lo que se llama aquí constantes carácter son en realidad constantes enteras.
Hay que señalar que el valor ASCII de los números del 0 al 9 no coincide con el propio valor numérico. Por ejemplo, el valor ASCII de la constante carácter ‘7’ es 55.
Ciertos caracteres no representables gráficamente, el apóstrofo (‘) y la barra invertida (\) y otros caracteres, se representan mediante la siguiente tabla de secuencias de escape, con ayuda de la barra invertida (\).
| Nombre completo | Constante | en C | ASCII |
| Sonido de alerta | BEL | \a | 7 |
| Nueva línea | NL | \n | 10 |
| Tabulador horizontal | HT | \t | 9 |
| Retroceso | BS | \b | 8 |
| Retorno de carro | CR | \r | 13 |
| Salto de página | FF | \f | 12 |
| Barra invertida | \ |
\\ | 92 |
| Apóstrofo | ‘ | \’ | 39 |
| Comillas | “ | \” | 34 |
| Carácter nulo | NULL | \0 | 0 |
6.3.3.Cadenas de caracteres.
Una cadena de caracteres es una secuencia de caracteres delimitada por comillas ("), como por ejemplo: "Esto es una cadena de caracteres". Dentro de la cadena, pueden aparecer caracteres en blanco y se pueden emplear las mismas secuencias de escape válidas para las constantes carácter. Por ejemplo, las comillas (") deben estar precedidas por (\), para no ser interpretadas como fin de la cadena; también la propia barra invertida (\).
Es muy importante señalar que el compilador sitúa siempre un byte nulo (\0) adicional al final de cada cadena de caracteres para señalar el final de la misma. Así, la cadena "mesa" no ocupa 4 bytes, sino 5 bytes. A continuación se muestran algunos ejemplos de cadenas de caracteres:
- "Informática"
- "'A'"
- " cadena con espacios en blanco "
- "Es una \"cadena de caracteres\".\n"
6.3.4.Constantes de tipo Enumeración.
En C existe una clase especial de constantes, llamadas constantes enumeración. Estas constantes se utilizan para definir los posibles valores de ciertos identificadores o variables que sólo deben poder tomar unos pocos valores. Por ejemplo, se puede pensar en una variable llamada dia_de_la_semana que sólo pueda tomar los 7 valores siguientes: lunes, martes, miercoles, jueves, viernes, sabado y domingo. Es muy fácil imaginar otros tipos de variables análogas, una de las cuales podría ser una variable booleana con sólo dos posibles valores: SI y NO, o TRUE y FALSE, u ON y OFF. El uso de este tipo de variables hace más claros y legibles los programas, a la par que disminuye la probabilidad de introducir errores.
En realidad, las constantes enumeración son los posibles valores de ciertas variables definidas como de ese tipo concreto. Considérese como ejemplo la siguiente declaración:
enum dia {lunes, martes, miercoles,jueves, viernes, sabado,domingo};
|
Esta declaración crea un nuevo tipo de variable (el tipo de variable dia) que sólo puede tomar uno de los 7 valores encerrados entre las llaves. Estos valores son en realidad constantes tipo int: lunes es un 0, martes es un 1, miercoles es un 2, etc. Ahora, es posible definir variables, llamadas dia1 y dia2, que sean de tipo dia, en la forma:
|
enum dia dia1, dia2; /* esto es C */ dia dia1, dia 2; /*esto es C++*/ |
A estas variables se les pueden asignar valores en la forma dia1 = martes; o aparecer en diversos tipos de expresiones y de sentencias que se explicarán más adelante.
Los valores enteros que se asocian con cada constante tipo enumeración pueden ser controlados por el programador. Por ejemplo, la declaración,
enum dia {lunes=1, martes, miercoles, jueves, viernes, sabado, domingo};
|
Asocia un valor 1 a lunes, 2 a martes, 3 a miercoles, etc., mientras que la declaración,
enum dia {lunes=1, martes, miercoles, jueves=7, viernes, sabado, domingo}; |
Asocia un valor 1 a lunes, 2 a martes, 3 a miercoles, un 7 a jueves, un 8 a viernes, un 9 a sabado y un 10 a domingo.
Se puede también hacer la definición del tipo enum y la declaración de las variables en una única sentencia, en la forma:
enum palo {oros, copas, espadas,bastos} carta1, carta2, carta3; |
Donde carta1, carta2 y carta3 son variables que sólo pueden tomar los valores oros, copas, espadas y bastos (equivalentes respectivamente a 0, 1, 2 y 3).
6.4.Cualificador const.
Se puede utilizar el cualificador const para indicar que esa variable no puede cambiar de valor. Si se utiliza con un array, los elementos del array no pueden cambiar de valor. Por ejemplo:
const int i=10; const double x[] = {1, 2, 3, 4}; |
El lenguaje C no define lo que ocurre si en otra parte del programa o en tiempo de ejecución se intenta modificar una variable declarada como const. De ordinario se obtendrá un mensaje de error en la compilación si una variable const figura a la izquierda de un operador de asignación.
El cualificador const se suele utilizar cuando, por motivos de eficiencia, se pasan argumentos por referencia a funciones y no se desea que dichos argumentos sean modificados por éstas.
6.5.Tamaño de los datos en C.
| Tipo de dato | Bytes | Rango |
| char | 1 | -128 a 127 |
| unsigned char | 1 | 0 a 255 |
| short | 2 | -32768 a 32767 |
| unsigned short | 2 | 0 a 65535 |
| int | 4 | -2147483648 a 2147483647 |
| unsigned int | 4 |
0 a 4294967295 |
| long | 4 | -2147483648 a 2147483647 |
| unsigned long | 4 | 0 a 4294967296 |
| float | 4 | (de 6 a 7 dígitos) -3.4E+38 a –1.17E-38 1.17E-38 a 3.4E+38 |
| double | 8 | (de 15 a 16 dígitos) -1.79E+308 a -2.22E-308 2.22E-308 a 1.79E+308 |
| long double | 12 | (No estandar, unos 19 dígitos) -1.18E+4932 a –3.36E-4932 3.36E-4932 a 1.18E+4932 |