Definición de punteros en C++ en Introducción a la Programación

Introducción a la
Programación.
Tema: Definición de punteros.
Unidad II: Elementos de Programación .

2.8 Definición de arreglos unidimensionales y
bidimensionales.
2.9 Búsqueda, ordenación y mezcla de arreglos.
2.10 Estructura de datos.
2.11 Programación modular.
2.12 Definición de
punteros.
2.13 Estructuras dinámicas.
Unidad II: Elementos de Programación

2.12 Definición de punteros.
Objetivos:
Distinguir qué son los apuntadores.
Utilizar apuntadores para pasar argumentos a las
funciones.
Conocer las estrechas relaciones entre los
apuntadores y los arreglos.
Unidad II: Elementos de Programación

Bibliografía
Pensar en C++.
Volumen 1. 2012. Bruce
Eckel. Capítulo 3.
Páginas: 126 - 127.

Bibliografía
C++ Cómo programar.
Editorial Pearson
Prentice Hall Sexta
edición. 2007. Deitel.
Deitel. Capítulo 8.
Páginas: 337 – 343, 386
- 389.

Bibliografía
Fundamentos de
Programación con el
Lenguaje de Programación
C++. Dpto. Lenguajes y
CC. Computación E.T.S.I.
Informática. 2017. Vicente
Benjumea y Manuel
Roldán. Capítulo 12.
Páginas: 155 – 160.

Bibliografía
Apuntes de Fundamentos
de Programación. Curso
2006 / 2007. 1er Curso de
Administración de
Sistemas Informáticos.
2007. Jorge Sánchez
Asenjo. Capítulo 6.
Páginas: 114.

Introducción.
Hasta ahora, todos los programas y códigos estudiados
almacenan su estado interno con variables automáticamente
gestionadas por el compilador. Estas son creadas cuando el
flujo de ejecución entra en el ámbito de su definición (se
reserva espacio en memoria y se crea el valor de su estado
inicial), posteriormente se manipula su estado (accediendo o
modificando su valor almacenado), y finalmente se destruyen
cuando el flujo de ejecución sale del ámbito donde fue declarada
la variable (liberando los recursos asociados a ella y la zona de
memoria utilizada). A este tipo de variables gestionadas
automáticamente por el compilador se las suele denominar
variables automáticas (o locales), y residen en una zona de
memoria gestionada automáticamente por el compilador, la
pila de ejecución, donde se alojan y desalojan las variables
locales (automáticas) pertenecientes al ámbito de ejecución de
cada subprograma.

Introducción.
Así, el tiempo de vida de una determinada variable está
condicionado por el ámbito de su declaración.
Además, el número de variables automáticas utilizadas
en un determinado programa está especificado
explícitamente en el propio programa, y por lo tanto su
capacidad de almacenamiento está también especificada
y predeterminada por lo especificado explícitamente en el
programa. Es decir, con la utilización única de variables
automáticas, la capacidad de almacenamiento de un
determinado programa está predeterminada desde el
momento de su programación (tiempo de compilación),
y no puede adaptarse a las necesidades reales de
almacenamiento surgidas durante la ejecución del
programa (tiempo de ejecución.)

Introducción.
La gestión de memoria dinámica surge como mecanismo
para que el programa, durante su tiempo de ejecución, pueda
alojar y desalojar memoria según las necesidades surgidas
durante una ejecución, dependiendo de las circunstancias
reales de cada momento de la ejecución del programa en un
determinado entorno. Esta ventaja adicional añade un
determinado coste asociado a mayor complejidad de gestión,
ya que en las variables automáticas, era el compilador el
encargado de su gestión, pero en las variables dinámicas es el
programador quien debe, codificar la gestión del tiempo de
vida de cada variable dinámica, cuando debe ser alojada y
creada, como será utilizada, y finalmente cuando debe ser
destruida y desalojada. Además, debe gestionar la memoria
dinámica y se debe preocupar de su alojo y su liberación,
poniendo cuidado y énfasis en no perder recursos (perder
zonas de memoria sin liberar y sin capacidad de acceso.)

