UNIDAD II Elementos básicos de un lenguaje de programación (control y arreglos)

 2.1 Estructuras de control.

             Las estructuras de control también conocidas como ciclos, bucles, estructuras iterativas o repetitivas, son básicas para la elaboración de programas, ya que el repetir una tarea varias veces a una gran velocidad, precisión y fiabilidad es una de las características de las computadoras que aumentan considerablemente su potencia.  C soporta tres tipos de estructuras de control:

Ø      Ciclo while

Ø      Ciclo do_while

Ø      Ciclo for 

2.1.1 Teoría de ciclos.

            Un ciclo es cualquier construcción de programa que repite una sentencia o secuencia de sentencias un número de veces.  Las sentencias o grupo de sentencias que se repiten en un bloque se denominan cuerpo del bucle y cada repetición del cuerpo del ciclo se llama iteración del ciclo.

 

2.1.2 Contadores, acumuladores.

Contadores:

En los procesos repetitivos se necesita normalmente contar los sucesos o acciones internos del ciclo, como pueden ser: registro o elementos en un archivo y número de iteraciones a realizar por el ciclo.  Para realizar esta tarea se utilizan los contadores, cuya construcción es una de las técnicas corrientes en la realización de cualquier programa.

Un contador es un campo de la memoria que está destinado a contener los diferentes valores que se van incrementando o decrementando en cada iteración.  El campo contendrá las sucesivas sumas parciales que se van realizando en la ejecución de las sucesivas repeticiones.  El incremento en las sumas parciales es siempre constante, pudiendo ser positivo o negativo, es decir el contador se irá incrementando o decrementando.  El contador se representará en un programa por medio de una variable.

En las instrucciones de preparación del ciclo se realiza la inicialización del contador o contadores.  La inicialización de un contador consiste en poner el valor inicial de la variable que representa al contador.  

Ejemplos:

Contador =0                              Contador = 4

Por consiguiente, el contador se representará por una instrucción de asignación del tipo:

 

Contador = Contador + 1           Contador = Contador – 1

 

Siendo 1 el incremento del contador.

 

Acumuladores:

 Un acumulador es un campo o zona de memoria cuya misión es almacenar cantidades variables resultantes de sumas sucesivas.  Realiza la función de un contador con la diferencia que el incremento o decremento  de cada suma es variable en lugar de constante como en el caso del contador.  

Se representa por S=S+N donde N es una variable y no constante.

 Al igual que al contador a un acumulador se le inicializa.

 

2.1.3 Ciclos controlados por contadores, centinelas.  

Ciclos controlados por centinelas.

            Por lo general no se conoce con exactitud cuantos elementos de datos se procesarán antes de comenzar su ejecución.  Esto  se produce bien porque hay muchos datos a contar normalmente o porque el número de datos a procesar depende de cómo prosigue el proceso de cálculo.

            Un medio para manejar esta situación es instruir al usuario a introducir un único dato definido y especificado denominado valor centinela como último dato.  La condición del ciclo comprueba cada dato y termina cuando se lee el valor centinela.  El valor centinela se debe seleccionar con mucho cuidado y debe  ser un valor que no pueda producirse como dato.  En realidad el centinela es un valor que sirve para terminar el proceso de ciclo.

 

Ejemplo:

 

//En el siguiente fragmento  el centinela será –1

 const centinela =-1;

printf(“Introduzca la primer calificación “);

scanf(“%d”,&calif);

while(calif!=centinela)

{

 suma+=calif;

printf(“Introduzca la siguiente calificación “);

scanf(“%d”,&calif);

}  

En este caso  el ciclo se repetirá mientras la calificación sea diferente de –1, es decir mientras sea diferente del centinela.  

 

Ciclos controlado por contador.  

            Estos ciclos como su nombre lo indica son controlador por un contador, es decir en este tipo de ciclos se conoce el número de veces que este se repetirá desde el inicio del ciclo.  El ciclo que de forma natural es controlado por un contador es el ciclo for, en el caso de los ciclos while como ya se pudo ver se controlan de diferentes maneras una de ellas es por medio de un contador.  

Ejemplo:

El siguiente fragmento muestra un ciclo while que controlado por un contador se repetira 10 veces.

 int Contador =1;

while(Contador<=10)

