NOMBRE DEL ALUMNO: FABIAN CERVANTES GARCIA.

NOMBRE DEL MAESTRO: JAVIER MANJARREZ MENDOZA.

NOMBRE DE LA ACTIVIDAD: APUNTADORES.

NOMBRE DE LA MATERIA: LENGUAJES DE PROGRAMACION.

GRUPO: MET 4°B.

FECHA DE ENTREGA: 30-11-2020.

Objetivo.

El objetivo de este reporte es que el alumno conozca sobre los apuntadores, ya

que son muy importantes para la parte de la programación, ya que van a utilizar
para la programación los apuntadores.

Introducción.

En esta parte vamos a investigar sobre los apuntadores para los programas, para
poder hacer programaciones, ya que esto los podremos ocupar depende que
programa vayas a hacer y que función tenga ya que esos apuntadores sirven
mucho para las programaciones, es una de las herramientas o atajos para poder
hacer una programación no tan larga.

Desarrollo.

Punteros de caracteres: Definición, Declaración e Iniciación.

Un puntero de carácter es un objeto del tipo siguiente:

char * p;

Los punteros de carácter se utilizan normalmente para acceder a cadenas de

caracteres, puesto que éstas están construidas tomando como base una dirección
(la del primer carácter) y un marcador de fin de cadena (el carácter '\0'). La
declaración de un puntero de carácter sigue las reglas habituales:

char * puntero_caracter;

En este momento puntero_caracter no tiene un valor utilizable. Será preciso

dárselo; esto podría hacerse en la forma siguiente:

char letra;
char * puntero;

puntero = &letra;

y se tendrá un alias.

Punteros de cadenas: Definición, Declaración e Iniciación.

La declaración de una cadena puede ser de la forma siguiente:

char cadena [LONGITUD];

Así se reserva espacio para una cadena de LONGITUD caracteres. En C, el

nombre de las listas mono dimensionales equivale a la dirección del primer
elemento de las mismas. Una vez que se dispone de espacio reservado para la
cadena, se puede construir un puntero de la cadena empleando las sentencias
siguientes:

char * p;

char cadena [LONGITUD];

p = cadena;/* Esto equivale, desde luego, a poner: */

p = &cadena [0];

Esto dará lugar a que en p se almacene la dirección de cadena; no es un error de

asignación, por cuanto no se intenta almacenar una cadena en un carácter, sino
que se asigna el valor de la dirección de un carácer a una variable de tipo puntero
de char. Esto no pasaría de ser un alias de la cadena... pero suceden cosas
interesantes, como puede verse a continuación.

Recorrido de una cadena mediante aritmética de punteros y mediante índices.

El mecanismo de la aritmética de punteros en C tiene su expresión más sencilla

en el caso de utilizar, precisamente, punteros de caracteres. Consideremos las
declaraciones siguientes:

Tipo_base lista [NUMERO_DE_ELEMENTOS];

Tipo_base *p, *q;

p = lista;

y veamos a continuación la forma en que funciona la aritmética de punteros. Se

admite la suma de números enteros (positivos o negativos) a un puntero. Esto es,
se admiten expresiones de la forma

q = p + 1;

El resultado de estas operaciones es otro puntero de igual tipo. La dirección

almacenada en el puntero nuevo es, como siempre, un número. Podría pensarse
que al sumar 1 a un puntero se consigue otro puntero tal que el valor numérico del
mismo es igual al valor numérico de la primera dirección incrementado en una
unidad. Y de hecho, así sucede cuando se trata de un puntero de char, o de algún
tipo base cuya extensión sea de un byte.

En general, cuando se suma 1 a un puntero, el valor numérico de la dirección no

se incrementa en 1, sino en sizeof (Tipo_base). Entonces, al sumar i a un puntero
se tiene que la dirección obtenida al calcular p+i tiene el valor direccion_de_p +
i*sizeof (Tipo_base). Se ha obtenido un nuevo puntero, que señala una posición
de memoria que correspondería a un elemento de una lista situado i posiciones
más alla del elemento señalado por p.

Ejemplo.

Comprobar que si p es un puntero de char entonces al sumar 1 a p se obtiene una

dirección cuyo valor aumenta en 1 (= sizeof (char)) respecto a la dirección de p.
En general, comprobar que al sumar i a p (al calcular p+i) se incrementa el valor
de p en i*sizeof (char).

Solución

#include<stdio.h>

int main(int argc, char * argv[])

char letra;

char * p = &letra, *q;

int i;

unsigned long base;

printf("La dirección de letra es %u\n", (unsigned int)p);

q = p + 1;

printf("La dirección dada por q = p + 1 es %u\n", (unsigned int)q);

q = p + 2;
 printf("La dirección dada por q = p + 2 es %u\n", (unsigned int)q);

q = p + 3;

printf("La dirección dada por q = p + 3 es %u\n", (unsigned int)q);

