unidad 5 programacion

5.1 Arreglos unidimensionales y multidimensionales

Los arreglos son una colección de variables del mismo tipo que se referencian utilizando un nombre común. Un arreglo consta de posiciones de memoria contigua. La dirección más baja corresponde al primer elemento y la más alta al último. Un arreglo puede tener una o varias dimensiones. Para acceder a un elemento en particular de un arreglo se usa un índice.
El formato para declarar un arreglo unidimensional es:
tipo nombre_arr [ tamaño ]
Por ejemplo, para declarar un arreglo de enteros llamado listanum con diez elementos se hace de la siguiente forma:

int listanum[10];

En C, todos los arreglos usan cero como índice para el primer elemento. Por tanto, el ejemplo anterior declara un arreglo de enteros con diez elementos desde listanum[0] hasta listanum[9].
La forma como pueden ser accesados los elementos de un arreglo, es de la siguiente forma:

listanum[2] = 15; /* Asigna 15 al 3er elemento del arreglo listanum*/
num = listanum[2]; /* Asigna el contenido del 3er elemento a la variable num */

El lenguaje C no realiza comprobación de contornos en los arreglos. En el caso de que sobrepase el final durante una operación de asignación, entonces se asignarán valores a otra variable o a un trozo del código, esto es, si se dimensiona un arreglo de tamaño N, se puede referenciar el arreglo por encima de N sin provocar ningún mensaje de error en tiempo de compilación o ejecución, incluso aunque probablemente se provoque el fallo del programa. Como programador se es responsable de asegurar que todos los arreglos sean lo suficientemente grandes para guardar lo que pondrá en ellos el programa.
C permite arreglos con más de una dimensión , el formato general es:

tipo nombre_arr [ tam1 ][ tam2 ] ... [ tamN];

Por ejemplo un arreglo de enteros bidimensionales se escribirá como:

int tabladenums[50][50];

Observar que para declarar cada dimensión lleva sus propios paréntesis cuadrados.
Para acceder los elementos se procede de forma similar al ejemplo del arreglo unidimensional, esto es,

tabladenums[2][3] = 15; /* Asigna 15 al elemento de la 3ª fila y la 4ª columna*/
num = tabladenums[25][16];

A continuación se muestra un ejemplo que asigna al primer elemento de un arreglo bidimensional cero, al siguiente 1, y así sucesivamente.

main()
{
    int t,i,num[3][4];

    for(t=0; t<3; ++t)
        for(i=0; i<4; ++i)
            num[t][i]=(t*4)+i*1;

    for(t=0; t<3; ++t)
    {
        for(i=0; i<4; ++i)
            printf("num[%d][%d]=%d  ", t,i,num[t][i]);
        printf("\n");
    }

}

En C se permite la inicialización de arreglos, debiendo seguir el siguiente formato:

tipo nombre_arr[ tam1 ][ tam2 ] ... [ tamN] = {lista-valores};

Por ejemplo:

int i[10] = {1,2,3,4,5,6,7,8,9,10};
int num[3][4]={0,1,2,3,4,5,6,7,8,9,10,11};

unidad 4 Programacion

4.1 La sentencia for

La sentencia for tiene el siguiente formato:

for ( expresion1; expresion2; expresion3)

sentencia;
o { bloque de sentencias }

En donde expresion1 se usa para realizar la inicialización de variables, usando una o varias sentencias, si se usan varias sentencias deberá usarse el operador , para separarlas. Por lo general, establece el valor de la variable de control del ciclo. expresion2 se usa para la condición de terminación del ciclo y expresion3 es el modificador a la variable de control del ciclo cada vez que la computadora lo repite, pero también puede ser más que un incremento.
Por ejemplo:

int X;

main()
{
    for( X=3; X>0; X--)
    {
        printf("X=%d\n",X);
    }
}

genera la siguiente salida a pantalla ...

X=3
X=2
X=1

Todos las siguientes sentencias for son válidas en C. Las aplicaciones prácticas de tales sentencias no son importantes aquí, ya que tan sólo se intenta ilustrar alguanas características que pueden ser de utilidad:

for ( x=0; ( (x>3) && (x<9) ); x++ )

for ( x=0, y=4; ( (x>3) && (x<9) ); x++, y+=2)

for ( x=0, y=4, z=4000; z; z/=10)

En el segundo ejemplo se muestra la forma como múltiples expresiones pueden aparecer, siempre y cuando estén separadas por una coma ,
En el tercer ejemplo, el ciclo continuará iterando hasta que z se convierta en .

4.2 La sentencia while