Puntero.
Es un tipo simple que permite acceder a posiciones
concretas de memoria y específicamente a
determinadas zonas de la memoria dinámica. Así, una
variable de tipo puntero apunta (o referencia) a una
determinada entidad (variable) de un determinado tipo
alojada en la zona de memoria dinámica. Por tanto, para
un determinado tipo puntero, se debe especificar
también el tipo de variable (en memoria dinámica) a la
que apunta, el cual define el espacio que ocupa en
memoria y las operaciones (y métodos) que se le
pueden aplicar. Por ello, cuando un programa gestiona
la memoria dinámica con punteros, debe manejar y
gestionar la propia variable de tipo puntero, y
también la variable dinámica apuntada por éste.

Puntero.
Un tipo puntero se define utilizando la palabra
reservada typedef junto al tipo de variable
dinámica apuntada, un asterisco para indicar que
es un puntero a una variable de este tipo, y el
identificador que denomina al tipo. Se trata de
una de las herramientas más importantes de C /
C++. Se trata de una variable cuyo contenido es
la dirección al contenido de otra variable. Son
la base de las estructuras dinámicas. En general
una variable contiene un valor que es con el que
se opera, en el caso del puntero no es un valor
directo sino que es la dirección de memoria en
la que se encuentra el valor.

Puntero.
En este sentido, el nombre de una variable hace
referencia directa a un valor, y un apuntador
hace referencia indirecta a un valor. Un
puntero señala a una dirección de memoria. Al
proceso de hacer referencia a un valor a través
de un apuntador se le conoce comúnmente
como indirección. Esa dirección de memoria
contendrá valores de un determinado tipo. Por
ello al declarar un puntero hay que indicar de qué
tipo es el puntero; o, lo que es lo mismo, el tipo
de valores a los que apunta. Ejemplo: int
*ptrSuma; ptrSuma es un puntero a valores
enteros.

Puntero.
Los punteros deben declararse antes de
usarse. Ejemplo, la declaración int
*cuentaPtr, cuenta; declara a la variable
cuentaPtr como de tipo int * (es decir, un
apuntador a un valor int ) y se lee:
“cuentaPtr es un apuntador a un valor
int” o “cuentaPtr apunta a un objeto de
tipo int”. Además, cuenta se declara como
int, y no como un puntero a un int. El * en la
declaración se aplica sólo a cuentaPtr. A
cada variable declarada como puntero se le
antepone un asterisco ( * )

Puntero.
double *xPtr, *yPtr; indica que xPtr y yPtr
son punteros a valores double. Cuando el *
aparece en una declaración, no es un
operador; en lugar de ello, indica que la
variable que se está declarando es un
puntero. Los punteros se pueden declarar
de manera que apunten a objetos de
cualquier tipo de datos.

Puntero.
typedef int* PInt ; // Tipo Puntero a Entero
struct Persona { // Tipo Persona
string nombre; string telefono;
int edad; } ;
typedef Persona* PPersona ;
// Tipo Puntero a Persona
typedef int* PInt ; // Tipo Puntero a Entero
struct Persona { // Tipo Persona
string nombre; string telefono;
int edad; } ;
PInt es una variable que apunta a una
variable dinámica tipo int. PPersona es el
tipo de variable que apunta a una variable
dinámica tipo Persona.

Puntero.
Los punteros deben inicializarse cuando
se declaran, o en una asignación. Un
puntero debe inicializarse con 0, NULL o
una dirección del tipo correspondiente. Un
puntero con valor 0 o NULL no apunta a
nada, y se conoce como apuntador nulo. La
constante simbólica NULL se define en el
archivo de encabezado <iostream> (y en
varios archivos de encabezado más de la
biblioteca estándar) para representar el
valor 0.

Puntero.
Inicializar un apuntador con NULL es
equivalente a inicializar un apuntador
con 0 , pero en C++, se utiliza 0 por
convención. Cuando se asigna 0, se
convierte en un apuntador del tipo
apropiado. El valor 0 es el único valor
entero que puede asignarse directamente a
una variable apuntador sin tener que
convertir primero el entero en un tipo
apuntador.

