UNIVERSIDAD DE LAS FUERZAS ARMADAS

PROGRAMACION 1

ESTUDIANTES: DAISY CRUZ-CRISTIAN

ORTEGA

DOCENTE: ING. ZAMBRANO

TAREA Nro 3

FECHA: 11-05-2018
OBJETIVOS
  Realizar un programa, utilizando lógica de punteros, en donde el usuario ingresa
datos en un arreglo de 10 posiciones, con dígitos del 0 al 9. En el mismo arreglo, se
imprimen primero los números diferentes de cero y luego los ceros.
 Analizar y comprender el problema; poner en práctica lo aprendido en clases y
ejecutar el programa sin complicaciones.

MARCO TEORICO
ARREGLOS
Los arrays, arreglos o vectores forman parte de la amplia variedad de estructuras de datos
que nos ofrece C++, siendo además una de las principales y más útiles estructuras que
podremos tener como herramienta de programación. Los arrays, arreglos o vectores (como
los quieras llamar), son utilizados para almacenar múltiples valores en una única variable.
En un aspecto más profundo, los arrays, permiten almacenar muchos valores en posiciones
de memoria continuas, lo cual permite acceder a un valor u otro de manera rápida y
sencilla. Estos valores pueden ser números, letras o cualquier tipo de variable que deseemos
incluso tipos de datos propios.
Para obtener todos los datos que se encuentran al interior de un vector, es necesario recorrer
el array o vector, para recorrerlo, se usa casi siempre un ciclo for, en algunos casos mas
específicos un ciclo while, pero generalmente el ciclo for es el ideal para esto, dado que
conocemos el tamaño del array. La lógica de este procedimiento es la siguiente, el ciclo for
comenzara desde cero e ira hasta el tamaño del vector, de modo que la variable de control
que generalmente llamamos "i", será la que va a ir variando entre cero y el tamaño del
array, de esta forma al poner la i al interior de los corchetes, estaremos accediendo al valor
de cada casilla del vector y podremos hacer lo que sea necesario con dicho valor.

PUNTEROS
Es una variable que contiene la dirección de memoria de un dato o de otra variable que
contiene al dato en un arreglo. Esto quiere decir, que el puntero apunta al espacio físico
donde está el dato o la variable. Un puntero puede apuntar a un objeto de cualquier tipo,
como, por ejemplo, a una estructura o una función. Los punteros se pueden utilizar para
referencia y manipular estructuras de datos, para referenciar bloques de memoria asignados
dinámicamente y para proveer el paso de argumentos por referencias en las llamadas a
funciones.
Ya se dijo que un puntero es una variable que guarda la dirección de memoria de otra
variable, haciendo lógica a esto, decimos que un puntero se declara igual que cualquier otra
variable, pero anteponiendo un * (asterisco) antes del nombre de la variable.
Su sintaxis sería:
 tipo *NombrePuntero = NULL; Se iguala a NULL para saber que no tiene asignada
ninguna dirección.
Donde tipo es el tipo de dato al que referenciará este puntero, es decir, que si se
necesita guardar la dirección de memoria de un dato int, se necesita un puntero de
tipo int.

