Carátula para entrega de prácticas

Facultad de Ingeniería Laboratorios de docencia

Laboratorio de Computación
Salas A y B

Profesor: Sáenz García Elba Karen

Asignatura: Estructura de Datos Y Algoritmos 1

Grupo: 4

No de Práctica(s): 2

Integrante(s): Dionicio Juárez Agustín Zúñiga De Olarte Juan Ángel

Reyes Castillo Christian

Palacios Cacique Esteffany Abigail

Ávila Sánchez Eduardo Benjamín

No. de Equipo de
cómputo empleado:

Semestre: 2 semestre

Fecha de entrega: 20 de agosto 2018

Observaciones:

CALIFICACIÓN: ________________
Introducción:

Llamados también punteros. Un Apuntador es una variable que contiene una dirección de memoria, la cual
corresponderá a un dato o a una variable que contiene el dato. Cada variable que se utiliza en una aplicación
ocupa una o varias posiciones de memoria. Estas posiciones de memoria se accedan por medio de una
dirección.

El Operador de Dirección ( &) regresa la dirección de una variable.

El Operador de Indirección ( * ), toma la dirección de una variable y regresa el dato que contiene esa
dirección.

Los punteros son uno de los aspectos más potentes de la programación en C, pero también uno de los más
complejos de dominar. Los punteros permiten manipular la memoria del ordenador de forma eficiente. Dos
conceptos son fundamentales para comprender el funcionamiento de los punteros:

El tamaño de todas variables y su posición en memoria.

Todo dato está almacenado a partir de una dirección de memoria. Esta dirección puede ser obtenida y
manipulada también como un dato más.

Los punteros son también una de las fuentes de errores más frecuente. Dado que se manipula la memoria
directamente y el compilador apenas realiza comprobaciones de tipos, el diseño de programas con punteros
requiere una meticulosidad muy elevada que debe ir acompañada de una dosis idéntica de paciencia.
Programar eficientemente usando punteros se adquiere tras escribir muchas líneas de código pero requiere
una práctica sostenida.

Cuando se escribe un programa, se asume que las variables se almacenan en memoria y están ahí
disponibles para ser utilizadas. En principio, los detalles de cómo se almacenan y organizan los datos en
memoria no son visibles a un programador. Sin embargo, como el lenguaje de programación C nos ofrece una
gestión de memoria muy cercana a la RAM, para realizar un uso eficiente de la memoria es preciso conocer
más de cerca cómo se organiza la memoria de un programa.

Los arreglos (arrays) permiten almacenar vectores y matrices. Los arreglos unidimensionales sirven para
manejar vectores y los arreglos bidimensionales para matrices. Sin embargo, las matrices también se pueden
almacenar mediante arreglos unidimensionales y por medio de apuntadores a apuntadores, temas que se
verán en el capıtulo siguiente. La palabra unidimensional no indica que se trata de vectores en espacios de
dimensión uno; indica que su manejo se hace mediante un subíndice. El manejo de los arreglos
bidimensionales se hace mediante dos subíndices.
Objetivo: Utilizar apuntadores en Lenguaje C para acceder a localidades de memoria tanto de datos primitivos
como arreglos.

Desarrollo: Realizar las actividades 1- 5 y al terminar colocar en la plataforma su código fuente. Las
actividades restantes son para el reporte(en equipo).

Actividad 1

Completar el siguiente código:

#include <stdio.h>