Puntero.
typedef int* PInt ;
// Tipo Puntero a Entero
struct Persona
{ // Tipo Persona
string nombre;
string telefono;
int edad; } ;
#include <cstddef>
int main()
{ PInt p1 = NULL ;
PPersona p2 = NULL ;}
typedef int* PInt ;
// Tipo Puntero a Entero
struct Persona
{ // Tipo Persona
string nombre;
string telefono;
int edad; } ;
#include <cstddef>
int main()
{ PInt p1 = NULL ;
PPersona p2 = NULL ;}
NULL, constante
especial tipo puntero
que indica a una
variable tipo puntero
que apunte a nada,
es decir, especifica
que la variable tipo
puntero contiene el
valor NULL, o sea no
apunta a ninguna
zona de la memoria
dinámica. Para usarla
incluya <cstddef>.

Gestión de Memoria Dinámica.
int main()
{PPersona ptr; ptr = new Persona ;}
int main()
{PPersona ptr; ptr = new Persona ;}
La memoria dinámica la gestionar el programador;
y al crear una variable dinámica, debe solicitar
memoria dinámica con el operador new seguido por
el tipo de variable dinámica a crear. (new), primero
reserva espacio en memoria dinámica para
albergar a la variable, y después crea (invocando al
constructor especificado) el contenido de la variable
dinámica. Finalmente, a la variable ptr se le asigna
el valor del puntero (dirección de memoria) que
apunta a la variable dinámica creada por el operador
new. Ejemplo, para crear una variable dinámica tipo
Persona, sería:

int main()
{ PPersona ptr ;
ptr = new Persona("pepe", "111", 5) ;}
int main()
{ PPersona ptr ;
ptr = new Persona("pepe", "111", 5) ;}
Cuando el tipo de variable dinámica tenga otros
constructores definidos, es posible usarlos en la
construcción del objeto en memoria dinámica. Si el
tipo Persona tuviese un constructor que reciba el
nombre, teléfono y edad de la persona:
Tras manipular adecuadamente la memoria dinámica
alojada, llegará un momento en que dicha variable
dinámica ya no sea necesaria, y su tiempo de vida
terminó. Así, el programador libera explícitamente la
variable dinámica con el operador delete:

int main()
{PPersona ptr;
// Creación automática de la variable PTR
ptr = new Persona ; / * Creación de la
variable dinámica anónima* /
// manipulación ...
delete ptr ;
}
/ * Destrucción de la variable dinámica
anónima * /
/ * Destrucción automática de la variable
PTR * /
int main()
{PPersona ptr;
// Creación automática de la variable PTR
ptr = new Persona ; / * Creación de la
variable dinámica anónima* /
// manipulación ...
delete ptr ;
}
/ * Destrucción de la variable dinámica
anónima * /
/ * Destrucción automática de la variable
PTR * /

La sentencia delete ptr, destruye la variable dinámica
(invoca su destructor), y después libera la
memoria dinámica de dicha variable. Finalmente la
variable local ptr queda con un valor
inespecificado, y será destruida automáticamente
por el compilador cuando el flujo de ejecución salga
de su ámbito de declaración. La operación delete
sobre una variable tipo puntero sin valor NULL,
hará absolutamente nada. Si esta variable es
destruida al terminar su vida y el operador delete no
se usa, la memoria dinámica apuntada por la variable
ptr se pìerde al igual que los recursos disponibles.

Operaciones con variables tipo puntero.
El puntero nulo
(NULL) se puede
asignar a cualquier
variable de tipo
puntero. Ejemplo:
int main()
{ PPersona p1 ;
// ...
p1 = NULL ;
// ...
}
Al crear una variable
dinámica con new se
le puede asignar una
variable de tipo
puntero. Ejemplo:
int main()
{ PPersona p1 ;
p1 = new
Persona
("pepe", "111", 5) ;
}

Una variable tipo puntero puede recibir el valor
de otra variable puntero. Así, ambas variables tipo
puntero apuntarán a la misma variable dinámica,
que será compartida por ambas. Si se libera la
variable dinámica apuntada por una de ellas, la
variable dinámica compartida se destruye, su
memoria se desaloja y ambas variables locales tipo
puntero quedan con un valor inespecificado.
int main()
{PPersona p1 = new Persona("pepe", "111", 5) ;
PPersona p2 ;
p2 = p1 ;
delete p1 ;}
int main()
{PPersona p1 = new Persona("pepe", "111", 5) ;
PPersona p2 ;
p2 = p1 ;
delete p1 ;}

