INSTITUTO TECNOLOGICO DE ORIZABA

Programación
Ing. Eléctrica
Arreglos en C++

Un arreglo es una colección ordenada de variables del mismo tipo. Las variables que
pertenecen a un arreglo se conocen por el nombre de elementos. El término ordenado
significa que en la colección hay un primer elemento, un segundo elemento, un tercer
elemento, y así sucesivamente. Además, los elementos pueden a su vez organizarse en
subgrupos llamadas dimensiones.
En resumen, un arreglo:
•No es una variable; es un grupo de variables conocidas como elementos
•Cada elemento ocupa una posición dentro del grupo
•Todos los elementos son del mismo tipo
•El nombre del arreglo indica donde se localiza el grupo en la memoria de la computadora.
•Los arreglos se clasifican de acuerdo a las dimensiones que tengan
•Las dimensiones no tienen relación con el plano Cartesiano; nada que ver con matemática
•Las dimensiones indican como están organizados los elementos dentro del grupo
•Los arreglos de dos dimensiones pueden visualizarse como tablas
•Los valores que se guarden en el arreglo se almacenan en los elementos ya que los elementos
son las variables

Para crear arreglos en C++, hay que indicar el tipo de los elementos (ejemplo, int, char,
double, bool o un tipo definido por el programador)
2. el nombre del arreglo
3. la cantidad de dimensiones y sus tamaños; cada dimensión comienza con el signo
[ seguido por el tamaño de la dimensión y termina con el signo ]
Para crear un arreglo de una dimensión, el formato es el siguiente:
<tipo de los elementos> <nombre del arreglo> [ <tamaño primera dimensión> ]
Para determinar la cantidad de elementos en un arreglo, hay que multiplicar el tamaño de
cada una de las dimensiones indicados en la declaración. El tamaño debe ser un literal de tipo
entero o el nombre de una constante de tipo entero.
Para nombrar un elemento en un arreglo hay que indicar el nombre del arreglo, seguido de
tantas parejas de corchetes [ ] como dimensiones declaradas. Dentro de cada pareja de
corchetes tiene que haber un índice. La combinación de los índices indica la posición del
elemento dentro del grupo. El valor mínimo para un índice es 0. El valor máximo es uno
menos que el tamaño de la dimensión correspondiente en la declaración del arreglo.

Arreglo unidimensional

El subgrupo más pequeño posible se conoce como un arreglo de una dimensión. Un arreglo
unidimensional tiene una sola dimensión. En C#, la dimensión se maneja por medio de un
par de corchetes. A los arreglos de una dimensión también se les llama listas.

Ejemplo #1. Arreglo de una dimensión

Declaración
INSTITUTO TECNOLOGICO DE ORIZABA

int a[3]; // forma una secuencia de tres elementos

Nombre del grupo
a Nombre de los elementos
a[0] → primer elemento
a[1] → segundo elemento
a[2] → tercer elemento

Operaciones con arreglos unidimensionales.

Para manejar un arreglo, las operaciones a efectuarse son:

Declaración del arreglo,

Creación del arreglo,
Inicialización de los elementos del arreglo, y
Acceso a los elementos del arreglo.
A continuación describiremos cada una de estas operaciones, en C#.

Declaración.
La declaración de un arreglo unidimensional consiste en establecer las características del
arreglo y sus elementos, por medio de la siguiente sintaxis:

<tipo> [ ] < identificador > ;

Donde:

tipo indica el tipo correspondiente a los elementos del arreglo ,

identificador es el nombre del arreglo, y

el par de corchetes, [ ], representa la dimensión del arreglo y encierra un número entero que
corresponde al número de elementos del arreglo.

Ejemplos:

int [ ] a ;

float [ ] distancia ;

Artículo [ ] art = new Artículo[ 3];

Observe que, en la declaración, el espacio entre los corchetes está vacío. Esto se debe a que,
durante dicha operación, no se reserva espacio en la memoria.

Creación.
La creación de un arreglo unidimensional consiste en reservar espacio de memoria para todos
sus elementos, utilizando la siguiente sintaxis:
INSTITUTO TECNOLOGICO DE ORIZABA

< identificador > = new <tipo> [ tamaño ] ;

Donde:

new es el operador para gestionar espacio de memoria, en tiempo de ejecución,