{

 printf(“%d, “, Contador);

 Contador++;

}  

 

Ciclos controlados por indicadores (Banderas)

 En lenguajes como Pascal, que tienen el tipo bool, se utiliza una variable booleana con frecuencia como indicadores o banderas de estado para controlar la ejecución de un ciclo.  El valor del indicador se inicializa (normalmente a false“ ) antes de la entrada al ciclo y se redefine  (normalmente a verdadero “ true “) cuando un suceso específico ocurre dentro del ciclo.  En C no existe el tipo bolean, por lo que se utiliza como bandera una variable que puede tomar dos valores, 0 o 1.  Un ciclo controlado por bandera se ejecuta hasta que se produce un proceso anticipado y se cambia el valor del indicador.

 Ejemplo.

 Se desea leer diversos datos tipo carácter introducidos por teclado mediante un ciclo while y se debe terminar el ciclo cuando se lea un dato tipo dígito (0-9).

 La variable bandera, digito_leido  se utiliza como un indicador que representa cuando un dígito se ha producido por teclado.

 

Variable bandera

Significado

Digito_leido

Su valor es falso (cero) antes de entrar en el ciclo y mientras el dato leído sea un carácter y es verdadeo cuando el cuando el dato leído es un dígito.

 

El problema que se desea resolver es la lectura de datos carácter y la lectura debe detenerse cuando el dato leído sea numérico (un dígito de ‘0’ a ‘9’).  Por consiguiente, antes de que el ciclo se ejecute y se lean los datos de entrada, la variable digito_leido se inicializa en falso (cero).  Cuando se ejecuta el ciclo, éste debe continuar ejecutándose mientras el dato leído sea un carácter y en consecuencia la variabale digito_leido tiene de valor falso y se debe detener el ciclo cuando el dato leído sea un dígito y en este caso el valor de la variable dígito_leido debe cambiar a verdadero (uno).  En consecuencia la condición del ciclo debe ser !digito_leido ya que esta condición es verdadera cuando digito_leido es falso. El ciclo quedaría así:

  digito_leido=0;

while(!digito_leido)

{

     printf(“Introduzca un carácter: “);

     scanf(“%c”,&car);

     digito_leido=((‘0’<=car)&&(car<=’9’));

...

}

             

2.2 Tipos de ciclos

 2.2.1 for

   En C, el ciclo proporciona potencia y flexibilidad. Su formato General es el siguiente:

 

 for ( inicialización;prueba condicional;incremento)

                sentencia;

             La sección de inicialización es usada para asignar un valor inicial a la variable que controla el ciclo.  La sección de inicialización es ejecutada una sola vez. Antes del que ciclo empiece.

               La sección de prueba condicional del ciclo compara la variable de control contra un valor cada vez que el ciclo se repita. Si la prueba evalúa cierto (TRUE), el ciclo se repite. Si es falso (FALSE), el ciclo se detiene, y la ejecución del programa continua con la siguiente línea de código que le sigue al ciclo.

             La prueba condicional es ejecutada al comienzo de cada iteración.

               La sección de incremento del ciclo for es ejecutada al final de cada iteración. Esto es, La sección de incremento se ejecuta después de que el bloque de sentencias es ejecutado, pero antes de la prueba condicional. El propósito de la sección de incrementos es aumentar (o disminuir) la variable de control del ciclo en cierta cantidad.

             El ciclo for en C es más poderoso y flexible que el de otros lenguajes. Las secciones : inicialización, prueba condicional  e incremento no están limitadas a dichas actividades. El for de C no pone límites en el tipo de expresiones que ocurren ahí dentro. Por ejemplo, no se tiene que usar la sección de inicialización para asignar un valor inicial a la variable de control de ciclo. Más aún, no hay necesidad de utilizar una variable de control de ciclo cuando la prueba condicional se emplea de otra manera para terminar el ciclo. Finalmente, la sección de incremento es sólo una expresión que es evaluada cada vez que el ciclo itera (se repite). En ocasiones no se necesita incrementar ninguna variable.

            Otras de las flexibilidades del for en C es que pueden estar vacías algunas de las secciones anteriores, o tener varias expresiones en cada sección.

 Por ejemplo:

                  

x=1;                                                                                          for (x=1;x<=10;x++)