En la asignación, el valor anterior de la variable
tipo puntero se pierde, por lo que debe tener
especial cuidado que no se pierda la variable
dinámica que tuviese asignada, si tuviese alguna.
int main()
{ PPersona p1 = new Persona("pepe", "111", 5) ;
p1 = NULL ; // se pierde el valor anterior
delete p1 ; }
int main()
{ PPersona p1 = new Persona("pepe", "111", 5) ;
p1 = NULL ; // se pierde el valor anterior
delete p1 ; }

Desreferenciación de este tipo de variables.
El acceso a una variable dinámica apuntada por una
variable de tipo puntero, utiliza el operador unario
asterisco (*) precediendo al nombre de la variable de tipo
puntero a través de la cual es apuntada. Ejemplo: Si ptr
es una variable local de tipo puntero que apunta a una
variable dinámica de tipo Persona, entonces *ptr es la
variable dinámica apuntada, y se trata como cualquier
otra variable tipo Persona.
int main() {PPersona ptr = new Persona("pepe", "111", 5) ;
Persona p = *ptr ; / * Asigna contenido de la variable
dinámica a la variable p * /
*ptr = p ; / * Asigna contenido de la variable p a la variable
dinámica * /
delete ptr ; / * destruye variable dinámica y libera su espacio
de memoria * /
}
int main() {PPersona ptr = new Persona("pepe", "111", 5) ;
Persona p = *ptr ; / * Asigna contenido de la variable
dinámica a la variable p * /
*ptr = p ; / * Asigna contenido de la variable p a la variable
dinámica * /
delete ptr ; / * destruye variable dinámica y libera su espacio
de memoria * /
}

Si una variable de tipo puntero tiene el valor NULL,
entonces desreferenciar la variable produce un error
en tiempo de ejecución que aborta la ejecución del
programa. Desreferenciar un puntero con valor
inespecificado produce un comportamiento anómalo en
tiempo de ejecución. Es posible, así mismo, acceder a
los elementos de la variable apuntada mediante el
operador de desreferenciación.
int main()
{ PPersona ptr = new Persona ;
(*ptr).nombre = "pepe" ;
(*ptr).telefono = "111" ;
(*ptr).edad = 5 ;
delete ptr ;}
int main()
(*ptr).nombre = "pepe" ;
(*ptr).telefono = "111" ;
(*ptr).edad = 5 ;
delete ptr ;}

Usar paréntesis es obligatorio por que el operador punto
(.) tiene mayor precedencia que el de desreferenciación
(*). Así, en el caso de acceder a los campos de un
registro en memoria dinámica a través de una variable de
tipo puntero, es más adecuado utilizar el operador de
desreferenciación (->)
int main()
ptr->nombre = "pepe" ;
ptr->telefono = "111" ;
ptr->edad = 5 ;
delete ptr ;}
int main()
ptr->nombre = "pepe" ;
ptr->telefono = "111" ;
ptr->edad = 5 ;
delete ptr ;}

Comparando variables tipo puntero.
Variables del mismo tipo
puntero se pueden
comparar entre sí por
igualdad (==) o
desigualdad (!=), para
comprobar si apuntan a la
misma variable dinámica.
También se pueden
comparar por igualdad o
desigualdad con el
puntero nulo (NULL) para
saber si apunta a alguna
variable dinámica, o por el
contrario no apunta a
nada.
int main()
{ PPersona p1, p2 ;
// ...
if (p1 == p2)
{
// ...
}
if (p1 != NULL)
{
// ...
}
}
int main()
{ PPersona p1, p2 ;
// ...
if (p1 == p2)
{
// ...
}
if (p1 != NULL)
{
// ...
}
}

Operadores de apuntadores.
El operador dirección (&) es unario y obtiene la
dirección de memoria de su operando. Ejemplo, si
considera:
int y = 5; // declara la variable y
int *yPtr; // declara la variable apuntador yPtr, entonces
yPtr = &y; // asigna la dirección de y a yPtr
asigna la dirección de la variable y a la variable apuntador
yPtr . Entonces, se dice que la variable yPtr “apunta a” y.
Ahora, yPtr hace referencia indirecta al valor de la
variable y. Observe que el uso del signo & en la
instrucción anterior no es el mismo que el uso del & en la
declaración de una variable de referencia, a la cual
siempre se le antepone el nombre de un tipo de datos. Al
declarar una referencia, el & forma parte del tipo. En una
expresión como &y, el & es un operador.

