- 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.
0 comentarios:
Publicar un comentario