La sentencia while es otro ciclo o bucle disponible en C. Su formato es:

while ( expresion) sentencia;

donde sentencia puede ser una sentencia vacía, una sentencia única o un bloque de sentencias que se repetirán. Cuando el flujo del programa llega a esta instrucción, primero se revisa si la condición es verdad para ejecutar la(s) sentencia(s), y después el ciclo while se repetirá mientras la condición sea verdadera. Cuando llega a ser falsa, el control del programa pasa a la línea que sigue al ciclo.
En el siguiente ejemplo se muetra una rutina de entrada desde el teclado, la cual se cicla mientras no se pulse A:

main()
{
    char carac;

    carac = '\0';
    while( carac != 'A') carac = getchar();
}

Antes de entrar al ciclo se inicializa la variable carac a nulo. Después pasa a la sentencia while donde se comprueba si carac no es igual a 'A', como sea verdad entonces se ejecuta la sentencia del bucle (carac = getchar();). La función getchar() lee el siguiente carácter del flujo estándar (teclado) y lo devuelve, que en nuestro ejemplo es el caracter que haya sido tecleado. Una vez que se ha pulsado una tecla, se asigna a carac y se comprueba la condición nuevamente. Después de pulsar A, la condición llega a ser falsa porque carac es igual a A, con lo que el ciclo termina.
De lo anterior, se tiene que tanto el ciclo for, como el ciclo while comprueban la condición en lo alto del ciclo, por lo que el código dentro del ciclo no se ejecuta siempre.
A continuación mostramos otro ejemplo:

main()
{
    int x=3;

    while( x>0 ) 
    {
        printf("x = %d\n", x);
        x--;
    }
}

que genera la siguiente salida en pantalla:

x = 3
x = 2
x = 1

Como se observa, dentro del ciclo tenemos más de una sentencia, por lo que se requiere usar la llave abierta y la llave cerrada { ... } para que el grupo de sentencias sean tratadas como una unidad.
Como el ciclo while pueda aceptar también expresiones, y no solamente condiciones lo siguiente es válido:

while ( x-- );

while ( x = x + 1 );

while ( x += 5 );

Si se usan este tipo de expresiones, solamente cuando el resultado de x--, x=x+1 o x+=5 sea cero, la condición fallará y se podrá salir del ciclo.
De acuerdo a lo anterior, podemos realizar una operación completa dentro de la expresión. Por ejemplo:

main()
{
    char carac;

    carac = '\0';
    while ( (carac = getchar()) != 'A' )
        putchar(carac);
}

En este ejemplo se usan las funciones de la biblioteca estándar getchar() -- lee un caracter del teclado y putchar() escribe un caracter dado en pantalla. El ciclo while procederá a leer del teclado y lo mostrará hasta que el caracter A sea leído.

4.3 La sentencia do-while

Al contrario de los ciclos for y while que comprueban la condición en lo alto del bucle, el bucle do ... while la examina en la parte baja del mismo. Esta característica provoca que un ciclo do ... while siempre se ejecute al menos una vez. La forma general del ciclo es:

do {

sentencia;

} while (condición);

Aunque no son necesarias las llaves cuando sólo está presente una sentencia, se usan normalmente por legibilidad y para evitar confusión (respecto al lector, y no del compilador) con la sentencia while.
En el siguiente programa se usa un ciclo do ... while para leer números desde el teclado hasta que uno de ellos es menor que o igual a 100:

main()
{
    int num;

    do 
    { 
        scanf("%d", &num);
    } while ( num>100 );
}

Otro uso común de la estructura do ... while es una rutina de selección en un menú, ya que siempre se requiere que se ejecute al menos una vez.

main()
{
    int opc;

    printf("1. Derivadas\n");
    printf("2. Limites\n");
    printf("3. Integrales\n");

    do 
    {
        printf("   Teclear una opcion:  ");
        scanf("%d", &opc);

        switch(opc)
        {
            case 1:
                printf("\tOpcion 1 seleccionada\n\n");
                break;
            case 2:
                printf("\tOpcion 2 seleccionada\n\n");
                break;
            case 3:
                printf("\tOpcion 3 seleccionada\n\n");
                break;
            default:
                printf("\tOpcion no disponible\n\n");
                break;
        }
    } while( opc != 1  &&  opc != 2  &&  opc != 3);
}

Se muestra un ejemplo donde se reescribe usando do ... while uno de los ejemplos ya mostrados.

main()
{
    int x=3;

    do  
    {
        printf("x = %d\n", x--);
    }
    while( x>0 ) ;
}