El operador * , que se conoce comúnmente como el
operador de indirección u operador de desreferencia,
devuelve “un sinónimo” (es decir, un alias o sobrenombre)
para el objeto al que apunta su operando apuntador. Por
ejemplo cout << *yPtr << endl; muestra el valor de la
variable y (en este caso, 5 ), al igual que la instrucción
cout << y << endl;
Al proceso de utilizar el * de esta manera, se le conoce
como desreferenciar un apuntador. Observe que un
apuntador desreferenciado también se puede usar en el
lado izquierdo de una instrucción de asignación, como en
*yPtr = 9; lo cual asignaría 9 a y.

#include <iostream>
using std::cout;
using std::endl;
int main()
{int a; // a es un entero
int *aPtr; // aPtr es un int * -- apuntador a un entero
a = 7; // se asigna 7 a la variable a
aPtr = &a; // se asigna la dirección de a a aPtr
cout << "La dirección de a es " << &a <<
"nEl valor de aPtr es " << aPtr;
cout << "nnEl valor de a es " << a <<
"nEl valor de *aPtr es " << *aPtr;
cout << "ndemostración que * y & son inversos " <<
"uno del otro.n&*aPtr = " << &*aPtr << "n*&aPtr = "
<< *&aPtr << endl;
return 0; // indica que terminó correctamente
} // fin de main
#include <iostream>
using std::cout;
using std::endl;
int main()
{int a; // a es un entero
int *aPtr; // aPtr es un int * -- apuntador a un entero
a = 7; // se asigna 7 a la variable a
aPtr = &a; // se asigna la dirección de a a aPtr
cout << "La dirección de a es " << &a <<
"nEl valor de aPtr es " << aPtr;
cout << "nnEl valor de a es " << a <<
"nEl valor de *aPtr es " << *aPtr;
cout << "ndemostración que * y & son inversos " <<
"uno del otro.n&*aPtr = " << &*aPtr << "n*&aPtr = "
<< *&aPtr << endl;
} // fin de main

Paso de parámetros de variables tipo puntero.
El tipo puntero es un tipo simple, y por tanto se tratará
así. En caso de paso de parámetros de tipo puntero, si es
un parámetro de entrada, entonces se utilizará el paso
por valor, y si es un parámetro de salida o de
entrada/salida, entonces se usa el paso por referencia.
Hay que ser consciente que un parámetro de tipo puntero
puede apuntar a una variable dinámica, y en este caso, a
partir del parámetro se puede acceder a la variable
apuntada.

Paso de argumentos a funciones por
referencia mediante apuntadores.
En C++ hay tres formas de pasar argumentos a una
función:
 Paso por valor.
 Paso por referencia con argumentos tipo referencia.
 Paso por referencia con argumentos tipo apuntador.
Puede usarse return para devolver un valor de una
función llamada a la función que la llamó (o puede
devolverse el control de una función llamada sin devolver
un valor). Pueden pasarse argumentos a una función
mediante el uso de argumentos tipo referencia. Dichos
argumentos permiten a la función llamada modificar los
valores originales de los argumentos en la función que
hizo la llamada.

Los argumentos tipo referencia también permiten a
los programas pasar objetos de datos grandes a una
función, y evitar la sobrecarga de pasar los objetos por
valor (que, desde luego, requiere de la creación de una
copia del objeto). Al igual que las referencias, los
apuntadores también pueden usarse para modificar
una o más variables en la función que hace la
llamada, o pasar apuntadores a objetos de datos
grandes para evitar la sobrecarga de pasar los objetos
por valor.

Puede usar apuntadores y el operador indirección ( * )
para realizar el paso por referencia (en forma idéntica
al paso por referencia en los programas en C, ya que
éste no tiene referencias). Cuando se llama a una función
con un argumento que se debe modificar, se pasa la
dirección del argumento. Para realizar esto se aplica el
operador dirección ( & ) al nombre de la variable cuyo
valor se va a modificar. Los arreglos no se pasan
usando el operador &, ya que el nombre del arreglo es
la ubicación inicial en memoria del mismo (es decir, el
nombre de un arreglo ya es un apuntador.)