for (;x<=10;x++)                                                                         printf("su valor es %4d",x);

printf("su valor es %4d",x);

 En el ciclo for tanto la variable de control como las que se utilizan para la condición pueden ser del tipo entera o caracter, ya que la variable tipo carácter tiene una valor entero (código ASCII).

 Ejemplos  con el ciclo for:

 El siguiente programa imprime los números del 1 al  20  elevados al cuadrado:

 #include <stdio.h>

  main()

{ int num;

  for(num=1;num<=20;num++)

    printf(“%8d  %8d\n”,num, num*num);

}

El siguiente programa lee los números de 1 hasta N   y  los imprime al cuadrado:

#include <stdio.h>

 main()

{

 int num,N;

   printf(“Cuantos numeros quieres imprimir”);

  scanf(“%d”,&N);

  for(num=1;num<=N;num++)

    printf(“%8d  %8d\n”,num, num*num);

}

 

2.2.2 do()-while

Tiene la forma :

  do

  {

    sentencias

  } while(expresión);

El ciclo do_while repite una sentencia o varias sentencias mientras la expresión es cierta. Se detiene cuando la expresión de convierte falsa.

El ciclo do_while siempre se ejecuta al menos una vez, dado que la expresión controladora del ciclo se checa al final de cada iteración.

Sentencia

Expresión

 

 Ejemplo:

La siguiente sección  de programa pide una serie de números, determinado para cada uno si son pares o impares, este terminará cuando se teclee un * .

 do

{

 printf(“Teclea un número “);

scanf(“%”,&num);

if(num%2==0)

 printf(“Número par “);

else

 printf(“Número impar “);

 printf(“Teclee * para terminar “);

scanf(“%c”,&centinela);

}while(centinela !=’*’);

 

2.2.3 while()

 Un ciclo while tiene una condición del ciclo (una expresión lógica) que controla la secuencia de repetición.  La posición de esta condición del ciclo es delante del cuerpo de este y significa que un ciclo while es un ciclo pretest de modo que cuando se ejecuta el mismo, se evalúa la condición antes de que se ejecute el cuerpo del ciclo.

En la siguiente figura se representa el diagrama de flujo del ciclo.

 

Expresión

Sentencia

 

El diagrama indica que la ejecución de la sentencia o sentencias expresadas se repiten mientras que la condición sea verdadera, en el momento que esta es falsa termina.  También indica que la condición se evalúa antes de que se ejecute el cuerpo del ciclo y si desde un principio la condición es falsa este no se ejecuta.  Es decir que un ciclo while puede ejecutarse 0 o más veces.

 

Sintaxis:

 1.- while (condición_ciclo)

            sentencia;

 

2.- while (condición_ciclo )

    {

            sentencia 1;

            sentencia 2;

            .                                   cuerpo del ciclo

            .

            .

            sentencia n;

}    

 

El comportamiento o funcionamiento de una sentencia (ciclo) while es:

 

1.       Se evalua la condición_ciclo

2.       Si es verdadera (distinto de cero ):

a.       La sentencia especificada, denominada cuerpo del ciclo, se ejecuta.

b.      Vuelve el control al paso 1.

3.       En caso contrario:

a.       El control se transfiere a la sentencia siguiente al ciclo.

   

Ejemplo 1.

 

/* Cuenta hasta 10 */

int x=0;

while (x<10)

  printf(“X = %d”,x++);

 

Ejemplo 2.

 

/* Visualiza n asteriscos */

 

contador = 0;

while (contador < n)

{

printf (“*”);

contador++;

}

 

La variable que representa la condición del ciclo se denomina también variable de control del bucle debido a que su valor determina si el cuerpo del ciclo se repite.  La variable de control del ciclo debe ser: 1) inicializada, 2) comprobada, y 3) actualizada para que el cuerpo del ciclo se ejecute adecuadamente.

Cada etapa se resume así:

1.       Inicialización.  Contador se establece a un valor inicial (se inicializa a cero, aunque podría ser otro su valor) antes de que se alcance la sentencia while.

2.       Prueba/condición.  Se comprueba el valor de contador antes de que comience la repetición de cada ciclo (denominada iteración o pasada).

3.       Actualización. Contador se actualiza (su valor se incrementa en 1, mediante el operador ++) durante cada iteración.

 

