Un arreglo unidimensional es un tipo de datos estructurado que está formado de una

colección finita y ordenada de datos del mismo tipo. Es la estructura natural para modelar
listas de elementos iguales.

El tipo de acceso a los arreglos unidimensionales es el acceso directo, es decir, podemos

acceder a cualquier elemento del arreglo sin tener que consultar a elementos anteriores o
posteriores, esto mediante el uso de un índice para cada elemento del arreglo que nos da su
posición relativa.

Para implementar arreglos unidimensionales se debe reservar espacio en memoria, y se debe

proporcionar la dirección base del arreglo, la cota superior y la inferior.

REPRESENTACION EN MEMORIA: Los arreglos guardan en memoria la cantidad de espacios

que se le indican en la declaración.

Ejemplo: sea el siguente arreglo unidimensional donde se va a guardar 5 datos de tipo entero
(integer)

x : array[1..5] of integer
En memoria el computador guarda 5 espacios: esto quiere decir en el arreglo X en la posición 1
guarda 34, en el arreglo X en la posición 2 guarda 22, asi hasta la última posición del arreglo X
posicion 5 guarda 72.
X [1]

34

X [2]

22

X [3]

39

X [4]

63

X [5]
72

Declaracion de los arreglos unidimensionales: Se declara el tipo del arreglo, con la palabra
reservada TYPE, luego se declara la variable de tipo arreglo, esto se hace en el bloque de
declaracion de variables palabra reservada VAR.

Type

nombre_arreglo= array[x..y]of tipo_dato;

Ejemplos:

salarios= array [1…x] of real;

nombre_trabajador=array[1..x] of string;

Nota: El tipo de dato del arreglo puede ser: integer,real, boolean, string etc.

Variables tipo array

Var

sueldo:salarios;

nombre:nombre_trabajador;

Una vez declarados los arreglos procedemos a cargar información en ellos, para esto usamos
estructuras repetitivas la mas recomendable por su facilidad es el for, una vez cargada la
información se puede hacer cualquier operación de calculo y por último mostramos la
información de los arreglos usando de igual manera la estructura repetitiva for.

carga de un arreglo, la letra i es el indice o subindice del arreglo e indica la posición del arreglo:

for i:=1 to num do

begin

readln(notas[i]);

end;

Mostrar la información de un arreglo, la letra i es el indice o subindice del arreglo e indica la

posición del arreglo::

for i:=1 to num do

begin

writeln(notas[i]:3:1);

end;

Se han hechos programas que suman una cantidad de números usando dos variables, una para
leer cada número y otra para acumular la suma. Este enfoque tiene la desventaja de que se
pierden los valores de los sumandos. El uso de arreglos permite calcular la suma de los
números con una cantidad mínima de código y a la vez conservar cada valor, como muestra el
siguiente programa completo:

Program SumaN;
Uses

Crt;

Const

n = 5;

Var

nums: Array[1..n] Of Integer;

s, i: Integer;

Begin

For i:=1 To n Do

Begin

Write('Escriba el número: ');

ReadLn(nums[i]);

s := s + nums[i];

End;

WriteLn('La suma es: ', s);

End.

Nótese el uso de una constante para marcar el tamaño del arreglo; dicha constante, también
sirve para controlar el For. De este modo, sólo se hace necesario cambiar un número para
adecuar el programa a la escala apropiad

PUNTEROS
Es una variable estática que, en vez de contener valores de datos, contiene valores que
representan direcciones de memoria de variables.
PUNTERO
Variable que contiene la DIRECCIÓN de memoria en la que se encuentra almacenada otra
variable.
La sintaxis general para declarar una
variable tipo puntero es:
tipo *nombre_puntero;
donde tipo es el tipo de variablesa la que apuntará el puntero.
int *p;
Asignación de punteros.
Respecto a la comparación y a la asignación, los punteros se ajustan a las mismas reglas que
cualquier otra variable en C:
•Un puntero puede utilizarse a la derecha de una declaración de
asignación para asignar su valor a otro puntero.
•Podemos comparar dos punteros en una expresión relacional.
El valor de otro puntero, del mismo tipo.
La dirección de memoriade una variable cuyo tipo coincida en el tipo_base del puntero

Inicialización de punteros
Al igual que otras variables, C no inicializa los punteros cuando se declaran y es preciso
inicializarlos antes de su uso.
TODO PUNTERO DEBE INICIALIZARSE, ya que en caso contrario
tras ser declarado apuntaría a cualquier sitio (PELIGROSO)al usarlo puede p.ej. modificar una
parte de la memoria reservada a otra variable
Si aún no sabemos dónde debe apuntar, se le asignará el valor NULL (nulo)
No apunta a ningún sitio en especial.
Ejemplo:
int *p = NULL;