tamaño es un número entero que representa el número de elementos del arreglo.

Ejemplos:

a = new int [10] ; // Se crea el arreglo a , con 10 elementos de tipo entero.

distancia = new float[ 5] ; // Se crea el arreglo distancia , con 5 elementos de punto flotante
y precisión sencilla .Artículo [] art = new Artículo[3];

Artículo [ ] art = new Artículo[ 3]; // Se crean 3 referencias a objetos de la clase Artículo

art[0]= new Artículo(); // Se crea el primer objeto del arreglo art

art[1]= new Artículo(); // Se crea el segundo objeto del arreglo art

art[2]= new Artículo(); // Se crea el tercer objeto del arreglo art

Las dos primeras operaciones de declaración y creación anteriores se pueden agrupar en una
sola instrucción, como se muestra enseguida:

int [ ] a = new int [10] ;

float [ ] distancia = new float[5] ;

Inicialización.

Un arreglo es un objeto que, cuando es creado por el compilador, se le asignan

automáticamente valores iniciales predeterminados a cada uno de sus elementos, de acuerdo
a los siguientes criterios:

Si el tipo del arreglo es numérico, a sus elementos se les asigna el valor cero.
Si el tipo del arreglo es char, a sus elementos se les asigna el valor '\u0000'.
Si el tipo del arreglo es bool, a sus elementos se les asigna el valor false.
Si el tipo del arreglo es una clase, a sus elementos se les asigna el valor null.
Cuando se requiere asignar valores iniciales diferentes de los predeterminados, es posible
agrupar las operaciones de declaración, creación e inicialización en una sola instrucción, por
ejemplo:
INSTITUTO TECNOLOGICO DE ORIZABA

int [ ] a = { 1, 0,4,-6, 2,9, 23,455, 90,35 };

float [ ] distancia = { 2.50F, 286.45F, 46.75F, 30.62F, 93.00F };

string [ ] pato = { "Hugo", "Paco", "Luís" };

Acceso.

Se puede acceder a los valores de los elementos de un arreglo a través del nombre del arreglo
y un subíndice. El subíndice debe escribirse entre corchetes y representa la posición del
elemento en el arreglo. Así, podemos referirnos a un elemento del arreglo escribiendo el
nombre del arreglo y el subíndice del elemento entre corchetes. Los valores de los subíndices
empiezan en cero para el primer elemento, hasta el tamaño del arreglo menos uno.

Ejemplo:
float [ ] distancia = new float[5] ; // Crea el arreglo distancia con 5 elementos.

float x = 25F, y = 10F ; // Crea dos variables de punto flotante y precisión sencilla.

distancia[0] = x + y ; // El valor asignado al primer elemento es 35.

distancia[1] = ++distancia[0] ; // Asigna 36 al segundo elemento.

distancia[2] = distancia[1] - distancia[0] + 4 ; // Asigna 5 al tercer elemento.

distancia[3] = distancia[2]-- ; // Asigna 5 al cuarto elemento

// y disminuye en 1 el valor del tercero.

distancia[4] = distancia[3] * distancia[2] ; // Asigna 20 al quinto elemento.

y = distancia[4] ; // Asigna a y el valor almacenado en el quinto elemento.

Aplicaciones.
Listas.
Resolvamos el problema de manejar dos listas: una con los nombres de un grupo de alumnos
y otra con una calificación para cada uno de los alumnos.
Primero se deberán leer los nombres de los alumnos y la calificación que corresponde a cada
uno de ellos y después habrá que desplegar dos columnas: una con los nombres de los
alumnos y la otra con sus respectivas calificaciones.

La lectura debe lucir de manera similar a la siguiente:

INSTITUTO TECNOLOGICO DE ORIZABA

Número de alumnos: 30

Nombre [0] :
Calificación[0] :

Nombre [1] :
Calificación[1] :

Nombre [2] :
Calificación[2] :

...
...

Nombre [29] :
Calificación[29] :

El despliegue en el monitor luciría así:

No. Nombre Calif.

1 Hugo 100
2 Paco 90
3 Luís 95
... ...
30 Donald 70

El siguiente código corresponde a un programa que resuelve el problema.

// Lista.cs : Lee una lista de nombres y calificaciones correspondientes a un grupo de