main(){

float a,*ap; a=7.5; ap=&a;

printf("Direccion asignada a la variable a % \n", );

printf("Direccion asignada a la variable ap % \n", );

printf(" Valor asignado a la variable a % \n", );

printf(" Valor asignado a la variable ap o dirección a la que apunta % \n", );

printf(" Contenido de la variable a la que apunte % ", );

printf(" tamaño en bytes para la variable a % \n", );

printf(" tamaño en bytes para la variable ap % \n", );

/*Escribir abajo la línea que modifique el valor de la variable -a- mediante el apuntador ap. y se muestre el
nuevo valor en la salida estándar*/

1:

#include <stdio.h>

main(){

float a,*ap;

a=7.5;

ap=&a;

printf("Direccion asignada a la variable -a- % \n",&a );

printf("Direccion asignada a la variable -ap- % \n",&ap );

printf(" Valor asignado a la variable -a- % \n",a );

printf(" Valor asignado a la variable -ap- o direccion a la que apunta % \n",ap );

printf(" Contenido de la dirección que almacena -ap- (contenido de ls variable a la que apunta) % \n ",*ap );

printf(" tamaño en bytes para la variable -a- % \n", &a ) ;

printf(" tamaño en bytes para la variable -ap- % \n", &a );

2: #include <stdio.h>

void intercambia(int *a,int *b);

main(){

int a=3,b=5;

intercambia(&a,&b);

printf("Valor de a y b son %d y %d",a,b);

void intercambia(int *a,int *b){

int tmp;

tmp=*a;

*a=*b;

*b=tmp;

3: #include<stdio.h>

#define n 10

void llena(int *ap);

void suma(int *ap1,int*ap2,int*ap3);

void imprime(int*ap);

main(){

int A[n],B[n],C[n],*a,*b,*c;

a=&A[0];//llenado del arreglo a

llena(a);

b=&B[0];//llenado del arreglo b

llena(b);

c=&C[0];

suma(a,b,c);
 imprime(a);

imprime(b);

imprime(c);

void llena(int *ap){

int i;

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

printf("Llenado");

scanf("%d",ap+i);

void suma(int *ap1,int*ap2,int*ap3){

int i;

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

*(ap3+i)=*(ap1+i)+*(ap2+i);

void imprime(int*ap){

int i;

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

printf("Tu resultado es %d\n:",*(ap+i) );

}
4: ##include<stdio.h>

main()

int a[5],x,*b;

b=&a[0];

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

printf("dame tu valor en [%d]\n",x+1);

scanf("%d",b+x);

printf ("ARREGLO\n");

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

printf("\t%d",*(b+x));

5: #include<stdio.h>

int longitudCadena(char *p);

int main(){

char s[50];

printf("Introduce la cadena:\n\n");

fgets(s, 50, stdin);

printf("\nLa longitud de la cadena es: %i \n",longitudCadena(s));

int longitudCadena(char *p)

int n;

for (n=0; *p!= '\0'; n++)

 {

p++;

return n;

6:

#include<stdio.h>

main(){

int A[5] = {21,22,45,37,34};

int B[5] = {30,60,40,38,43};

int traspuesta[2][5] = {{30,60,40,38,43}, {21,22,45,37,34}};

int x, y;

printf("\tMatriz Original\n\n");

for(x=0; x<5; x++){

printf("%d, ", A[x]);

 }

for(x=0; x<5; x++){

printf("%d, ", B[x]);

printf("\n\n\tMatriz Traspuesta\n\n");

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

for(y=0; y<5; y++){

printf("%d, ", traspuesta[x][y]);

return 0;

7:

#include<stdio.h>

char longCad(char *cad1, char *cad2);

main()

char s[50], e[50];

printf("Introduce la cadena 1:\n");

gets(s);

printf("Introduce la cadena 2:\n");

gets(e);

printf ("TUS CADENAS INICIALES SON:\n %s\n %s\n",s,e);

longCad(e,s);
 printf ("\tCopiamos cadena 1 en 2\n");

printf ("TUS CADENAS SON:\n %s\n %s\n",s,e);

char longCad(char *cad1, char *cad2)

int i;

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

*(cad1+i)=*(cad2+i);

Conclusiones:

Reyes Castillo Christian:

Para mi esta práctica fue un poco confusa ya que usamos además de arreglos, usamos apuntadores, estos
apuntadores son muy buenos para ayudarte en el código, pero muy confusos ya que estos funcionan para la
unidad de memoria y poder modificar conforme avanza el programa esas unidades, al igual los arreglos que te
ayudan para juntar toda la información en poco código, pero investigando y con ayuda de los apuntes te da
una idea de cómo se trabajan y juntando ambos es interesante como actúan para algún problema, una
práctica interesante aunque un poco confusa.

Dionicio Juárez Agustín:

Utilizamos apuntadores en lenguaje C para acceder a las localidades de memoria, para esto manejamos arreglos y
algunos datos primitivos. Un apuntador es una variable, que almacena como contenido una dirección de memoria, de
otra variable a la que apunta, dicha dirección representa el lugar donde se almacena un dato. Los apuntadores tienen un
tipo de dato específico y solo pueden apuntar a espacios de memoria con datos del mismo tipo. Hacer la practica en
ocasiones se complicó debido a que no hubo una plena organización en el equipo, aun así pudimos entregar algo.

Zúñiga De Olarte Juan Ángel:

Al realizar la práctica fue un poco compleja ya que antes no había tratado mucho con apuntadores y arreglos
juntos, pero al hacerlo me di cuenta de que ambos son importantes para la programación en c, ya que los
apuntadores manipulan la dirección de memoria y con esto manipular lo que tiene dentro este mismo, tuvimos
que investigar y apoyarnos de los apuntes.

Palacios Cacique Esteffany Abigail:

Con la realización de esta práctica me di cuenta de la importancia del uso de los apuntadores ya que son de
gran ayuda para manipular la memoria interna ya sea de una variable sencilla o de arreglos multidimensional y
bidimensionales, ayudando a que nuestro programa sea más eficaz y eficiente.
Ávila Sánchez Eduardo Benjamín:

Durante el trabajo tuvimos varias dificultades al imprimir arreglos, ya que se nos dificultó saber el cuándo y el
cómo imprimir lo que contenía el apuntador y cuándo iba la dirección de el mismo.

En cuanto a las actividades finales fueron un poco complejas al intentar transformar los arreglos
bidimensionales a arreglos unidimensionales y a apuntadores, aunque el guardar cadenas en otras no estuvo
tan complicado.

A pesar de ello nos dimos a la tarea de investigar y arreglar estos problemas de manera eficiente y rápida
esperando a que sea la correcta.