Manipulación básica de datos

• Literales
• Tipos básicos
• Declaraciones de variables
• Rangos de valores y tipos modificados
• Nombres de variables (identificadores)
• Expresiones
• Asignaciones
• Operadores booleanos
• Operadores avanzados

Literales

Literal: un dato escrito directamente (ej. 1234, “hola”, etc.)

Nombre	Descripción	Ejemplos
Decimal	entero en base 10	1234
Hexadecimal	entero en base 16	0x1234
Octal	entero en base 8	01234
Carácter	byte en ASCII	'A'
Coma flotante	número real en c.f.	1.25 3.456e6 3.456e-6
Cadena	texto literal	"hola, mundo"

Declaraciones de variables

Las variables se utilizan para guardar datos dentro del programa.

Hay que declarar las variables antes de usarlas.

Cada variable tiene un tipo.

Declaración:

tipo nombre ;

Ejemplo:

int pepe;

Las variables globales se declaran justo antes de main().

Rangos de valores y tipos modificados

Rango de los enteros

Una variable entera acepta valores positivos y negativos dentro de un rango determinado, que depende de la plataforma y del compilador (en pecés bajo MS-DOS suele estar entre -32768 y 32767; en Linux son enteros de 32 bits).

Existen modificaciones para el tipo int, para alterar el rango de valores sobre el que trabaja:

Modificador	Significado
short	entero corto (rango más pequeño)
long	entero largo (rango más amplio)
unsigned	entero sin signo (0..N)
signed	entero con signo (-N-1 .. +N)

La palabra int se puede omitir en la declaración de la variable.

Los modificadores de tamaño ( short, long) y de signo ( signed, unsigned) se pueden combinar.

Por omisión, un entero es signed (en la práctica, esta palabra reservada casi nunca se emplea).

Ejemplos:

         unsigned sin_signo;                /* entero sin signo */

         long saldo_en_cuenta;     /* entero largo con signo */

         unsigned long telefono;   /* entero largo sin signo */

Tipo char

El tipo char permite manejar caracteres (letras), aunque se trata de un tipo numérico.

Normalmente el rango de valores va de –128 a +127 (signed char), o bien de 0 a 255 (unsigned char).

Los literales de tipo carácter se pueden utilizar como números.

         char caracter;

         int entero;

         main()

         {

                 caracter = 65; // valdría como una ‘A’

                 entero = ‘A’;  // valdría como un 65

         }

Nombres de variables (identificadores)

Un identificador es un nombre que define a una variable, una función o un tipo de datos.

Un identificador válido ha de empezar por una letra o por el carácer de subrayado _, seguido de cualquier cantidad de letras, dígitos o subrayados.

OJO: Se distinguen mayúsculas de minúsculas.

No se pueden utilizar palabras reservadas como int, char o while.

Muchos compiladores no permiten letras acentuadas o eñes.

Ejemplos válidos:

                 char letra;

                 int Letra;

                 float CHAR;

                 int __variable__;

                 int cantidad_envases;

                 double precio123;

                 int __;

Ejemplos no válidos:

                 int 123var;               /* Empieza por dígitos */

                 char int;                 /* Palabra reservada */

                 int una sola;    /* Contiene espacios */

                 int US$;                  /* Contiene $ */

                 int var.nueva;   /* Contiene el punto /

                 int eñe;                  /* Puede no funcionar */

Expresiones

Los datos se manipulan mediante expresiones, que sirven para calcular valores. En C hay varios operadores para construir expresiones.

Estos son los operadores elementales sobre números:

Operador	Significado
+	suma
-	resta
*	producto
/	división
%	módulo (resto de la división)

Una expresión combina varias operaciones y devuelve un valor.

Los operadores *, / y % tienen precedencia sobre la suma y la resta.

Se pueden utilizar paréntesis para agrupar subexpresiones.

Ejemplos de expresiones:

         1

         2+2

         4 + 6/2

         (4+6) / 2

         ( 3*5 + 12 ) % 7

Asignaciones

La forma de dar valor a una variable es

variable = expresión ;

Se le llama asignación.

También se puede dar valor a una variable en el mismo momento en que se declara ( inicialización).

tipo variable = expresión ;

Una variable que se declara sin inicializar contiene un valor indeterminado.

Ejemplo:

         int valor1 = 0;  /* variable inicializada a cero */

         int valor2;               /* variable no inicializada */

         main()

         {

                 valor1 = 4 + 3;  /* asignación */

                 valor2 = 5;               /* otra asignación */

         }

Expresiones: uso de variables

Una expresión puede ser el nombre de una variable.

En ese caso, el resultado de la expresión es el valor de la variable.

Ejemplo:

int valor1 = 5;

int valor2 = 1;

main()

{

         valor2 = ( valor1 * 4 ) - valor2;

}

Operadores booleanos

Hay operadores para evaluar condiciones.

En C no existe tipo booleano, así que el resultado de la expresión utiliza números enteros: si la condición es cierta, estas expresiones devuelven un 1; si no es cierta, devuelven un cero.