El nombre de un arreglo, nombreArreglo, es
equivalente a &nombreArreglo[0]. Cuando se pasa la
dirección de una variable a una función, el operador
indirección (*) se puede usar en la función para
formar un sinónimo para el nombre de la variable;
esto a su vez se puede utilizar para modificar el valor de
la variable en esa ubicación en la memoria de la función
que hizo la llamada.

Ejemplo: Una función que eleva un entero al cubo:
cuboPorValor y cuboPorReferencia. Se pasa la variable
numero por valor a la función cuboPorValor. La función
cuboPorValor eleva su argumento al cubo y pasa el
nuevo valor de vuelta a main, usando una instrucción
return. El nuevo valor se asigna a numero en main.
Observe que la función que llama tiene la oportunidad de
examinar el resultado de la llamada a la función antes de
modificar el valor de la variable numero. Por ejemplo, en
este programa podría haberse almacenado el resultado
de cuboPorValor en otra variable, para después examinar
su valor y asignar el resultado a numero, sólo después de
determinar que el valor devuelto era razonable.

#include <iostream>
using std::cout;
using std::endl;
int cuboPorValor( int ); // prototipo
int main()
{ int numero = 5;
cout << "El valor original de numero
es " << numero;
numero = cuboPorValor( numero );
/ * pasa el numero por valor a
cuboPorValor * /
#include <iostream>
using std::cout;
using std::endl;
int cuboPorValor( int ); // prototipo
int main()
{ int numero = 5;
cout << "El valor original de numero
es " << numero;
numero = cuboPorValor( numero );
/ * pasa el numero por valor a
cuboPorValor * /

cout << "nEl nuevo valor de numero es "
<< numero << endl;
return 0;
/ * indica que terminó correctamente * /
} // fin de main
/ * calcula y devuelve el cubo del argumento
entero * /
int cuboPorValor( int n )
{ return n * n * n;
/ * eleva al cubo la variable local n y
devuelve el resultado */
} // fin de la función cuboPorValor
<< numero << endl;
return 0;
/ * indica que terminó correctamente * /
} // fin de main
/ * calcula y devuelve el cubo del argumento
entero * /
int cuboPorValor( int n )
{ return n * n * n;
/ * eleva al cubo la variable local n y
devuelve el resultado */
} // fin de la función cuboPorValor

Ejemplo: Se pasa la variable numero a la función
cuboPorReferencia mediante el uso del paso por
referencia con un argumento tipo apuntador; la
dirección de numero se pasa a la función. La función
cuboPorReferencia especifica el parámetro nPtr (un
apuntador a int) para recibir su argumento. La función
desreferencia el apuntador y eleva al cubo el valor al
que apunta nPtr. Esto modifica directamente el valor de
numero en main.

Una función que recibe una dirección como
argumento debe definir un parámetro tipo apuntador
para recibir la dirección. Por ejemplo, el encabezado
para la función cuboPorReferencia especifica que
cuboPorReferencia debe recibir la dirección de una
variable int (es decir, un apuntador a un int) como
argumento, debe almacenar la dirección en forma local
en nPtr y no debe devolver un valor. El prototipo de
función para cuboPorReferencia contiene int* entre
paréntesis. Al igual que con otros tipos de variables, no
es necesario incluir los nombres de los parámetros
tipo apuntador en los prototipos de función.

#include <iostream>
using std::cout; using std::endl;
void cuboPorReferencia( int * ); // prototipo
int main()
{ int numero = 5;
cout << "El valor original de numero es " << numero;
cuboPorReferencia( &numero );
// pasa la dirección de numero a cuboPorReferencia
<< numero << endl;
} // fin de main
// calcula el cubo de *nPtr; modifica la variable numero en main
void cuboPorReferencia( int *nPtr )
{ *nPtr = *nPtr * *nPtr * *nPtr;
// eleva *nPtr al cubo
} // fin de la función cuboPorReferencia
#include <iostream>
using std::cout; using std::endl;
void cuboPorReferencia( int * ); // prototipo
int main()
{ int numero = 5;
cout << "El valor original de numero es " << numero;
cuboPorReferencia( &numero );
// pasa la dirección de numero a cuboPorReferencia
<< numero << endl;
} // fin de main
// calcula el cubo de *nPtr; modifica la variable numero en main
void cuboPorReferencia( int *nPtr )
{ *nPtr = *nPtr * *nPtr * *nPtr;
// eleva *nPtr al cubo
} // fin de la función cuboPorReferencia

