Empleando apuntadores una función
puede entregar múltiples resultados
//Esta función no funciona
#include <stdio.h>
void intercambiaValores(float a, float b)
{
float tmp = a;
a = b;
b = tmp;
}
int main()
{
float pa = 2, pe = 3;
intercambiaValores(pa, pe);
printf("%f, %f\n", pa, pe); // imprime: 2, 3
}
Para que funcione se le debe de enviar la dirección de las variables
#include <stdio.h>
void intercambiaValores(float a, float b)
{
float tmp = a;
a = b;
b = tmp;
}
int main()
{
float pa = 2, pe = 3;
intercambiaValores(&pa, &pe); // produce error de sintaxis
printf("%f, %f\n", pa, pe); // imprime: 2, 3
}
Para que funcione se le debe de enviar la dirección de las variables y recibirlas en apuntadores
#include <stdio.h>
void intercambiaValores(float *a, float *b)
{
float tmp = *a;
*a = *b;
*b = tmp;
}
int main()
{
float pa = 2, pe = 3;
intercambiaValores(&pa, &pe);
printf("%f, %f\n", pa, pe); // imprime: 3, 2
}
Apuntadores y Arreglos
El identificador de un arreglo tiene asociado la
dirección de su primer elemento
float b[6] = {4.,6.,8.};
b y &b[0]
Se refieren a la misma dirección
b[0]
Valores
4.0
b[1]
6.0
b[2]
8.0
b[3]
b[4]
b[5]
b[0]
Valores
4.0
b[1]
b[2]
6.0
b[3]
b[4]
b[5]
8.0
#include <stdio.h>
int main()
{
float c, *a, b[3] = {4.,6.,8.};
c = b[2];
a = b;
// pongo en el apuntador a la dirección del primer elemento de b
a++;
*a = *a + 1.;
// manipulación de la dirección
// manipulación del contenido, ahora vale 7
a--;
c = *(a + 2);
// Observar esta línea
printf("%f %f\n",*a,c); // imprime 4 8
getchar();
return 0;
}
//
También se puede hacer así:
c = a[2]; // a no es un arreglo pero lo puedo manipular como si lo fuera
¿ Cual es entonces la diferencia
entre arreglo y apuntador ?
ARREGLO: La dirección que contiene el
identificador del arreglo es constante.
APUNTADOR: La dirección que contiene el
apuntador es variable.
float c, *a, b[4];
a = b;
a = &c;
b = &c; /* error, no se puede cambiar la dirección que contiene b, que es
la dirección del primer elemento del arreglo */
Aplicaciones frecuentes del
apuntador
• 1.- Entrega de valores múltiples por parte de una función.
• 2.- Creación dinámica de arreglos empleando las funciones malloc y free.
• 3.- Paso de funciones a otras funciones
Ayuda que proporciona Pelles C
para la función malloc
malloc function
Purpose:
Allocates an object of the specified size.
Syntax:
void * malloc(size_t size);
Declared in:
<stdlib.h>
Description:
The malloc function allocates space for an object whose size is specified by size and whose value is
indeterminate.
Returns:
A null pointer if the new object could not be allocated, otherwise a pointer to the new object. The
allocated space is guaranteed to be suitable aligned for all basic data types
Ayuda que proporciona Pelles C
para la función free
free function
Purpose:
Deallocates an object.
Syntax:
void free(void *ptr);
Declared in:
<stdlib.h>
Description:
The free function causes the space pointed to by ptr to be deallocated, that is, made
available for further allocation. If ptr is a null pointer, no action occurs. Otherwise, if the
argument does not match a pointer earlier returned by the calloc, malloc, or realloc
function, or if the space has been deallocated by a call to free or realloc, the behavior
is undefined.
Returns:
Nothing
Ejemplo
#include <stdlib.h>
#include <stdio.h>
void miFun(float *a, int n)
{
a = (float *) malloc(sizeof(float) * n);
// Le asigno un bloque de memoria
for (int i = 0; i < n; i++)
a[i] = i * 2 + 1;
for (int i = 0; i < n ; i++)
printf("%f \n", *(a + i ));
free(a);
return 0;
// Libero el bloque de memoria
}
int main()(
{
float *p
miFun(p, 100);
// aquí p se puede usar para realizar otra cosa
retun 0;
}
1.000000
3.000000
5.000000
7.000000
9.000000
11.000000
13.000000
15.000000
17.000000
19.000000
21.000000
23.000000
25.000000
27.000000
29.000000
31.000000
33.000000
35.000000
37.000000
39.000000
41.000000
43.000000
45.000000
47.000000
49.000000
..
..
Paso de funciones a otras
funciones
Declaración de la función anfitriona:
tipoDeDato anfitriona(tipoDeDato ( *huesped ) (tipo1 , tipo2 ), tipoDatoArg1, tipoDatoArg2);
Ejemplos:
float miFun1(double ( *miFun2) (int, int), double a, double b);
void miFun3(double ( *miFun4) (void) ) );
Paso de funciones a otras
funciones
#include <math.h>
#include <stdio.h>
#define PI 3.1416
double miFun(double (*fun)(double a), double a)
{
return fun(a);
}
int main()
{
float r = miFun(cos, PI);
printf("%f\n", r);
return 0;
}
#include <math.h>
#include <stdio.h>
#define PI 3.1416
double recip(double a)
{
return 1/ a;
}
double miFun(double (*fun)(double a), double a)
{
return fun(a);
}
int main()
{
float r = miFun(cos, PI); // imprime el coseno de PI
printf("%f\n", r);
float r = miFun(sin, PI); // imprime el seno de PI
printf("%f\n", r);
r = miFun(recip, 100); // imprime el recíproco de 100
printf("%f\n", r);
return 0;
}
Descargar

Arreglos multidimensionales