Ejercicios con Punteros.

Los operadores unitarios ​* y ​& tienen mayor precedencia que los operadores aritméticos ​+
y ​-e​ igual precedencia que ​++​ y ​--​;

Definimos dos variables enteras a y b, y dos punteros a datos de tipo entero ​pa​ y ​pb​.

Inta a, b, *p, *q;

b = *pa+1; al valor apuntado por ​pa​ se le suma 1 y el resultado se asigna a ​b.​

b =*(pa+1); ​el siguiente entero al entero apuntado por ​pa​, es asignado a ​b​.
pb = &b; a ​pb​ se le asigna la dirección de la variable ​b​.

En el siguiente caso se supone que b esta a puntada por pb.

*pb = 0; la variable ​b​ es puesta a 0.

*pb += 2; la variable ​b​ se incrementa en dos unidades.​ incrementa
(*pb) --; la variable ​b se decrementa en una unidad. Sin paréntesis, se decrementa ​pb y no
b.​ ​decrementa

​Ejemplos

1. Programa que muestre el uso de operadores básicos en la declaración de

punteros empleando el direccionamiento y el operador indirección.

#include <stdio.h>
#include <conio.h>
main()
{
int a;
/*Declaración de un puntero a un entero */
int *p;

printf("Ingrese un valor ENTERO para la variable:\n");

scanf("%d", &a);
while(a<0)
 {
printf("ERROR, el valor debe ser mayor que cero:\n");
scanf("%d", &a);
}

printf("a=%d\n", a); /*Imprimo el valor de a*/

printf("La dirección de a es %p\n", &a);
printf("*p=%p\n", p); /*Imprimo la dirección que guarda p*/
/*imprimo el valor guardado en la dirección a la que apunta p*/
printf("a=%d\n", *p);
printf("El tamaño de *p es %d\n", sizeof(p));
getch();
return 0;
}
2. Diseñe un programa, que sume dos variables de tipo entero, por medio de
apuntadores.

#include <stdio.h>
#include <conio.h>
main()
{
int a, b, c;
int *p1, *p2, *p3; /*declaración de los punteros */
printf("Ingrese el valor de a:\n");
scanf("%d", &a);
printf("Ahora el valor de b:\n");
scanf("%d", &b);
c=a+b;
printf("a+b=%d\n", c);
/*asignamos las direcciones a los punteros correspondientes/
p1=&a;
p2=&b;
printf("*p1 + *p2=%d\n", *p1+*p2);
p3=&c;
printf(" Dirección de a es %p\n Dirección de b es %p\n Y la de c es %p\n\n", p1, p2, p3);
getch();
return 0;
}

3. Programa que lee un arreglo y una matriz usando aritmética de punteros */

#include <stdio.h>
#include <conio.h>
#define M 3
#define N 3
main()
{
int x[3][3], y[3];
int f=0,c=0;

for(f=0; f< M; f++)

{
for(c=0; c<N; c++)
{
printf("*(x+ %d)+%d)=", f,c);
scanf("%d", *(x+f)+c);
}
printf("Elemento %d del vector:\n", f);
scanf("%d", &y[f]);
}
printf("IMPRESIONES:\n");
printf("*** MATRIZ ***\n");
for(f=0; f<M; f++)
for(c=0; c<N; c++)
printf("%d", *(*(x+f)+c));
printf("\n*** VECTOR ***\n");
for(f=0; f<M; f++)
printf("%d", *(y+f));
getch();
return 0;
}

En C, existe entre punteros y arrays una relación tal que, cualquier operación que se pueda
realizar mediante la indexación de un array, se puede realizar también con punteros.

4. Versión con arreglos

#include <stdio.h>
#include <stdlib.h>
int main()
{
static int lista[] = {24, 30, 15, 45, 34};
int ind;

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

printf("%d ", lista[ind]);
return 0;
}*/

Versión con apuntadores.

int main()
{
static int lista[]={24, 30, 15, 45, 34};
int ind;

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

printf("%d ", *(lista+ind));
return 0;
}
5. En este programa el resultado devuelto es un puntero al carácter buscado a un
puntero nulo si no se encuentra.

#include<string.h>
#include<stdio.h>
main()
{
char car,linea[81],*p;

puts("Introducir la cadena de caracteres: ");

gets(linea);
printf("Introducir car%cacter a buscar: ",160);
car=getchar();
/*la función strchr sirva para localizar un caracter en una cadena*/
p=strchr(linea,car);/*retorna un puntero a un char*/
printf("\n%s \n ",p);
}

6. El siguiente programa copia una cadena de caracteres en otra. Primeramente, se

presenta una versión con arrays y después otra con punteros.
#include <stdio.h>
#include <string.h>

main() ​programa principal

{
char cadena1[81], cadena2[81];
void copstr(char *,char *);

printf("Introduce el texto: ");

gets(cadena1);
copstr(cadena2,cadena1);/*copia una cadena2 en la cadena1*/
printf("\n\n La cadena copiada es: %s", cadena2);
}
Son 4 versiones
/*void copstr(char *p, char *q) /*copia q a p*/
/*{
int i=0;

while((p[i]=q[i])!='\0')
i++;
}*/

/*void copstr(char *p, char *q)

{
int i=0;

while((*p=*q)!='\0')
{
p++;
q++;
}
}*/
/*void copstr(char *p, char *q)
{
int i=0;

while((*p++ = *q++)!='\0');
}*/
void copstr(char *p, char *q)
{
int i=0;

while(*p++ =*q++);
}