Si la variable de control no se actualiza  el ciclo se ejecutara siempre, este se denominará ciclo infinito, en otras palabras el ciclo infinito será aquel en el cual su condición_ciclo nunca sea falsa.

 

Ejemplo

/* Ciclo infinito */

 

contador = 1;

while(contador < 100)

{

printf (“%d”, contador);

contador--;

}

 

el contador se decrementa en 1 por lo que siempre será menor a 100 y el ciclo nunca terminará de repetirse.    

   

2.3 Anidaciones.

Al  igual que en otras estructuras utilizadas dentro de el lenguaje C, los ciclos también se pueden anidar, de tal forma que dentro de un ciclo se incluya uno o más ciclos como parte del cuerpo de este.

Estos ciclos serán ciclos internos al primero, y por consiguiente cada que el ciclo que los contiene se repite estos se evaluará y/o se repetirán.

No existe restricción en lo que respecta a anidar un cilo de un tipo dentro de otro, es decir se puede perfectamente tener un ciclo while dentro de un cilo for o do_while.

Ejemplo:

El siguiente segmento generará las tablas de multiplicar del 1 al 5

for( x=1;x<=5;x++)

   for (y=1;y<=10;y++)

         printf(“%d x %d  = %d \n”, y,x,y*x);

 

El ciclo que tiene como variable de control y, se encuentra anidado dentro de el ciclo que tiene como variable de control x.

Este programa lee las temperaturas de los 365 días del año cada hora

#include <stdio.h>

void main(void)

 { float temp;

   int dias=1, horas;

 

   while(dias<=365)

   {

    for( horas=1;horas<=24;horas++)

    {

    printf(“Da la temperatura del día %d en la hora %d “,dias,horas);

    scanf(“%f”,&temp);

   }

   dias=dias+1;

  }

}

 

En este caso se encuentra anidado dentro de un ciclo while un ciclo for.

 

2.4 Introducción a arreglos.

Un arreglo se define como un grupo de datos homogéneos, ordenados y finitos.  Homogéneos porque todos los datos almacenados en el arreglo deben ser del mismo tipo, ordenados porque se encuentran en posiciones consecutivas de memoria y finitos porque siempre debe de ser una cantidad de elementos predefinidos desde un principio.  Por esta última razón estos también se definen como estructuras estáticas.

  Los arreglos se dividen es arreglos unidimensionales (también conocidos como vectores) y multidimensionales dentro de los cuales los que más manejaremos en  el curso serán los de dos dimensiones (también conocidos  como tablas o matrices).

      Los datos contenidos en un arreglo pueden ser cualquiera de los tipos de datos que conocemos en C, (char, flota, int, etc ), e incluso tipos de datos creados por el programador como lo serían las estructuras, las cuales se verán un poco más adelante.

      Cada uno de los datos contenidos en el arreglo se conoce como elemento del arreglo y la posición que este guarda en el mismo se maneja como subíndice, estos son consecutivos y siempre inician con la posición 0.

 

2.5 Arreglos unidimensionales.

 

Como ya se menciono anteriormente los arreglos unidimensionales también se conocen como vectores  y  como  su nombre lo indica son arreglos que tienen un salo dimensión.  La representación que le damos al arreglo es la siguiente:

 VECTOR_A  

12.2

10.7

7.8

98.2

54.0

0

1

2

3

4

 VECTOR DE 5 ELEMENTOS

El elemento VECTOR_A[0] contiene 12.2, VECTOR_A[1] contiene 10.7, VECTOR_A[2] contiene 7.8, VECTOR_A[3] contiene 98.2 y VECTOR_A[4] contiene 54.0.

Declaración de arreglos unidimensionales.

Tipo de dato   Nombre de la variable  [ dimensión ];

Donde:

Tipo de dato, es cualquier tipo de dato valido en C.

Nombre de la variable, el nombre que se le dará al arreglo.

Dimensión, el número de elementos s que contendrá el arreglo.

 

Por ejemplo:

int  VECTOR_A [5];      //Declaración de un arreglo de enteros de 5 elementos.

float  VECTOR_B[5];    // Declaración de un arreglo de flotantes de 5 elementos