PRIMERA PARTE
PROGRAMA 1-CODIGO
#include<stdio.h>
#define dim 10
int main(){
printf("Bienvenido al programa\n");
int A[dim],num,*p,aux;
p=&num; //Se da la direccion de una variable a un puntero

for(int i=0;i<dim;i++){
printf("Ingrese un numero para la posicion %d, por favor ",i+1);
scanf("%d",p); //Se da un valor a un puntero
if(*p<9){ //si el valor ingresado es menor que nueve se entra en la estructura
*(A+i)=*p; //se asigna el valor del puntero al arreglo
}
else{
while(*p>9){ //si el numero es mayor a nueve, se ingresa hasta que sea menor
printf("Numero invalido, por favor ingrese nuevamente un valor para la
posicion %d ",i+1);
scanf("%d",p);
}
*(A+i)=*p; //asignacion del valor del puntero al arreglo
}
 }

printf("\n");
printf("Los datos que ha ingresado son:");
for(int i=0;i<dim;i++) //inicio de la impresion del arreglo con los numeros recopilados
{
printf("%d ",*(A+i)); //impresion del arreglo
}
printf("\n");

for(int b=0;b<dim;b++){
for(int j=b+1;j<dim;j++){
if(*(A+b)==0){
aux=*(A+b); //se guarda el valor del vector en una posicion en
una variable temporal
*(A+b)=*(A+j); //se compara el valor de una posicion con el de la
siguiente
*(A+j)=aux; //se guarda el valor de la siguiente posicion en una
variable temporal
}
}
}

printf("\n");
printf("El arreglo resultante es:\n ");
for(int i=0;i<dim;i++){
printf("%d ",*(A+i)); //impresion del arreglo ya trabajado
}
}

CAPTURA DEL PROGRAMA 1

 SEGUNDA PARTE
PROGRAMA 2-CODIGO

#include<stdio.h>
#define dim 10

int main()
{
int A[dim],aux=0,i,j,*p,*q;
p=&A[0]; // se le da la direccion de la primera posicion del arreglo al puntero
printf("***************BIENVENIDO AL PROGRAMA***************\n");
for(int i=0;i<dim;i++)
{
printf("Por favor, ingrese un dato para la posicion %d: ",i+1);
 scanf("%d",p); //asignando un valor al puntero
while(*p>9) //imposibilita que se pueda ingresar un numero mayor a 9
{
printf("Numero invalido, por favor ingrese nuevamente un valor
para la posicion %d: ",i+1);
scanf("%d",p); //le da un valor a un puntero
}
*p++; //aumenta de valor el puntero, porque previamente se le dio la
direccion del arreglo
}
printf("\n");
printf("Los datos que ha ingresado son:");
p=&A[0]; //se asigna de nuevo la direccion del arreglo al puntero para imprimir desde
el principio el arreglo
for(int i=0;i<dim;i++) //inicio de la impresion del arreglo con los numeros recopilados
{
printf("%d ",*p); //impresion del valor de p
*p++; //Avanza en posicion el puntero
}
printf("\n");

for(int i=0;i<dim-1;i++){
p=&A[0]; //Se asigna la direccion de la primera posicion del arreglo al puntero
q=&A[1]; //Se le asigna la direccion de la siguiente posicion del arreglo para la comparacion
for(int j=0;j<dim-1;j++){
if(*p==0){ //para analizar en funcion de los 0 existentes
aux=*p; //se guarda en una variable temporal al valor que tiene p
*p=*q; //se igual el valor de la posicion de p con la siguiente que
esta guardada en q
*q=aux; //se guarda el valor de q en la variable temporal
 }
*p++; //se avanza en posiciones el vector
*q++; //se avanza en posicion al vector
}
}
printf("El arreglo resultante es:\n ");
p=&A[0]; //se vuelve a ubicar en la primera posicion del arreglo
for(int i=0;i<dim;i++)
{
printf("%d ",*p);
*p++;
}

CAPTURA DEL PROGRAMA 2

CONCLUSIONES
 Es necesario tener dominio y total compresión de la materia con respecto a
punteros, para poder analizar de manera correcta como es que se va a avanzar entre
direcciones y asignar adecuadamente valores en los punteros.
 Cuando se trata a un arreglo como puntero es necesario especificar el movimiento
entre posiciones, con el objetivo de que se guarde un dato en cada posición
disponible del arreglo.
 Cuando se hace la comparación para dejar al final los ceros, en el caso de que se
trate al arreglo como un puntero es necesario analizar empezando desde la primera
posición y luego en el mismo arreglo analizar la posición siguiente. Pero cuando se
hace la comparación asignando dos punteros diferentes, es necesario que el primer
puntero empiece en la primera posición y el otro en la siguiente, para luego
proseguir a avanzar con los punteros.

BIBLIOGRAFIA
 Arrays, d. and González, J. (2018). Arrays, arreglos o vectores en C++: Uso y sintaxis en
C++. [online] Programarya.com. Available at:
https://www.programarya.com/Cursos/C++/Estructuras-de-Datos/Arreglos-o-Vectores
[Accessed 02 May. 2018].
 Es.wikibooks.org. (2018). Programación en C/Punteros - Wikilibros. [online] Available at:
https://es.wikibooks.org/wiki/Programaci%C3%B3n_en_C/Punteros [Accessed 11 May
2018].