APUNTADORES A ARREGLOS

Por supuesto que los apuntadores pueden apuntar a cualquier tipo de dato, incluyendo
arreglos. Mientras que eso ya era evidente cuando discutíamos el programa 3.1, es importante
expandir como es que hacemos esto cuando se trata de arreglos multidimensionales.

Para revisar, en el capítulo 2, establecimos que, dado un arreglo de enteros podemos apuntar
un puntero a entero a ese arreglo usando:

int *ptr;
ptr = &mi_arreglo[0]; /* apuntamos nuestro apuntador al primer elemento del
arreglo */

Como habíamos establecido, el tipo de la variable apuntadora debe coincidir con el tipo de el
primer elemento en el arreglo. En adición, podemos usar un puntero como un parámetro de
una función que esté diseñada para manipular un arreglo. Ejemplo:

Dados:

int arreglo[3] = {1, 5, 7};

void a_func(int *p);

Algunos programadores prefieren escribir el prototipo de una función así como: void
a_func(int p[]); Lo que informaría a otros que usaran esta función que la función sirve para
manipular los elementos de un arreglo. Por supuesto, en cualquier caso, lo que realmente le
estamos pasando a la función es un puntero al primer elemento del arreglo,
independientemente de la notación usada en el prototipo o definición de la función . Nótese
que si usamos la notación de arreglos, no hay necesidad de pasar la dimensión real del arreglo,
ya que no estamos pasando el arreglo completo, sino únicamente la dirección de su primer
elemento.
Pasemos al problema de tratar con un arreglo bidimensional. Como se estableció en el último
capítulo, C interpreta un arreglo de 2 dimensiones como si se tratara de un arreglo que consta
de un arreglo de una dimensión. En ese caso, el primer elemento de un arreglo de 2
dimensiones de enteros, es un arreglo unidimensional de enteros. Y un puntero a un arreglo
de enteros de dos dimensiones debe apuntar a ese tipo de datos. Una manera de cumplir con
esto es por medio del uso de la palabra clave “typedef”. typedef asigna un nuevo nombre para
el tipo de datos especificado. Por ejemplo:

typedef unsigned char byte;

hace que el nombre byte signifique el tipo de datos unsigned char. Por tanto:

byte b[10];

sería entonces un arreglo de 10 elementos del tipo unsigned char.

Observemos cómo en la declaración del typedef, la palabra byte ha reemplazado aquello que
normalmente sería el nombre de nuestra variable unsigned char. Por tanto, la regla para usar
typedef es que el nombre del nuevo tipo de datos sea el nombre usado en la definición del
tipo de datos.

Así que al declarar:

typedef int Arreglo[10];

Arreglo se vuelve un nuevo tipo de datos para un arreglo de 10 enteros. Es decir Arreglo
mi_arreglo, declara mi_arreglo como un arreglo de 10 enteros y Arreglo arr2d[5]; hace que
arr2d sea un arreglo de 5 arreglos de 10 enteros cada uno.
Nótese que al hacer Arreglo *p1d; hace de p1d un apuntador a un arreglo de 10 elementos.
Debido a que *p1d apunta al mismo tipo de datos que arr2d, asignar la dirección de el arreglo
bidimensional arr2d a p1d, el puntero a arreglo unidimensional de 10 enteros, es aceptable. Es
decir, si hacemos tanto: p1d = &arr2d[0]; como p1d = arr2d; ambos son correctos.

Ya que el tipo de datos que usamos para nuestro apuntador es un arreglo de 10 enteros,
esperaríamos que al incrementar p1d por 1 cambiaría su valor por 10*sizeof(int), y lo hace.
Esto es que sizeof(*p1d) es 40. puedes comprobar esto tú mismo escribiendo un pequeño
programa.

El usar typedef hace las cosas más claras para el lector y fáciles para el programador, pero no
es realmente necesario. Lo que se necesita es una manera de declarar un puntero como p1d
sin usar la palabra clave typedef. Es posible hacerlo y que:

int (*p1d)[10];

es la declaración apropiada, es decir p1d es aquí un apuntador a un arreglo de 10 enteros tal y

como era como cuando fue declarado usando el tipo de datos Arreglo. Observa que es
diferente de hacer:
 int *p1d[10];

lo que haría de p1d el nombre de un arreglo de 10 apuntadores al tipo entero.