// alumnos de una materia.

using System;
using C = System.Console;

public class Lista

{

public static void Main()

int nAlumnos;

C.Write("Número de alumnos: ");

INSTITUTO TECNOLOGICO DE ORIZABA

nAlumnos = Convert.ToInt32(C.ReadLine());

string [ ] alumnos = new string[nAlumnos]; //Crea el arreglo de

//alumnos.

int [ ] calif = new int [nAlumnos]; // Crea el arreglo de calificaciones.

// Lee los elementos de los dos arreglos.

for(int i = 0; i < nAlumnos ; i++)

{

C.Write("Nombre del alumno [" + i + "] : ");

alumnos[i] = C.ReadLine( );

C.Write("Calificación [" + i + "] : ");

calif[i] = Convert.ToInt32(C.ReadLine( ));

// Despliega los valores de los dos arreglos.

C.WriteLine("No. Nombre Calif.");

for(int i = 0 ; i < nAlumnos ; i++)

{

C.Write(" " + (i+1) + ".- " + alumnos[ i] );

C.WriteLine(" " + calif[i] );

Vectores.

Otra de las aplicaciones de los arreglos es el manejo de vectores.

Los vectores son una forma de almacenar datos que permiten contener una serie de valores
del mismo tipo, cada uno de los valores contenidos tiene una posición asociada que se usará
para accederlos. Está posición o índice será siempre un número entero positivo.

En C la cantidad de elementos que podrá contener un vector es fijo, y en principio se define

INSTITUTO TECNOLOGICO DE ORIZABA

cuando se declara el vector. Los vectores se pueden declarar de la siguiente forma:

tipo_elemento nombre[largo];
Esto declara la variable nombre como un vector de tipo_elementos que podrá contener largo
cantidad de elementos, y cada uno de estos elemento podrá contener un valor de tipo
tipo_elemento.

Por ejemplo:

double valores[128];
En este ejemplo declaramos un vector de 128 elementos del tipo double, los índices de los
elementos irían entre 0 (para el primer elemento y 127 para el último).

De la misma forma que con las otras declaraciones de variables que hemos visto se le puede
asignar un valor iniciar a los elementos.

O también se pueden declarar:

tipo_elemento nombre[largo]={valor_0, valor_1, valor_2};

En caso estamos asignadole valores a los primeros 3 elementos del vector nombre. Notar que
largo debe ser mayor o igual a la cantidad de valores que le estamos asignando al vector, en
el caso de ser la misma cantidad no aporta información, por lo que el lenguaje nos permite
escribir:

tipo_elemento nombre[]={valor_0, valor_1, valor_2};

Que declarará nombre como el vector de largo 3.

Para acceder a un elemento accederemos a través de su posición. Es decir:

tipo_elemento elemento;
...
elemento = nombre[2];
Asumiendo que tenemos el vector anterior definido estaríamos guardando valor_2 en
elemento.

Veamos algunos ejemplos:

/*
* Ejemplo : El producto escalar de dos vectores
*/
#include <stdio.h>

double producto_escalar(double v1[], double v2[], int d);

int main()
{
const int largo = 3;
INSTITUTO TECNOLOGICO DE ORIZABA

double vector_1[] = {5,1,0};

double vector_2[] = {-1,5,3};

double resultado = producto_escalar(vector_1, vector_2, largo);

// imprime el resultado
printf("(%f, %f, %f) . (%f, %f, %f) = %f\n",
vector_1[0], vector_1[1], vector_1[2],
vector_2[0], vector_2[1], vector_2[2],
resultado);
return 0;
}

/* producto escalar entre dos vectores */

double producto_escalar(double v1[], double v2[], int d)
{
double resultado = 0;
int i;
for (i=0; i < d; i++) {
resultado += v1[i] * v2[i];
}
return resultado;
}
En el ejemplo anterior usamos los vectores de C para representar vectores matemáticos y
calcular el producto vectorial entre ellos. Una peculiaridad que se puede notar es que al recibir
un arreglo en una función no se especifica el largo, volveremos a esto en un capítulo posterior.

Otra función clásica es la búsqueda de un máximo o mínimo, que podemos escribirla de la

siguiente manera:

int buscar_maximo(double valores[], int num_valores)

{
int maximo_pos = 0;
for (int i = 1; i < num_valores; i++) {
if (valores[i] > valores[maximo_pos]) {
maximo_pos = i;
}
}
return maximo_pos;
}
Otro ejemplo sencillo, calcular el promedio de los valores.

double promedio(double valores[], int largo)

{
double suma=0;
for (int i=0;i<largo;i++) {
suma+=valores[i];
INSTITUTO TECNOLOGICO DE ORIZABA

}
return suma/largo;
}
Cuando una función recibe un vector por parámetro y cambia su contenido y el cambio es
permanente (se ve aún fuera de la función). Esto puede parecer extraño después del énfasis
que pusimos en resaltar que todos los parámetros de una función se reciben por valor.
Mientras tanto usemos esto para definir una función que le aplique otra función que recibe
por parámetro a cada elemento del vector, guardando el resultado en el mismo vector y una
llamada de ejemplo a esta.

void cuadrados(double vector[], int largo)

{
for (int i=0;i<largo;i++) {
vector[i]=cuadrado(vector[i]);
}
}
...
double cuadrado(double valor) {
return valor*valor;
}
...
cuadrados(elementos,num_elem);
...
De la misma forma que venimos usando vectores de tipos básicos, podemos tener vectores
de vectores, estos se declaran de la siguiente forma:

int matriz[3][7];
int tabla[3][4]={ { 1, 2, 3, 4},
{ 5, 6, 7, 8}, /* los espacios y saltos de líneas no son tomados en cuenta */
{ 9,10,11,12} };
double v[2][2][2];
...
printf("tabla[0][1]: %i\n", tabla[0][3]); // Imprime 4
printf("tabla[2][0]: %i\n", tabla[2][0]); // Imprime 9
...
En este ejemplo tabla es un vector de longitud 3, cuyos elementos son vectores de longitud 4
de elementos de tipo int.

En resumen, suponiendo que v[n] es un vector de cualquier tipo de dato con n cantidad de
posiciones, al vector v se le aplican las siguientes reglas:

1.La primera posición siempre será v[0]

2.La última posición es v[n-1]
3.En versiones previas a C99 n es una constante definida antes de la declaración de v[n]
INSTITUTO TECNOLOGICO DE ORIZABA

Arreglo bidimensional

Un arreglo de dos dimensiones se subdivide en arreglos de una dimensión. Un arreglo

bidimensional tiene dos dimensiones y es un caso particular de los arreglos
multidimensionales. En C#, las dimensiones se manejan por medio de un par de corchetes,
dentro de los que se escriben, separados por comas, los valores de las dos dimensiones.
Este tipo de arreglos al igual que los anteriores es un tipo de dato estructurado, finito
ordenado y homogéneo. El acceso a ellos también es en forma directa por medio de un par
de índices.
La representación en memoria se realiza de dos formas: almacenamiento por columnas o por
renglones.

Operaciones con arreglos bidimensionales.

Para manejar un arreglo, las operaciones a efectuarse son:

Declaración del arreglo,

Creación del arreglo,
Inicialización de de los elementos del arreglo, y
Acceso a los elementos del arreglo.
A continuación describiremos cada una de estas operaciones, en C#.

Declaración.
La declaración de un arreglo consiste en establecer las características del arreglo y sus
elementos, por medio de la siguiente sintaxis:

<tipo> [ , ] < identificador > ;

Donde:

tipo indica el tipo correspondiente a los elementos del arreglo ,

identificador es el nombre del arreglo, y

el par de corchetes y la coma, [ , ], representan las dimensiones del arreglo y encierra dos
números enteros, cuyo producto corresponde al número de elementos del arreglo.

Ejemplos:

double [ , ] matriz ;

int [ , ] ubicación ;

Rama [ , ] árbol; // Rama es una clase.

Observe que, en la declaración, el espacio entre los corchetes está vacío. Esto se debe a que,
INSTITUTO TECNOLOGICO DE ORIZABA

durante dicha operación, no se reserva espacio en la memoria.

Creación.
La creación de un arreglo bidimensional consiste en reservar espacio en la memoria para
todos sus elementos, utilizando la siguiente sintaxis:

< identificador > = new <tipo> [ dim1, dim2 ] ;

Donde:

new es el operador para gestionar espacio de memoria, en tiempo de ejecución,

dim1 y dim2 son valores enteros que representan las dimensiones del arreglo.

El tamaño del arreglo es el resultado de multiplicar los valores de las dimensiones y

representa el número de elementos del arreglo.

Ejemplos:

matriz = new double [2, 3] ; // Se crea el arreglo matriz, con 6 elementos de tipo

//punto flotante y precición doble .

ubicación = new int[ 4,2] ; // Se crea el arreglo ubicación, con 8 elementos de

//tipo entero de 32 bits .

árbol = new Rama[5,2] ; // Se crea el arreglo arbol, con 10 objetos

//de la clase Rama.

Las operaciones de declaración y creación anteriores se pueden agrupar en una sola

instrucción, como se muestra enseguida:

double [ , ] matriz = new double [2,3] ;

int [ , ] ubicación = new int[4, 2] ;

Rama [ , ] alumno = new Rama[5,2] ;

Inicialización.
Un arreglo es un objeto que,cuando es creado por el compilador, se le asignan
automáticamente valores iniciales predeterminados a cada uno de sus elementos, de acuerdo
a los siguientes criterios:
INSTITUTO TECNOLOGICO DE ORIZABA

Si el tipo del arreglo es numérico, a sus elementos se les asigna el valor cero.
Si el tipo del arreglo es char, a sus elementos se les asigna el valor '\u0000'.
Si el tipo del arreglo es bool, a sus elementos se les asigna el valor false.
Si el tipo del arreglo es una clase, a sus elementos se les asigna el valor null.
Cuando se requiere asignar valores iniciales diferentes de los predeterminados, es posible
agrupar las operaciones de declaración, creación e inicialización en una sola instrucción, por
ejemplo:

double [ , ] matriz = { {1.5, 0, 4, -6.5, 2 } , {2.3, 9, 3.5, 4.8, 6.2} };

int [ , ] ubicación = { {2, 4} , {6, 8} , {9, 10}, {5 , 1}};

string [ , ] funcionario = { {"Hugo", "jefe"} ,

{ "Paco", "operador "},

{ "Luís","ayudante"} };

Acceso.
Se puede acceder a los valores de los elementos de un arreglo bidimensional a través del
nombre del arreglo y dos subíndices. Los subíndices deben escribirse entre corchetes y
representa la posición del elemento en el arreglo. Así, podemos referirnos a un elemento del
arreglo escribiendo el nombre del arreglo y los subíndices del elemento entre corchetes. Los
valores de los subíndices empiezan en cero para el primer elemento, hasta el tamaño del
arreglo menos uno.

Ejemplo:
int [ , ] posición = new int[5, 10] ; // Crea el arreglo posición , con 50 elementos de tipo
entero.

int x;

posición[ 3, 5] = 3 ;

x = posición[ 3, 5] ;

Aplicaciones.

Matrices.
Una matriz es un arreglo rectangular de dos dimensiones, donde el acomodo de los elementos
está dispuesto en renglones y columnas.
INSTITUTO TECNOLOGICO DE ORIZABA

Ejemplo 1:
Se debe controlar la ubicación de los asistentes a una sala de conferencias por medio de un
gafete que tiene escrito el nombre del asistente, la fila y la columna donde se ubica su asiento.

El siguiente segmento de código muestra la solución con arreglos bidimensionales.

string [ , ] asistente = new string[10,12] ;

// Inicializa los valores de los nombres con cadenas vacías.

for(int i=0 ; i < 10 ; i++ ) // Controla la fila.

for(int j=0 ; j < 12 ; j++ ) // Controla la columna.

asistente[ i , j ] = " " ;

// Captura los nombres de todos los asistentes y les asigna sus asientos,

// en el orden en que van llegando.

for(int i=0 ; i < 10 ; i++ ) // Controla la fila.

for(int j=0 ; j < 12 ; j++ ) // Controla la columna.

asistente[ i , j ] = System.Console.ReadLine( );

// Despliega los nombres de todos los asistentes.

for(int i=0 ; i < 10 ; i++ ) // Controla la fila.

for(int j=0 ; j < 12 ; j++ ) // Controla la columna.

System.Console.WriteLine( asistente[ i , j ] );

Ejemplo 2 :
Dada la matriz A :

895
632

y la matriz B :

714
503
INSTITUTO TECNOLOGICO DE ORIZABA

Elaborar un programa en C# para obtener la suma de ambas matrices: S = A + B

// SumMatrices.cs : Suma dos matrices de 2 renglones y 3 columnas.

using System;
using C = System.Console;

namespace Sumatrices
{

class Matriz
{

public static void Main()

{

const int r = 2, c = 3;
int i, j;

double[,] A = new double[r, c];

double[,] B = new double[r, c];
double[,] S = new double[r, c];

C.Clear();

// Lectura de valores para los elementos de A.

C.WriteLine("Suma de las matrices A y B de 2x3\n");

C.WriteLine("\nTeclee los valores de la Matriz A\n");

for (i = 0; i < r; i++)

for (j = 0; j < c; j++)

{

C.Write(" A[{0},{1}] = ",i,j);

A[i, j] = Double.Parse(Console.ReadLine());

// Lectura de valores para los elementos de B.

C.WriteLine("\nTeclee los valores de la Matriz B\n");

INSTITUTO TECNOLOGICO DE ORIZABA

for (i = 0; i < r; i++)

for (j = 0; j < c; j++)

{

C.Write(" B[{0},{1}] = ", i,j);

B[i, j] = Double.Parse(Console.ReadLine());

// Suma y despliegue de la matriz resultado.

C.WriteLine("\nMatriz S = A+B\n");

for (i = 0; i < r; i++)

{

for (j = 0; j < c; j++)

{

S[i, j] = A[i, j] + B[i, j];

C.Write(" " + S[i, j]);

C.WriteLine();

Un arreglo de tres dimensiones se subdivide en arreglos de dos dimensiones los cuales a su

vez se dividen en arreglos de una dimensión. Un arreglo de cuatro dimensiones se subdivide
en arreglos de tres dimensiones los cuales a su vez se dividen en arreglos de dos dimensiones
los cuales a su vez se dividen en arreglos de una dimensión. La misma idea se aplica en
arreglos de más dimensiones.

Ejemplo #2. Arreglo de dos dimensiones

Declaración
char m[2][3]; // forma una tabla de dos filas y tres columnas
// cada fila es un arreglo de una dimensión
// la declaración indica que hay dos arreglos de una dimensión
INSTITUTO TECNOLOGICO DE ORIZABA

Nombre del grupo

m → indica la localización del grupo en la memoria
Nombre de las filas
m[0] → primera fila → indica la localización de la fila dentro del grupo
m[1] → segunda fila → indica la localización de la fila dentro del grupo
Nombre de los elementos
m[0][0] → primer elemento
m[0][1] → segundo elemento
m[0][2] → tercer elemento
m[1][0] → cuarto elemento
m[1][1] → quinto elemento
m[1][2] → sexto elemento

Ejemplo #3. Arreglo de tres dimensiones

Declaración
double w[2][2][3]; // forma dos tablas de dos filas y tres columnas
// cada fila es una secuencia de tres elementos
// cada fila es un arreglo de una dimensión
// la declaración indica que hay dos arreglos de dos dimensiones
// los arreglos de dos dimensiones tienen a su vez dos arreglos de una dimensión
INSTITUTO TECNOLOGICO DE ORIZABA

Programas
#include<stdio.h>
#include<conio.h>
void main ()
{
int num[20]={5,67,8,90,345,12,33,45,78,1,2,78,900,67,345,12,21,5,98,1000};
int i,dato;
clrscr();
printf("de un numero entero : \n");
scanf("%d",&dato);
for (i=0;i<=19;i++){
if (dato==num[i]){
textcolor(RED);
cprintf("\nEl %d se encuentra en la posicion %d del arreglo \n",dato,i);
}
else {
printf("\nEl %d NO se encuentra en la posicion %d del arreglo \n",dato,i);}}
getch();
}
#include<stdio.h>
#include<conio.h>
void main ()
{
int num[20]={5,67,8,90,345,12,33,45,78,1,2,78,900,67,345,12,21,5,98,1000};
int i,dato,bandera=0;
clrscr();
printf("de un numero entero : \n");
scanf("%d",&dato);
for (i=0;i<=19;i++){
if (dato==num[i]){
printf("\nEl %d se encuentra en la posicion %d del arreglo \n",dato,i);
bandera=1;
}
}
if (bandera==0){
printf("\nNO");
}
getch();
}
#include<stdio.h>
#include<conio.h>
void main ()
{
int num[20];
int i,dato,bandera;
INSTITUTO TECNOLOGICO DE ORIZABA

char resp;
clrscr();
for (i=0;i<=19;i++){
printf("\nDame el elemento %d ",i);
scanf("%d",&num[i]);
}
do{
bandera=0;
printf("\nde un numero entero : \n");
scanf("%d",&dato);
for (i=0;i<=19;i++){
if (dato==num[i]){
printf("\nEl %d se encuentra en la posicion %d del arreglo \n",dato,i);
bandera=1;
}}
if (bandera==0){
printf("\nNO");}
printf("\nQuieres buscar otro numero en el arreglo s/n");
resp=getch();
}while(resp=='s');
getch();}
INSTITUTO TECNOLOGICO DE ORIZABA

LOS REGISTROS O ESTRUCTURAS

1. estructura es el nombre en C de los registros;

2. REGISTRO: grupo de información relacionada que se usa para almacenar datos acerca de
un tema o actividad;

3. una colección de registros constituye un archivo;

4. los registros están divididos en campos;

5. un campo es una variable de un tipo determinado.

Sintáxis:

1.) 2.) 3.)

struct <nombre> struct <nombre> struct <nombre>
Bloquev; <var1>,...,<varN>; Bloquev
<var1>,...,<varN>

1. define un registro de nombre <nombre> donde los diferentes campos son definidos dentro
de Bloquev. Este bloque solo debe contener definición de variables;

2. define los las variables <var1> a <varN> como de tipo: struct <nombre>. Se puede definir
una variable de tipo, de una estructura dada, donde quiera que la estructura este definida;

3. es una abreviación de 1.) y 2.).

Operaciones estructuras y acceso campos

Operaciones estructuras:

1. operaciones sobre un campo en partícular;

2. el paso de una estructura como parámetro;

3. afectaciones y comparaciones entre estructuras son prohibidas.

Uso de un campo:

struct libro {

char titulo[20]; /* título del libro */

INSTITUTO TECNOLOGICO DE ORIZABA

char autor[20]; /* autor del libro */

int num; /* número de libro */
};

struct libro lib1,lib2;

Para accesar los campos de lib1 y lib2 se usa el operador . de la forma siguiente:

lib1.titulo[i] o lib2.titulo[i]
para accesar el (i+1) caracter del título

lib1.autori[i] o lib2.autor[i]
para accesar el (i+1) caracter del autor

lib1.num o lib2.num
para el número del libro

progReg1.c Ejemplo estructuras

#include <stdio.h>
int main()
{
struct triangulo {
int base;
int altura;
int l1, l2, l3;
float area;
float perimetro;
}

struct triangulo fig1, fig2;

printf("Proporcione las longitudes de los lados del primer triangulo:")

scanf("%d %d %d", &fig1.l1, &fig1.l2, &fig1.l3)
printf("Proporcione el valor de la base y la altura del primer triangulo")
scanf ("%d %d",&fig1.base, &fig1.altura);
fig1.area = (fig1.base * fig1.altura)/2
fig1.perimetro = fig1. l1 + fig1.l2 + fig1.l3;

printf("Proporcione las longitudes de los lados del segundo triangulo:")

scanf("%d %d %d", &fig2.l1, &fig2.l2, &fig2.l3)
printf("Proporcione el valor de la base y la altura del segundo triangulo")
scanf("%d %d",&fig2.base, &fig2.altura);
INSTITUTO TECNOLOGICO DE ORIZABA

fig2.area = (fig2.base * fig2.altura)/2

fig2.perimetro = fig2. l1 + fig2.l2 + fig2.l3;

if (fig1.area > fig2.area)

printf("El primer triangulo tiene un area mas grande: %.3f \n",fig1.area );
else
printf("El segundo triangulo tiene un area mas grande: %.3f \n",fig2.area);

if (fig1.perimetro > fig2.perimetro)

printf("El primer triangulo tiene un perimetro mas grande: %.f \n",fig1.perimetro );
else
printf("El segundo triangulo tiene un perimetro mas grande: %.1f
\n",fig2.perimetro);
}