U.A.B.C.

Facultad de Ingeniería
Programación Estructurada UNIDAD II

UNIDAD II Elementos básicos de un lenguaje de programación.

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

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.

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.

Ing. Pablo M. Navarro Álvarez Página # 1

 U.A.B.C.
Facultad de Ingeniería
Programación Estructurada UNIDAD II

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.

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(nota!=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 controlados 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 repetirá 10 veces.

Ing. Pablo M. Navarro Álvarez Página # 2

 U.A.B.C.
Facultad de Ingeniería
Programación Estructurada UNIDAD II

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 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 ha sido leído por teclado. 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.

Ciclo for
En C, el ciclo for proporciona potencia y flexibilidad. Su sintaxis General es la
siguiente:
for ( inicialización;prueba condicional;incremento) sentencia;

Ing. Pablo M. Navarro Álvarez Página # 3

 U.A.B.C.
Facultad de Ingeniería
Programación Estructurada UNIDAD II

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.
Las sentencias incluidas entre llaves { . . .} se denominan bloque. Un programa
debe de tener sólo una función main(). Si se intenta hacer dos funciones main( ) se
produce un error. Además de la función main( ), un programa en C consta de una
colección de funciones. Todos los programas se construyen a partir de una o más
funciones que se integran para crear una aplicación. Todas las funciones contienen una o
más sentencias C y se crean generalmente para realizar una única tarea, tales como
imprimir la pantalla, escribir un archivo o Cambiar el color de la pantalla. Se puede
declarar y ejecutar un número de funciones casi ilimitado en un programa C.
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:

Ing. Pablo M. Navarro Álvarez Página # 4

 U.A.B.C.
Facultad de Ingeniería
Programación Estructurada UNIDAD II

#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);
}

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. Este ciclo siempre se ejecuta
al menos una vez, dado que la expresión controladora del ciclo se checa al final de cada
iteració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 !=‟*‟);

Ing. Pablo M. Navarro Álvarez Página # 5

 U.A.B.C.
Facultad de Ingeniería
Programación Estructurada UNIDAD II

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.
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 evalúa la condición del 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.

Ing. Pablo M. Navarro Álvarez Página # 6

 U.A.B.C.
Facultad de Ingeniería
Programación Estructurada UNIDAD II

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 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.

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 1: 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.

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

Ing. Pablo M. Navarro Álvarez Página # 7

 U.A.B.C.
Facultad de Ingeniería
Programación Estructurada UNIDAD II

#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.

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.

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: VECTOR DE 5 ELEMENTOS

12.2 10.7 7.8 98.2 54.0

0 1 2 3 4
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.

Ing. Pablo M. Navarro Álvarez Página # 8

 U.A.B.C.
Facultad de Ingeniería
Programación Estructurada UNIDAD II

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.
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};
Para acceder a los elementos de un vector, solo de debe de utilizar la siguiente
sintaxis: 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 para la lectura de un vector de valores enteros:
int Vector[20];
for ( posicion=0;posicion<20;posicion++)
scanf(“%d”,&Vector[posición]);

Ing. Pablo M. Navarro Álvarez Página # 9

 U.A.B.C.
Facultad de Ingeniería
Programación Estructurada UNIDAD II

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 para la escritura de un vector de valores 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 todo el vector desde el 1º hasta el último
if(Vector[p]==E_buscar)//si E_buscar es igual a lo que esta en Vector[p]
{ pos=p; //Guardas la posicion p donde se encontró en pos
break; //Abandonas el ciclo
}
if (pos==-1) //Si pos es igual a –1 no se encontró, ya que era el valor
inicial y nunca se modifico, es decir no se cumplió la condición.
printf(“El elemento no se encontró “);
else //Si pos es diferente de –1 si lo encontró 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 se encuentra mas

de una vez en el arreglo.

Ing. Pablo M. Navarro Álvarez Página # 10

 U.A.B.C.
Facultad de Ingeniería
Programación Estructurada UNIDAD II

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 1º elemento hasta el
último
if(Vector[p]==E_buscar) //si E_buscar es igual a Vector[p] se imprime.
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 y se quieren ordenar en

forma ascendente:

23 2 56 1

Primer pasada

0 23 23 > 2 si hay 0 2 0 2 0 2
intercambio
1 2 1 23 23 >56 no hay 1 23 1 23
intercambio
2 56 2 56 2 56 56>1 si hay 2 1
intercambio
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.

Ing. Pablo M. Navarro Álvarez Página # 11

 U.A.B.C.
Facultad de Ingeniería
Programación Estructurada UNIDAD II

Segunda pasada

0 2 2 > 23 no hay 0 2 0 2
intercambio
1 23 1 23 23 >1 si hay 1 1
intercambio
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 0 1
intercambio
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;
}

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 de un array de caracteres:
A B C D E
[0] [1] [2] [3] [4]

Ing. Pablo M. Navarro Álvarez Página # 12

 U.A.B.C.
Facultad de Ingeniería
Programación Estructurada UNIDAD II

Ejemplo de una 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 arreglos numéricos, que son los que se verán a continuación.

Ing. Pablo M. Navarro Álvarez Página # 13

 U.A.B.C.
Facultad de Ingeniería
Programación Estructurada UNIDAD II

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

strlen(s1) Regresa el número 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.

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;
for(x=0;x<10;x++) //Llenado del arreglo
{
printf(“Teclea el elemento de la posición %d ”,x);
scanf(“%d”,&vector[x]); suma+=vector[x];
}
prom=suma/10;
for(x=0;x<10;x++) //Impresión de los elementos mayores a la media
if(vector[x]>prom)
printf(“%d es mayor a la media “, vector[x]);
}

Ing. Pablo M. Navarro Álvarez Página # 14

 U.A.B.C.
Facultad de Ingeniería
Programación Estructurada UNIDAD II

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.

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 estos deberán de tener 2 dimensiones.
Declaración:
Tipo de dato Nombre_variable [indice del renglón] [ indicie de la columna];
Ejemplo:
int MATRIZ_A [5][2]; //Declaración de arreglo de enteros, 5 renglones
por 2 columnas.
float MATRIZ_B[5][2]; //Declaración arreglo de flotantes, 5 renglones
por 2 columnas.
char MATRIZ_C[5][2]; //Declaración arreglo de caracteres, 5 renglones
por 2 columnas.
char MATRIZ_D[5][10]; //Declaración de arreglo, 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.

Ing. Pablo M. Navarro Álvarez Página # 15

 U.A.B.C.
Facultad de Ingeniería
Programación Estructurada UNIDAD II

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 un 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]);
}

Ing. Pablo M. Navarro Álvarez Página # 16

 U.A.B.C.
Facultad de Ingeniería
Programación Estructurada UNIDAD II

//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);

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);

Ing. Pablo M. Navarro Álvarez Página # 17