q = p + 4;

printf("La dirección dada por q = p + 4 es %u\n", (unsigned int)q);

printf("Escriba el valor de i: ");

scanf("%d", &i);

q = p + i;

printf("q = p + %d vale %u\n", i, (unsigned int)q);

base = (unsigned long)p;

printf("El valor calculado es: %u\n",base + i*sizeof(char));

return 0;

/*

La dirección de letra es 3221224104

La dirección dada por q = p + 1 es 3221224105

La dirección dada por q = p + 2 es 3221224106

La dirección dada por q = p + 3 es 3221224107

La dirección dada por q = p + 4 es 3221224108

Escriba el valor de i: 5

q = p + 5 vale 3221224108

*/
Si se estudian los valores obtenidos en la columna de la derecha, que son los
valores de la dirección de doble almacenada en p, y luego los valores de las
direcciones obtenidas al calcular p+1, p+2, etc., se observa que difieren 1 entre sí.
Esto es precisamente lo que se quería poner de manifiesto: si se suma 1 al
puntero, se obtiene una dirección situada 1 bytes más allá, porque el tamaño de la
variable señalada (char) es 1. En otras palabras, el puntero p se comporta como si
señalara el primer elemento de una lista de char.

Apuntadores y arreglos.

Existe una estrecha relación entre apuntadores y arreglos, tanto que

pueden ser usados en forma casi indistinta.
Una variable de tipo arreglo puede considerarse como un apuntadoral tipo
del arreglo.
Los apuntadores pueden ser utilizados en cualquier operación que involucre
subíndices de arreglos.

Ejemplo de relación entre apuntadores y arreglos.

#include <stdlib.h>

#include <stdio.h>

int main()

int tabla[10],i,x,*pt,*ptr;

pt = &tabla[0];

x = *pt;

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

*(pt+i) = rand() % 100;

 ptr = tabla;

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

printf(''%d \n'',*(ptr+i),tabla[i]);

Cuando se suma 1 a un apuntador el incremento se adecua al tamaño en memoria

del objeto apuntado.

Un apuntador es una variable, por lo que operaciones como pa = a y pa++ son

permitidas.

Un nombre de un arreglo es una constante, no una variable, de ahí que a = pa o

a++ o p = a.

Arreglos de apuntadores

Los arreglos pueden contener apuntadores

El uso más común es el de formar arreglos de cadenas de caracteres

Cada entrada en el arreglo es un apuntador al primer carácter de la cadena

Sea la declaración:

char * mensaje[4] = {''Hola'',''Adiós'',''Bye'',''Salut''}

Cada cadena está almacenada en memoria como una cadena de caracteres

terminada en NULL n0.
En el arreglo no están colocadas las cadenas, tan solo están almacenados los
apuntadores.

Aunque el arreglo es de tamaño fijo, permite el acceso a cadenas de caracteres de

cualquier longitud.

Inicialización de arreglos de apuntadores.

#include <stdlib.h>

#include <stdio.h>

int main()

int x;

char * mes[] = {

''mes ilegal'',

''enero'',

''febrero'',

''marzo'',

''abril'',

''mayo'',

''junio'',

''julio'',

''agosto'',

''septiembre'',

''octubre'',
 ''noviembre'',

''diciembre'',

};

x = rand() % 12;

printf(''El mes %d corresponde a %s \n'',x,mes[x]);

Ejemplo de inicialización de arreglos caracteres.

#include <stdio.h>

int main()

char *esp[10] = {

''uno'',

''dos'',

''tres''

};

char frances[5][10] = {

''un'',

''deux'',

''trois''

};
 printf("Elemen: 123456789\n");

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

printf("Esp[%d]: %s\n",i,esp[i]);

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

printf("Fra[%d]: %s\n",i,esp[i]);

printf("\nEsp: Elemento 3 de la entrada 2 %c \n",esp[2][3]);

printf("Fra: Elemento 4 de la entrada 3 %c \n",frances[3][4]);

printf("Esp: Elemento 7 de la entrada 2 %c \n",esp[2][7]);

frances[3][4]='A';

printf("Fra: Elemento 4 de la entrada 3 %c \n",frances[3][4]);

esp[2][3]='A'; /* Segmentation fault (core dumped) */

printf("Elemento 3 entrada 2 esp: %c \n",esp[2][3]);

Conclusión.

Los apuntadores son elementos fundamentales en el manejo de la memoria.

Y gracias a esta investigación nos ayuda a poder conocer un poco más a los
apuntadores para así facilitar la programación, ya que estos apuntadores son muy
útiles en cualquier tipo de programación ya también depende de que es lo que
queramos hacer, y así ya los podamos utilizar en nuestra vida diaria o mínimo ya
vamos a conocer de ellos cuando elaboremos un trabajo, o una programación,
porque así ya sabremos cómo se hacen y como se utilizan y para qué.