Temas de debate:
Dos apuntadores que apuntan a distintos arreglos no
se pueden comparar de una forma que tenga sentido.
Como el nombre de un arreglo es un apuntador al
primer elemento del arreglo, los nombres de los arreglos
se pueden manipular precisamente de la misma forma
que los apuntadores.

Ejercicios:
1. Declarar un apuntador vPtr que apunte a un objeto del
tipo unisgned int.
2.Declarar la variable fPtr para que sea un apuntador a un
objeto de tipo double.
3.Asignar la dirección de la variable numero1 a la variable
apuntador fPtr.
4.Escribir el encabezado para una función llamada
intercambiar, que reciba dos apuntadores a los números
de punto flotante con precisión doble x y y como
parámetros, y no devuelva un valor.
5.Escribir el prototipo para la función anterior.
6.Escribir el encabezado para una función llamada evaluar,
que devuelva un entero y reciba como parámetros el
entero x y un apuntador a la función poly. Esta función
debe recibir un parámetro entero y devolver un entero.
7.Escribir el prototipo para la función anterior.

Puntero a una función:
Un puntero a una función que no tiene argumentos y
no retorna nada, sería void (*funcPtr)(); Para
entenderla empiece en el medio y vaya hacia
afuera, es decir significa empezar con el nombre de
la variable, que es funPtr. Ir hacia afuera es mirar al
elemento inmediatamente a la derecha (nada en
este caso; el paréntesis derecho marca el fin de ese
elemento), después mirar a la izquierda (un puntero
denotado por el *), después mirar de nuevo a la
derecha (lista de argumentos vacía que indica que
no toma argumentos), después a la izquierda (void,
indica que retorna nada). Este movimiento derecha-
izquierda-derecha funciona con la mayoría de las
declaraciones.

*funcPtr necesita paréntesis para “tener contra
qué chocar” cuando vaya hacia la izquierda y
encuentre el *, en lugar de continuar hacia la
derecha y encontrar la lista de argumentos vacía.
Una vez ha definido un puntero a función, debe
asignarle la dirección de una función antes de
poder usarlo. La dirección de una función func() se
obtiene con el nombre de la función sin lista de
argumentos (func). También puede usar una
sintáxis más explícita: &func(). Para invocar la
función, debe dereferenciar el puntero de la misma
forma que lo ha declarado (recuerde que C y C++
siempre intentan hacer que las definiciones se
parezcan al modo en que se usan).

#include <iostream>
using namespace std;
void func()
{ cout << "func() called..." << endl; }
int main()
{ void (*fp)(); // Define a function pointer
fp = func; // Initialize it
(*fp)();
// Dereferencing calls the function
void (*fp2)() = func; // Define and initialize
(*fp2)(); }
#include <iostream>
using namespace std;
void func()
{ cout << "func() called..." << endl; }
int main()
{ void (*fp)(); // Define a function pointer
fp = func; // Initialize it
(*fp)();
// Dereferencing calls the function
void (*fp2)() = func; // Define and initialize
(*fp2)(); }

Una vez definido el puntero a función fp, se le asigna
la dirección de una función func() usando fp = func
(fíjese que la lista de argumentos no aparece junto al
nombre de la función). El segundo caso muestra una
definición e inicialización simultánea.

Definición de punteros en C++ en Introducción a la Programación

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a Definición de punteros en C++ en Introducción a la Programación

Similar a Definición de punteros en C++ en Introducción a la Programación (20)

Más de Facultad de Ciencias y Sistemas

Más de Facultad de Ciencias y Sistemas (20)

Último

Último (20)

Definición de punteros en C++ en Introducción a la Programación