char VECTOR_C[5][;   //Declaración de un arreglo de caracteres de 5 elementos.

char VECTOR_D[5][10]; //Declaración de un arreglo de 5 cadenas de caracteres de una longitud de 10 cada una.

 

Inicialización de vectores.

Al igual que las variables sin dimensión a los vectores también se les puede dar un valor inicial, la forma de hacer esto es :

int  VECTOR_A [5] = { 1,2,3,4,5 };     

float  VECTOR_B[5] = { 1.1,2.3,4,5,6.7,9.6};   

char VECTOR_C[5][ = { ‘s ‘, ‘d’, ‘p’, ‘#’, ‘2’}; 

char VECTOR_D[5][10] = { “uno”, “dos”, “tres”, “cuatro”, “cinco”};

En caso de que se quisiera inicializar todos los elementos del arreglo a 0 únicamente se pone:

int  VECTOR [5] ={0};

 

Acceso a los elementos de un vector:

Nombre de la variable [ posición ]

OPERACIONES BASICAS DE UN VECTOR

Dentro de las operaciones básicas que se efectúan sobre un vector tenemos las de lectura, escritura, ordenación y búsqueda.

 Lectura de los elementos de un vector:

 scanf(“%especificador”, & vector[posición]);

 lógicamente, si son varios elementos se utilizará un ciclo y  posición será un contador que se incrementará de acuerdo al número de elementos que tenga el arreglo.

 

EJEMPLO DE LECTURA DE UN VECTOR DE ENTEROS.

 int Vector[20];

 for ( posicion=0;posicion<20;posicion++)

   scanf(“%d”,&Vector[posición]); 

 Escritura de los elementos de un vector:

 

printf(“%especificador”,vector[posición]);

 lógicamente, si son varios elementos se utilizará un ciclo y  posición será un contador que se incrementará de acuerdo al número de elementos que tenga el arreglo.

 EJEMPLO DE ESCRITURA DE UN VECTOR DE ENTEROS.

 

for ( posicion=0;posicion<20;posicion++)

   printf(“%d”,Vector[posición]); 

 

Búsqueda .  

La operación de búsqueda es básica en cualquier estructura de datos, esta se refiere como su nombre lo indica a buscar dentro de un grupo de datos un dato o un conjunto de datos en especial, existen diferentes tipos de búsquedas, la más sencilla de ellas es la búsqueda lineal, que es la que se explicará a continuación:

 BÚSQUEDA LINEAL.

 Esta consiste en revisar elementos por elemento el arreglo hasta encontrar el elemento a buscar, cuando este no se repite en el arreglo en el momento que se encuentra la búsqueda se puede abandonar, pero si hay más de una ocurrencia de el elemento a buscar en el arreglo se sigue revisando el arreglo hasta llegar a  la ultima posición de éste.

 EJEMPLO DE UNA BÚSQUEDA LINEAL CUANDO EL ELEMENTO A BUSCAR SOLO SE ENCUENTRA UNA VEZ EN EL ARREGLO.

 Int E_buscar, Vector[20], pos=-1, p;

 printf(“Cual es elemento que buscas “);        //Guardas el elemento que buscas en E_buscar

scanf(“%d”, &E_buscar);

 for(p=0;p<20;p++)   //Recorres el vector desde el primer elemento hasta el último

 if(Vector[p]==E_buscar)      //si el E_buscar es igual a lo que esta en el vector en la posición p

   { pos=p;              //Guardas el valor de p (la posicion donde se encontró) en pos

      break;               //Abandonas el ciclo                                        

   }

 if (pos==-1)             //Si pos resulta ser igual a –1 no se encontro, ya que era el valor inicial y nunca se modifico, es decir no se cumplio la condición.

 printf(“El elemento no se encontró “);

else                                    //Si pos es diferente de –1 si lo encontro y esta en pos

 printf(“El elemento se encuentra en la posición %d”, pos);

 EJEMPLO DE UNA BÚSQUEDA LINEAL CUANDO EL ELEMENTO A BUSCAR SOLO SE ENCUENTRA MAS DE UNA VEZ EN EL ARREGLO.

 Int E_buscar, Vector[20],  p;

 printf(“Cual es elemento que buscas “);        //Guardas el elemento que buscas en E_buscar

scanf(“%d”, &E_buscar);

 for(p=0;p<20;p++)   //Recorres el vector desde el primer elemento hasta el último

 if(Vector[p]==E_buscar)      //si el E_buscar es igual a lo que esta en el vector en la posición p se imprime cuantas veces se encuentre.

      printf(“Esta en la posición %d \n ”,p

 

ORDENACIÓN  

Una de las operaciones básicas que se aplican en vectores es la ordenación de estos.  La ordenación consiste en reagrupar ya sea en órden ascendente o descendente los elementos del vector.

Existen diferentes métodos de ordenación uno de ellos es el método de ordenación de la burbuja, este es cuando el número de elementos a ordenar es de tamaño pequeño ya que el método consiste en tomar el primer elemento del vector y compararlo con el resto de los elementos, de tal forma que  cada que encuentra un elemento menor al que se esta comparando este se intercambia,  al finalizar la primer pasada por los elementos del vector el elemento mayor del vector quedará en la última posición(si la ordenación es ascendente) , el proceso se repite con todos los demás elementos del vector hasta que éste queda ordenado.

Por ejemplo si  se tiene el siguiente grupo de números :  

      23         2          56         1           

Estos se quieren ordenar en forma ascendente,  

Primer pasada

 

0

23

 23 > 2 si hay intercambio

0

2

 

0

2

 

0

2

1

2

 

1

23

23 >56 no hay intercambio

1

23

 

1

23

2

56

 

2

56

 

2

56

56>1 si hay intercambio

2

1

3

1

 

3

1

 

3

1

 

3

56

 

Como se puede apreciar, cuando el elemento que se esta comparando es mayor que el que le sigue este se intercambia, de tal forma que el elemento mayor queda en la última posición.  

Segunda pasada  

0

2

 2 > 23 no hay intercambio

0

2

 

0

2

1

23

 

1

23

23 >1 si hay intercambio

1

1

2

1

 

2

1

 

2

23

3

56

 

3

56

 

3

56

 

En esta segunda pasada, ya no se comparó con el último elemento, pues este ya esta ordenado.

 Tercera pasada

 

0

2

 2 > 1 si hay intercambio

0

1

1

1

 

1

2

2

23

 

2

23

3

56

 

3

56

 

 Al finalizar, el vector queda ordenado.  

Si hacemos el código para este método tomando K para las pasadas , j como subíndice para las posiciones y N para el número de elementos quedaría así:  

 

For(k=1;k<N;k++)

  For(j=0;j<N-k;j++)

     If(Vector[j]>Vector[j+1])

        { aux=Vector[j];

           Vector[j]=Vector[j+1];

            Vector[j+1]=aux;

      }         

 

2.5.1 Manipulación de los arreglos de caracteres.  

Una cadena de texto es un conjunto de caracteres, tales como  <<ABCDEFG>>.  C soporta cadenas de texto utilizando un array de caracteres que contenga una secuencia de caracteres:  

char cadena[  ] = “ABCDEFG “;

 Es importante comprender la diferencia entre array de caracteres y una cadena de caracteres.  Las cadenas contienen un carácter nulo al final del array de caracteres.  

Las cadenas se deben almacenar en arrays de caracteres, pero no todos los arrays de caracteres contienen cadenas.

 EJEMPLO:

 Array de caracteres: 

A

B

C

D

E

[0]

[1]

[2]

[3]

[4]

 Cadena de caracteres:

  

A

B

C

D

E

\0

[0]

[1]

[2]

[3]

[4]

[5]

 Las cadenas se señalan incluyendo un carácter al final de la cadena: el carácter nulo (\0), cuyo valor en el código ASCII es 0.  El medio más fácil de inicializar un array de caracteres es hacer la inicialización de la declaración:

 char cadena[ 7 ] = “ABCDEFG “;

El compilador inserta automáticamente un carácter nulo al final de la cadena, de modo que la secuencia real sería:

 

A

B

C

D

E

F

G

\0

[0]

[1]

[2]

[3]

[4]

[5]

[6]

[7]

 

La asignación se puede hacer también del siguiente modo:

cadena[0]=’A’;

cadena[1]=’B’;

cadena[2]=’C’;

cadena[3]=’D’;

cadena[4]=’E’;

cadena[5]=’F’;

cadena[6]=’G’;

cadena[7]=’\0’;

 

sin embargo no se puede asignar del siguiente modo:

cadena=” ABCDEF”;

Para copiar una constante cadena o copiar una variable de cadena a otra variable de cadena se debe utilizar la función de la biblioteca estándar  - srtcpy() copiar cadenas -  lo cual quedaría:

strcpy(cadena,”ABCDEFG “);  

EJEMPLO

 //El siguiente segmento de programa muestra una cadena de caracteres en forma vertical.

 char  cadena[ ]=”Ejemplo de manipulación de cadenas “;

int pos;

for(pos=0;cadena[pos];pos++)     // Mientras no se llegue al carácter nulo el ciclo se repite

printf(“%c\n”,cadena[pos]);          // Imprime cada una de los elementos de la cadena.

 

Cuando estamos manejando un arreglo de caracteres, este se maneja de la misma forma que los arreglo numéricos, que son los que se verán a continuación.

 

Funciones para la manipulación de cadenas #include<string.h>

strlen(s1) 

Regresa el numero de bytes (caracteres) en la cadena s1, no incluye el carácter nulo o fin de cadena.

strcmp(s1,s2) 

Compara las cadenas s1 y s2, regresando un valor igual a cero, si ambas cadenas son iguales, mayor a cero, si s1 es mayor que s2 o menor que cero si s1 es menor que s2.

strcpy(s1,s2) 

Copia el contenido de la cadena s2 en la cadena s1, incluyendo el carácter nulo.

strcat(s1,s2)

Agrega la cadena s2, a el final de la cadena s1, eliminando de s1 el carácter nulo de fin de cadena.

 Funciones para la manipulación de caracteres #include<ctype.h>

isalnum()

Verifica si un carácter es alfanumérico o numérico.

isalpha()   

Verifica si un carácter es alfabético.

isascii()    

Verifica si un carácter pertenece a los primeros 127 caracteres de la tabla ASCII.

isblank()   

Verifica si un carácter es un espacio en blanco o tabulador.

isdigit()   

Verifica si un carácter es numérico.

islower()   

Verifica si un carácter es una letra minúscula.

isupper()   

Verifica si un carácter es una letra mayúscula.

tolower()   

Convierte una letra a su correspondiente minúscula.

toupper()   

Convierte una letra a su correspondiente mayúscula.

 

 

2.5.3 Operaciones con arreglos numéricos.  

Ya se vio antes como declarar, inicializar y accesar a los elementos de arreglo unidimensional , ahora se mostrarán operaciones básicas con arreglos unidimensionales.

 EJEMPLO

/* El siguiente programa lee un vector de 10 elementos y solo imprime los elementos del vector que sean mayores a la media */

 #include <stdio.h>

 main()

{

 int vector[10], suma=0, prom, x;

//Llenado del arreglo

 for(x=0;x<10;x++)

{

 printf(“Teclea el elemento de la posición %d ”,x);

 scanf(“%d”,&vector[x]);

 suma+=vector[x];

}

 prom=suma/10;

 //Impresión de los elementos mayores a la media

 for(x=0;x<10;x++)

  if(vector[x]>prom)

      printf(“%d es mayor a la media “, vector[x]);

 }

 En el segundo ciclo al mismo tiempo que estamos viendo como mostrar el contenido de un vector, estamos realizando una búsqueda lineal tomando como base el promedio, hacemos una revisión del vector y en el momento que se cumple la condición se imprime el contenido del vector, si no existiera esta condición se mostrarían todos los elementos del vector.  

2.6 Arreglos bidimensionales.

       Como ya se menciono antes, estos también se conocen como matrices o tablas, estos son arreglos que tienen 2 dimensiones.  La declaración de estos es similar a los de una sola dimensión pero por lógica esto deberán de tener 2 dimensiones.

 Declaración:

 Tipo de dato   Nombre de la variable [indice del renglón] [ indicie de la columna];

 EJEMPLO:  

  int  MATRIZ_A [5][2];      //Declaración de un arreglo de enteros de 5 renglones por 2 columnas.

float  MATRIZ_B[5][2];    // Declaración de un arreglo de flotantes de 5 renglones por 2 columnas.

char MATRIZ_C[5][2];   //Declaración de un arreglo de caracteres de 5 renglones por 2 columnas.

char MATRIZ_D[5][10]; //Declaración de un arreglo de 5 cadenas de caracteres por 2 columnas de una longitud de 10 cada una.

 La representación de un arreglo bidimensional es como sigue:

 MATRIZ  

 

0

1

0

12

3

1

34

6

2

5

56

3

43

4

4

51

5

 

Los elementos de MATRIZ son:

MATRIZ[0][0] es igual a 12, MATRIZ[0][1] es igual a 3, MATRIZ[1][0] es igual a 34, MATRIZ[1][1] es igual a 6, MATRIZ[2][0] es igual a 5, MATRIZ [2][1] es igual a 56, MATRIZ [3][0] es igual a 43, MATRIZ [3][1] es igual a 4, MATRIZ [4][0] es igual a 51, MATRIZ[4][1] es igual a 5.  

Cuando un arreglo bidimensional tiene el mismo número de renglones y columnas, se dice que es una matriz cuadrada.

 Inicialización de arreglos bidimensionales.

Estos se pueden inicializar al igual que los de una sola dimensión, cuando se declaran.  La inicialización consta de una lista de constantes separadas por comas y encerradas entre llaves, como en el siguiente ejemplo:

int MATRIZ[2][3] = { 51,52,53,54,55,56};

o bien más amigables:

int  MATRIZ[2][3] = { {51,52,53},

                                  {54,55,56} };

y como ya sabe, los caracteres serán entre apostrofes y las cadenas entre comillas.

Acceso a los elementos de los arreglos bidimensionales.

Se puede acceder a los elementos del arreglo bidimensional de igual forma que los elementos de una arreglo unidimensional.  La diferencia reside en que los elementos bidimensionales deben especificarse los índices de la fila y la columna.

      El formato general es:

      Nombre de la variable [renglón] [columna] = valor;

      Valor = Nombre de la variable [renglón] [columna];

EJEMPLO:

MATRIZ[0][0] = 34;

VALOR = MATRIZ[1][2];

Lectura y escritura de los elementos de los arreglos bidimensionales.

Esta se puede hacer de elemento por elemento, pero esto resultaría  poco practico, es por eso que por lo general nos auxiliamos de ciclos anidados para esto.

Si lo hacemos sin ciclos:

int  MATRIZ[2][2];

//Lectura:

printf(“Teclea el valor del  elemento [0][0] de la MATRIZ “);

scanf(“%d”, &MATRIZ[0][0]);

//Escritura:

printf (“El elemento [0][0] de la  MATRIZ es %d”, MATRIZ[0][0]);

 

Si utilizamos ciclos:

int renglon, columna, MATRIZ[2][3];

//Lectura de la matriz

 for (renglón=0;renglón<2;renglón++)

    for(columna=0;columna<3;columna++)

      {

         printf(“Teclea el valor del elemento [%d][%d] “, renglón,columna);

         scanf(“%d”,&MATRIZ[renglón][columna]);

    } 

//Escritura de la matriz

for (renglón=0;renglón<2;renglón++)

    for(columna=0;columna<3;columna++)

         printf(“%d es el  elemento [%d][%d]  de la MATRIZ“, MATRIZ[renglón][columna],renglón,columna);

2.7 Arreglos multidimensionales.

 Los arreglos multidimensionales son aquellos que tienen más de una dimensión, dentro de estos se encuentran los arreglos bidimensionales.

 La declaración, inicialización y acceso es igual a las mencionadas anteriormente en los vectores y matrices, solo que en este caso dependerá de las  dimensiones que se estén manejando.

EJEMPLO DE UN ARREGLO DE 3 DIMENSIONES.

int  x,y,z,ARREGLO[2][3][4];

//Lectura

for(x=0;x<2;x++)

  for(y=0;y<3;y++)

     for(z=0;z<4;z++)

          {

            printf(“Teclea el valor del elemento [%d][%d][%d] “, x,y,z);

             scanf(“%d”,&ARREGLO[x][y][z]]);

            }

 

//Escritura

for(x=0;x<2;x++)

  for(y=0;y<3;y++)

     for(z=0;z<4;z++)

            printf(“%d es el valor del elemento [%d][%d][%d] “,ARREGLO[x][y][z], x,y,z);

 

 

Página elaborada por : Ing. Eva Herrera Ramírez

Bibliografía: Programación en C de Luis Joyanes