Diferencia entre revisiones de «Fundamentos de C - Lección 5»
Contenido eliminado Contenido añadido
mSin resumen de edición |
Sin resumen de edición |
||
Línea 1:
== '''ESTRUCTURAS CONDICIONALES''' ==
==== If ====
if (expresion)
{
Línea 13 ⟶ 11:
}
==== Switch ====
switch (variable)
{
Línea 34 ⟶ 31:
Switch sólo puede comprobar la igualdad.
== BUCLES ==
=== For ===
for (inicialización; condición; incremento) sentencia
inicialización ----> asignación
Línea 47 ⟶ 42:
printf ("%d",x); Imprime los numeros del 1 al 100
=== While ===
while (condición) sentencia;
Línea 55 ⟶ 49:
while (c!='A') c=getchar( );
=== Do / While ===
Analiza la condició al final.
Línea 75 ⟶ 69:
Para salir de un programa anticipadamente. Da lugar a la terminación inmediata del programa, forzando la vuelta al S.O. Usa el archivo de cabecera stdlib.h
=== Ejemplo: ===
#include <stdlib.h>
main (void)
Línea 125 ⟶ 118:
}
== Arrays ==
Todos los arrays tienen el 0 como índice de su primer elemento.
char p [10]; array de carácteres que tiene 10 elementos, desde p[0] hasta p[9].
Línea 138 ⟶ 132:
func1 (int x[ ]) /array no delimitado/
9
=== Inicialización de arrays ===
Forma general de inicialización de un array:
tipo nombre_array [tamaño] = {lista de valores};
Línea 146 ⟶ 140:
char nombre_array [tamaño]="cadena";
Se añade automáticamente el terminador nulo al final de la cadena.
=== Ejemplo: ===
char cad[5]="hola"; equivalentes char cad[5]={'h','o','l','a','\o'};
Es posible que C calcule automáticamente las dimensiones de los arrays utilizando arrays indeterminados. Si en la inicialización no se especifica el tamaño el compilador crea un array suficientemente grande para contener todos los inicializadores presentes.
char e1[ ]="error de lectura \n";
=== Cadenas ===
Aunque C no define un tipo cadena, estas se definen como un array de carácteres de cualquier longitud que termina en un carácter nulo ('\0').
Array que contenga 10 carácteres: char s[11];
Línea 161 ⟶ 155:
int strcmp (const char *s1, const char *s2); compara s1 y s2, devuelve 0 si con iguales, mayor que cero si s1>s2 y menor que cero si s1<s2. Las comparaciones se hacen alfabéticamente.
10
=== Arrays Bidimensionales ===
Se declaran utilizando la siguiente forma general:
tipo nombre_array [tamaño 2ª dim] [tamaño 1ª dim];
Línea 171 ⟶ 165:
....................
}
=== Arrays y Punteros ===
Un nombre de array sin índice es un puntero al primer elemento del array.
Ejemplo: Estas sentencias son idénticas:
Línea 184 ⟶ 178:
a=&a[0][0];
a[0][4]=*((*a)+4);
=== Memoria dinámica ===
Malloc (n) reserva una porción de memoria libre de n bytes y devuelve un puntero sobre el comienzo de dicho espacio.
Free (p) libera la memoria apuntada con el puntero p.
Línea 190 ⟶ 184:
Si no hay suficiente memoria libre para satisfacer la petición, malloc ( ) devuelve un nulo.
11
=== Ejemplo: ===
char *p;
p=malloc(1000);
== Estructuras ==
La forma general de una definición de estructura es:
struct etiqueta {
Línea 201 ⟶ 195:
.............................
} variables _de_estructura
=== Ejemplo: ===
struct dir {
char nombre[30];
Línea 210 ⟶ 204:
} info_dir;
A los elementos individuales de la estructura se hace referencia utilizando . (punto).
=== Ejemplo: ===
info_dir.codigo = 12345;
Forma general es: nombre_estructura.elemento
Línea 222 ⟶ 216:
Arrays de estructuras
Se define primero la estructura y luego se declara una variable array de dicho tipo.
=== Ejemplo: ===
struct dir info_dir [100];
Para acceder a una determinada estructura se indexa el nombre de la estructura:
info_dir [2].codigo = 12345;
12
=== Paso de estructuras a funciones ===
Cuando se utiliza una estructura como argumento de una función, se pasa la estructura íntegra mediante el uso del método estándar de llamada por valor.
=== Ejemplo: ===
struct tipo_estructura {
int a,b;
Línea 246 ⟶ 240:
printf ("%d",param.a);
}
=== Punteros a estructuras ===
Declaración: struct dir * pruntero_dir;
Existen dos usos principales de los punteros a estructuras:
Línea 252 ⟶ 246:
2) para crear listas enlazadas y otras estructuras de datos dinámicas.
Para encontrar la dirección de una variable de estructura se coloca & antes del nombre de la estructura.
=== Ejemplo: ===
struct bal {
float balance;
Línea 261 ⟶ 255:
No podemos usar el operador punto para acceder a un elemento de la estructura a través del puntero a la estructura. Debemos utilizar el operador flecha ->
p -> balance
=== Tipo enumerado ===
enum identificador {lista de constantes simbólicas};
=== Ejemplo: ===
enum arcoiris {rojo, amarillo, verde, azul, blanco}; (realmente asigna rojo=0, amarillo=1, ...)
printf ("%d %d", rojo, verde); imprime 0 2 en pantalla
Línea 270 ⟶ 265:
Los valores son: penique 0, niquel 1, diez_centavos 2, cuarto 100, medio_dolar 101, dolar 102
(Libro pag. 167 )
== Punteros ==
int x=5, y=6;
int *px, *py;
Línea 285 ⟶ 280:
13
14
=== Punteros y arrays ===
char cad[80], *p1;
p1 = cad p1 ha sido asignado a la dirección del primer elemento del array
Línea 298 ⟶ 293:
Para encontrar el valor de var:
*x[2]
=== Punteros a punteros ===
puntero ----------> variable Indirección simple
puntero ---------> puntero ---------> variable Indirección múltiple
Línea 314 ⟶ 309:
}
15
=== E/S por consola ===
getche ( ) lee un carácter del teclado, espera hasta que se pulse una tecla y entonces devuelve su valor. El eco de la tecla pulsada aparece automáticamente en la pantalla. Requiere el archivo de cabecera conio.h
putcahr ( ) imprime un carácter en la pantalla.
Línea 320 ⟶ 315:
int getche (void);
int putchar (int c);
=== Ejemplo: ===
main ( ) /* cambio de mayúscula / minúscula */
{
Línea 337 ⟶ 332:
gets ( ) lee una cadena de carácteres introducida por el teclado y la situa en la dirección apuntada por su argumento de tipo puntero a carácter. Su prototipo es:
char * gets (char *cad);
=== Ejemplo: ===
main ( )
{
Línea 376 ⟶ 371:
int scanf ( ) (const char *cadena_fmt, ...);
=== Ejemplo: ===
scanf ("%d",&cuenta);
==== === Aritmética de punteros ===
==== Sinopsis === =====
La aritmética de punteros se limita a suma, resta, comparación y asignación. Las operaciones aritméticas en los punteros de tipoX (punteros-a-tipoX) tienen automáticamente en cuenta el tamaño real de tipoX. Es decir, el número de bytes necesario para almacenar un objeto tipoX [2]. Por ejemplo, suponiendo una matriz de double con 100 elementos, si ptr es un puntero a dicha matriz, la sentencia ptr++; supone incrementar el Rvalue de ptr en 6.400 bits, porque el tamaño de la matriz es precisamente 100x64 bits.
Nota: no confundir el puntero-a-matriz con un puntero a su primer elemento (que aquí sería puntero-a-double).
La aritmética realizada internamente en los punteros depende del modelo de memoria en uso y de la presencia de cualquier modificador superpuesto.
Las operaciones que implican dos punteros exigen que sean del mismo tipo o se realice previamente un modelado apropiado .
==== Operaciones permitidas ====
Sean ptr1, ptr2 punteros a objetos del mismo tipo, y n un tipo entero o una enumeración; las operaciones permitidas y los resultados obtenidos con ellas son:
Operación Resultado Comentario
pt1++ puntero Desplazamiento ascendente de 1 elemento
pt1-- puntero Desplazamiento descendente de 1 elemento
pt1 + n puntero Desplazamiento ascendente n elementos
pt1 - n puntero Desplazamiento descendente n elementos
pt1 - pt2 entero Distancia entre elementos
pt1 == NULL booleano Siempre se puede comprobar la igualdad o desigualdad con NULL
pt1 != NULL booleano
pt1 <R> pt2 booleano <R> es una expresión relacional
pt1 = pt2 puntero Asignación
pt1 = void puntero genérico Asignación
NOTA: La comparación de punteros solo tiene sentido entre punteros a elementos de la misma matriz; en estas condiciones los operadores relacionales ( 4.9.12): ==, !=, <, >, <=, >=, funcionan correctamente.
=== Ejemplos: ===
N. Expresión Resultado
1. ip+10; Produce otro puntero; Si ip es un puntero al elemento m[j] de una matriz (dicho de otro modo: si *ip == &m[j] ), el nuevo puntero apunta a otro elemento m[j+10] de la misma matriz, con lo que *(ip+10) == &m[j+10]
2. y = *ip+10; Añade 10 al objeto *ip (objeto referenciado por ip) y lo asigna a y
3. *ip += 1; Equivale a: *ip = *ip + 1. Incrementa en 1 el valor (Rvalue) del objeto referenciado por ip.
4. ++*ip; Igual que el anterior: incrementa en 1 el valor del objeto referenciado por ip
5. ++ip; El resultado es otro puntero. Equivale a ip = ip+1, es decir, incrementa en 1 el valor del puntero, con lo que el nuevo puntero señala a otra posición (ver caso 1.)
6. ip++; Igual que el caso anterior. Incrementa en 1 el valor del puntero.
7. (*ip)++ Igual que el caso 4. Dado que el paréntesis tiene máxima precedencia y asocia de izquierda a derecha, incrementa en 1 el valor del objeto referenciado por ip.
Observe que el paréntesis es necesario; sin él la expresión modifica la posición de memoria señalado por ip. Es decir, se realiza ip++;. Si ip es un puntero al elemento m[j] de una matriz, el resultado es un puntero al elemento m[j+1]. Después se tomaría la indirección, es decir, el resultado final sería el valor del elemento m[j+1].
Por tanto, la expresión *ip++ equivale a *(ip++)
8. *ip+1; El valor resultante es el de incrementar en 1 el valor del objeto apuntado por ip
{{navegación|[[Programación en C]]|[[Fundamentos de C - Lección 4]]|[[Fundamentos de C - Lección 6]]}}
| |||