Operador	Resultado
A == B	1 si A es igual a B; 0 en caso contrario
A != B	1 si A es distinto de B
A > B	1 si A es mayor que B
A < B	1 si A es menor que B
A >= B	1 si A es mayor o igual que B

Para elaborar condiciones complejas, existen estos operadores:

Expresión	Resultado
E1 && E2	Cierta si E1 y E2 son ciertas (AND)
E1 || E2	Cierta si E1 o E2 son ciertas (OR)
! E	Cierta si E es falsa; falsa si E es cierta (NOT)

Se pueden agrupar expresiones booleanas con paréntesis.

Ejemplo:

( a>0 && a<10 ) || a==20

cierto si “a” está entre 1 y 9 (ambos inclusive), o vale 20.

Las asignaciones son expresiones

Una asignación es una expresión. Esto quiere decir que: a) devuelve un valor; b) una asignación puede incrustarse dentro de una expresión más compleja.

El valor devuelto por la asignación a=b es el resultado de evaluar b.

Ejemplo:

         C =  20 - ( B = 2*(A=5)+4 ) ;

A valdrá 5 (por la expresión A=5)

B valdrá 2*(5)+4= 14

C valdrá 20-(14)= 6

En consecuencia, una asignación se puede colocar en cualquier sitio donde se puede emplear una expresión.

Operadores avanzados

Los operadores de incremento, decremento y asignación compuesta permiten modificar el contenido de una variable de forma eficiente y abreviada.

Operadores	Significado
A++, ++A	Incrementa en 1 el valor de A (A=A+1)
A--, --A	Disminuye en 1 el valor de A (A=A-1)
A+=x	A=A+x
A-=x	A=A-x
A*=x	A=A*x
A/=x	A=A/x

Operadores “pre” y “post” y valor devuelto

Si el operador ++ o -- se coloca a la izquierda, se llama preincremento o predecremento, respectivamente. Si se coloca a la derecha, se llama postincremento o postdecremento.

Cuando se escriben estas expresiones dentro de expresiones más complejas, el valor que se devuelve es:

• Operaciones “pre”: El valor nuevo de la variable afectada
• Operaciones “post”: el valor anterior de la variable afectada

Ejemplo:

         x=1;

         A = ++x;         // preincremento: 

// A valdrá 2, x valdrá 2

         x=1;

         A = x++;         // postincremento:

                                   // A valdrá 1, x valdrá 2

Las asignaciones compuestas devuelven el nuevo valor de la variable:

x=2; A=(x*=3)+1; // x valdrá 6, A valdrá 7

Desbordamientos y redondeos

Desbordamientos (overflows)

En lenguaje C no se detectan desbordamientos. Si el resultado de una expresión está fuera del rango, el valor resultante es erróneo, pero no se interrumpe el programa ni se señaliza de ninguna forma.

Ejemplo:

         /* supongamos enteros de 16 bits */

         /* su rango va de –32768 a +32767 */

         int x, y;

         main()

         {

                 x = 30000;

                 y = x + 3000;    /* ¡¡ y valdrá –29769 !! */

         }

Redondeos

Si una expresión entera da un resultado fraccionario, se redondea al entero más cercano a cero (redondeo inferior).

Esto ocurre aunque el destino de la expresión sea una variable en coma flotante.

Ejemplo:

         x = 13 / 3;  // x valdrá 4

Números en coma flotante

Los números en coma flotante son necesarios para trabajar con fracciones o con números de un rango mayor que los enteros.

         float x = 123.456;

         float y = 10000000.0;

Conversión de tipo

Se puede cambiar el tipo de una expresión de esta forma:

(nuevo_tipo) expresión

Por ejemplo, para forzar a que una división de enteros se realice en coma flotante, podemos escribir:

         int x=5,y=3;

         float f;

         f = (float)x/y;

En este ejemplo, el valor de x, que es entero, se transforma a float. Así la división se realizará en coma flotante.

Vectores y matrices (arrays)

Se pueden crear variables que sean conjuntos de elementos del mismo tipo (vectores o matrices).

Sintaxis:

tipo nombre_del_vector [ dimensión ] ;

Ejemplo:

         int vector [5] ; /* Crea un vector de cinco enteros */

Los elementos de un vector empiezan en cero y terminan en dimensión - 1.

Para acceder al elemento i de un vector, se utiliza la expresión

vector [ i ]

Múltiples dimensiones

Se pueden declarar matrices de dos o más dimensiones, según esta sintaxis:

tipo matriz [ dimensión1 ] [ dimensión2 ] ... ;

Ejemplo:

         int matriz [3][8] ;

Se accede a los elementos con esta expresión:

         matriz [i][j] 

NOTA: la expresión matriz[i,j] no es válida, pero es una expresión correcta en C y no dará error de compilación (equivale a haber escrito matriz[j]).

Precauciones con los vectores

• El compilador de C reconoce la expresión vector[i,j], pero es un error.
• El C numera los elementos de un vector desde CERO.
• El C no detecta índices fuera de rango.
• Si A y B son vectores, la expresión A = B es ilegal.