EJERCICIOS DE ARREGLOS

//Ejercicio de punteros y arrays unidimensionales.

//Aritmética de punteros.

#include<stdio.h>

#include<stdlib.h>

main()

printf("Autor: David Tipan \n");

int

lista[5] = {10,20,30,40,50};

int *p;

p = lista;

printf("lista[0] equivale a: %d \n",lista[0]);

printf("*lista equivale a: %d \n",*lista);

printf("*p equivale a: %d \n\n\n",*p);

printf("lista[1] equivale a: %d \n",lista[1]);

printf("*(lista+1) equivale a: %d \n",*(lista+1));

printf("*(p+1) equivale a: %d \n\n\n",*(p+1));

printf("lista[2] equivale a: %d \n",lista[2]);

printf("*(lista+2) equivale a: %d \n",*(lista+2));

printf("*(p+2) equivale a: %d \n\n\n",*(p+2));

printf("lista[3] equivale a: %d \n",lista[3]);

printf("*(lista+3) equivale a: %d \n",*(lista+3));

printf("*p equivale a: %d \n\n\n",*(p+3));

printf("lista[4] equivale a: %d \n",lista[4]);

printf("*(lista+4) equivale a: %d \n",*(lista+4));

printf("*(p+4) equivale a: %d \n\n\n",*(p+4));

system("pause");

}
2.- /Programa que permite al usuario dar valores a los elementos del arreglo...

//...y luego muestra la direccion y contenido de cada elemento.

#include<stdio.h>

#include<stdlib.h>

main()

printf("Autor: David Tipan \n");

int

lista[5];

int*p;p = lista;

int i=0;

//Se llenan la lista con valores enteros

for

(i=0,p=lista; i<5 ; i++,p++)

{

printf("Ingrese el elemento %d: ",i);

scanf("%d",p);

//Se muestran las direciones de memoria de cada elemento

for

(i=0,p=lista; i<5 ; i++,p++)

printf("La direccion de memoria de lista[%d] es: %d \n",i,p);

//Se muestran los valores de cada elemento de la lista

for

(i=0,p=lista; i<5 ; i++,p++)

printf("El contenido de lista[%d] es: %d \n",i,*p);

system("pause");

}
3.- #include <conio.h>

#include <stdio.h>

#include <stdlib.h>

#define TAM 1000

void escribirArray(char a[], int tamanio);

int main()

char letra[TAM];

/* Array que contendrá las letras de la A a la Z*/

char AaZ[26];

/* contadores*/

int i,j,cont;

//srand(time(NULL));

/* Relleno del array de letras */

for(i=65;i<=90;i++){

AaZ[i-65]=i;

}
/*Relleno inicial del array aleatorio*/

for(i=0;i<TAM;i++){

/*genera caracteres del ASCII 65 al 90,

de la letra A a Z */

letra[i]=rand()%26+65;

/* Escritura del contenido del primer array*/

printf("Array inicial:\n");

escribirArray(letra,TAM);

/* El bucle recorre el array que contiene las letras de la A

a la Z y cuenta cada vez que aparece cada letra en el array de letras

aleatorias*/

for(i=0;i<26;i++){

cont=0;

for(j=0;j<TAM;j++){

if(AaZ[i]==letra[j]) cont++;

printf("La letra %c aparece %i veces\n",65+i,cont);

}
 getch();

/* Escribe el contenido de un array de enteros por pantalla */

void escribirArray(char a[], int tamanio){

int i;

for(i=0;i<tamanio;i++){

printf("%c ",a[i]);

printf("\n");

}
EJERCICIOS DE PUNTEROS

#include <stdio.h>

int mi_arreglo[] = {1,23,17,4,-5,100};

int *ptr;

int main(void)

int i;

printf("Autor: David Tipan\n");

ptr = &mi_arreglo[0]; /* apuntamos nuestro puntero

al primer elemento del arreglo*/

printf("\n\n");

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

printf("mi_arreglo[%d] = %d ", i, mi_arreglo[i]); /*<-- A */

printf("ptr + %d = %d\n",i, *(ptr + i)); /*<-- B */

}

return 0;

2.- #include<stdlib.h>

#include<stdio.h>

int main()

{ printf("DAvid tipan\n ");

int tabla[5],i,x, *y, *z;

y = &tabla[0];

x= *y;

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

*(y+i)= rand () % 10;

z = tabla;

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

printf("%d \n ", *(z+i),tabla[i]);

printf("%d %d \n",*(z+i),tabla[i]);