Funciones.

Una función es un conjunto de líneas de código que realizan una tarea específica y puede retornar un valor. Las funciones pueden tomar parámetros que modifiquen su funcionamiento. Las funciones son utilizadas para descomponer grandes problemas en tareas simples y para implementar operaciones que son comúnmente utilizadas durante un programa y de esta manera reducir la cantidad de código. Cuando una función es invocada se le pasa el control a la misma, una vez que esta finalizó con su tarea el control es devuelto al punto desde el cual la función fue llamada.

Ejemplo de una función

Para comenzar, vamos a considerar el caso en el cual se desea crear la función cuadrado(), que deberá devolver el cuadrado de un número real (de punto flotante), es decir, cuadrado() aceptará números de punto flotante y regresará una respuesta como número flotante.

Nota: aunque para la función que veremos el tipo de retorno coincide con el tipo de parámetro pasado, algunas veces las cosas pueden cambiar, es decir, no es obligatorio que una función reciba un parámetro de un tipo y que tenga que regresar una respuesta de dicho tipo.

// regresar el cuadrado de un número

double Cuadrado(double n)

{

    return n*n;

}

Normalmente, las funciones operan sobre ciertos valores pasados a las mismas ya sea como constantes literales o como variables, aunque se pueden definir funciones que no reciban parámetros. Existen dos formas en C++ de pasar parámetros a una función; por referencia o por valor. El hecho es que si en una declaración de función se declaran parámetros por referencia, a los mismos no se les podrá pasar valores literales ya que las referencias apuntan a objetos (variables o funciones) residentes en la memoria; por otro lado, si un parámetro es declarado para ser pasado por valor, el mismo puede pasarse como una constante literal o como una variable. Los parámetros pasados por referencia pueden ser alterados por la función que los reciba, mientras que los parametros pasados por valor o copía no pueden ser alterados por la función que los recibe, es decir, la función puede manipular a su antojo al parámetro, pero ningún cambio hecho sobre este se reflejará en el parámetro original.

Parametros por valor

La función cuadrado() (ver arriba) es un clásico ejemplo que muestra el paso de parámetros por valor, en ese sentido la función cuadrado() recibe una copia del parámetro n. En la misma función se puede observar que se realiza un calculo ( n*n ), sin embargo el parámetro original no sufrirá cambio alguno, esto seguirá siendo cierto aún cuando dentro de la función hubiera una instrucción parecida a n = n * n; o n*=n;.

Parametros por referencia

Para mostrar un ejemplo del paso de parámetros por referencia, vamos a retomar el caso de la función cuadrado, salvo que en esta ocasión cambiaremos ligeramente la sintaxis para definir la misma. Veamos:

// regresar el cuadrado de un número

double cuadrado2(double &n)

{

    n *= n;

    return n;

}

Al poner a prueba las funciones cuadrado() y cuadrado2() se podrá verificar que la primera de estas no cambia el valor del parámetro original, mientras que la segunda sí lo hace.

para llamar a la función cuadrado() vista anteriormente, podemos emplear:

cout << cuadrado(25);

cout << cuadrado(X);

R = cuadrado(X); // guardar en R el cuadrado de X

Bajo ciertas circunstancias se deseará escribir funciones que no regresen valor alguno (esto sería algo parecido a escribir procedures en Pascal) y para ello podemos declarar a la función como void. La palabra reservada void es utilizada para declarar funciones sin valor de retorno y también para indicar que una función específica no requiere de parámetros. Por ejemplo, la función pausa() que se verá en seguida, no devolverá valor alguno y la misma no requiere de parámetros.

// esta función requiere de la librería iostream

void pausa(void)

{

    cout << "Por favor presione <Enter> HOLA...";

    cin.get();

    cin.ignore(255, '\n');  // rechazar caracteres introducidos antes de <Enter>

}

Notas: se debe de aclarar que el uso de la palabra void dentro de los parentesis es opcional al momento de declarar una función. Así, la función pausa() podría haberse declarado como void pausa(), y la misma puede invocarse como: pausa();.

Las funciones predefinidas estan incluidas en los archivos de cabecera, los que se incluyen en el programa al principio con 
#include < > 
Por ejemplo iostream.h tiene: 
cin>>; 
cout<<; 
cerr; 
clog; 
y cada archivo de cabecera tiene las propias, que podes ver abriendo ese archivo que esta en la carpeta include con un editor de texto, alli estan definidas las funciones de cada uno aparte del codigo. 
conio.h: 
clreol( ); 
clrscr( ); 
gotoxy( int __x, int __y ); 
wherex( ); 
wherey( ); 
getch( ); 
getche( ); 
kbhit( ); 
putch( ); 
stdio.h: 
FILE 

stdin () 
stdout () 
stderr () 
stdaux () 
stdprn () 

Recursividad

La recursividad es una técnica de programación elemental que permite que una función pueda llamarse asimismo desde la misma función. Se puede utilizar la recursividad como una alternativa a la iteración. La recursividad es una herramienta poderosa e importante en la resolución de problemas en programación. Una solución recursiva es normalmente menos eficiente en términos de tiempo de computadora que una solución iterativa debido a las operaciones auxiliares que llevan consigo las llamadas suplementarias a las funciones: sin embargo, en muchas circunstancias el uso de la recursión permite a los programadores especificar las soluciones naturales, más lógicas, elegantes, sencillas, que serían, en caso contrario difícil de resolver.

Ventajas y desventajas de la Recursividad:

Ventajas:

·         No es necesario definir la secuencia de pasos exacta para resolver el problema.

·         Soluciones simples, claras.

·         Soluciones elegantes.

·         Soluciones a problemas complejos.

Desventajas:

·         Podría ser menos eficiente.

·         Sobrecarga asociada con las llamadas a subalgoritmos

·         Una simple llamada puede generar un gran número de llamadas Recursivas. (Fact(n) genera n llamadas recursivas)

·         El valor de la recursividad reside en el hecho de que se puede usar para resolver problemas sin fácil solución iterativa.

·         La ineficiencia inherente de algunos algoritmos recursivos.

Ejemplos de funciones recursivas en C++:

1.       // Sumar los dígitos de un número

#include <iostream>

using namespace std;

int SumaDigitos(int);

int main() {

    cout << 32890123 << ": " << SumaDigitos(32890123) << endl;

    return 0;

}

int SumaDigitos(int n) {

    if(n < 10) return n;

    return n%10+SumaDigitos(n/10);

}

ESTRUCTURAS DE CONTROL

Las estructuras de control de un programa CONTROLAN la ejecución de un programa y solo deben tener un punto de inicio y punto de salida.

Se dividen en tres: SECUENCIA, SELECCIÓN e ITERACION.

ESTRUCTURAS DE CONTROL CONDICIONALES

Las estrucutras de control condicionales o selectivas, nos permiten decidir  que ejecutar y que no en un programa.

• ESTRUCTURA DE CONTROL CONDICIONAL if

Nos permite elegir si se ejecuta o no un bloque de instrucciones

Sintaxis

if (condición)

sentencia;

if (condición) {

bloque

}

Ejemplo:

#include <stdio.h>

void main ()

{

int x;

printf(“Déme un numero”);

scanf(“%d”,&x);

if (x>0) {

printf(“El numero es positivo”);

 }

getch();

}

• Clausula else

Permite ejecutar un bloque de código si se cumple la condición y otro bloque de código diferente si la condición no se cumple.

z|

Sintaxis

if (condición)

sentencia1;

else

sentencia2;

if (condición) {

bloque1

} else {

bloque2

}

Ejemplo:

void main ()

{

int x;

printf(“Déme un numero: ”);

scanf(“%d”,&x);

if (x>=0)

printf(“El numero es positivo”);

else

printf(“El numero es negativo”);

}

• Sentencia switch

Permite seleccionar entre varias alternativas posibles

Sintaxis

switch (expresión) {

case expr_cte1:

sentencia1;

case expr_cte2:

sentencia2;

...

caseexpr_cteN:

sentenciaN;

default:

sentencia;

 }

Se ejecutan toda las sentencias incluidas a partir del caso correspondiente, salvo que explícitamente usemos break.

Ejemplo

ESTRUCTURAS DE CONTROL REPETITIVAS O ITERATIVAS(ciclos o bucles)

Un bucle o ciclo es tan solo una sentencia o un mandato que se repite continuamente hasta cumplir la condición, es una manera de evitar tener que escribir tanto una codificación. 

La iteración es cada repetición de una instrucción en un bucle.

• Buclewhile

El propósito es repetir un bloque de instrucciones mientras una condición se mantenga verdadera

Sintaxis

while (condición)

sentencia;

while (condición) {

bloque

}

Ejemplo:

#include<stdio.h>

voidmain ()

{

int n, i;

printf (“Introduzca un número: ”);

scanf (“%d”, &n);

 i=0; // Inicialización del contador

while (i<=10) {

printf (“%d x %d = %d\n“, n, i, n*i);

i++; 

                            }

}

• Bucle DO WHILE

Tipo de bucle, similar al while, que realiza la comprobación de la condición después de ejecutar el cuerpo del bucle.

Sintaxis

do

sentencia;

while (condición);

do {

bloque

}

while (condición);

Ejemplo;

Progrma que valida que un numero este en el rango de 10 a 20

#include <iostream.h>

intnum;

void main()

 {

 do

     {

        Printf("Dame el numero ");

        Scanf(“%d”,&num);

      }

    while ( (num<10) || (num> 20) );

printf("Numero dentro de rango");

• Bucle for

El bucle FOR se utiliza para repetir una o más instrucciones un determinado número de veces. De entre todos los bucles, el FOR se suele utilizar cuando sabemos seguro el número de veces que queremos que se ejecute

Sintaxis

for (exp1; exp2; exp3)

{

bloque;

}

Ejemplo:

Programa que imprime los números del 1 al 20

#include<stdio.h>

Int x;

Void main()

{

clrscr();

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

Printf(“%d”,x);

getch();

}

ETIQUETAS

Los programas C++ se ejecutan secuencialmente, es decir, las sentencias se ejecutan una a continuación de otra, en el mismo orden en que están escritas en el programa.

Sin embargo, esta secuencia puede ser interrumpida de varias maneras, mediante el uso de sentencias de salto.

Las etiquetas son la forma en que se indica al compilador en qué puntos será reanudada la ejecución de un programa cuando se produzca una ruptura del orden secuencial de ejecución.

GO TO

En lenguaje C, para escribir unainstrucción de salto goto (ir a), se utiliza la sintaxis:

goto<nombre de la etiqueta>

#include <stdio.h>

int main()

{ /* Abre main */

printf("\nEsta es la primera instruccion del programa.");

/* Se usa goto */

gotoinstruccion;

printf("\nEsta es la segunda instruccion del programa.");

instruccion:

printf("\nEsta es la tercera instruccion del programa.");

printf("\nEsta es la cuarta instruccion del programa.\n");

return0;

} /* Cierra main */

C proporciona cinco diferentes elementos para creación de tipos de datos propios, es decir, tipos de datos que permiten al programador crear aplicaciones más potentes:

• Estructuras: es la agrupación de variables del diferente tipo, bajo un mismo nombre.

• Unión: permite que la misma parte de memoria sea definida como dos o más tipos de variables diferentes.

• Campo de bits: es un tipo especial de estructura o unión que permite el fácil acceso a bits individuales.

• Enumeración: es una lista de constantes enteras con Nombre

Arrays y cadenas

 Las cadenas son arrays de caracteres (tipo char), terminado en un carácter nulo. Se pueden

inicializar al momento de la declaración, si se desea, en cuyo caso se hará usando las comillas.

– Ejemplo: char ciudad[20]=“San Sebastian”;

 char name[]=“Juan Pablo”;

 char *direccion=“Paseo Manuel Lardizabal 13”;

En la forma 2 y 3, el compilador reserva el número de caracteres para almacenar la información

Las cadenas suelen contener texto (nombres, frases, etc.), y éste se almacena en la parte inicial de la cadena. Para separar la parte de la cadena que contiene el texto de la parte no utilizada, se usa el carácter fin de texto que es el carácter nulo (‘\0’). Este carácter se introduce automáticamente al inicializar la cadena.

 En una cadena se puede acceder de forma independiente a cada elemento, de la misma manera como se hace con los vectores, por ejemplo:

char name[20];

name[0]='J';name[1]='u';name[2]='a'; name[3]='n'; name[4]='\0';

cout << name;

 Para la lectura de cadenas desde la consola, la sentencia cin presenta una dificultad: no acepta los espacios ni las tabulaciones, corta las frases.

 Para poder capturar una frase completa (con espacios), se puede utilizar la sentencia gets(), la cual forma parte de la biblioteca estándar del C++. Su forma general es:

gets(nombre_de_cadena);

Para usar esta función, es necesario incluir el fichero <stdio.h> en nuestro programa.

#include <iostream.h>

#include <stdio.h> //para gets()

#include <string.h> //para strlen()

void main (){

char frase[80];

cout << "Escriba una frase (<de 80 caract):";

cin >> frase;

cout << "Frase con cin:" << frase << endl;

//con gets

cout << "Escriba otra frase (<de 80 caract):"<<endl;

gets(frase);

cout << "Frase con gets():" << frase << endl <<endl;

//imprimir los elementos, uno a uno

int len=strlen(frase);

for (int i=0;i<len;i++){

cout << frase[i] << " <-> " << (int)frase[i] << endl;

}

}

• El siguiente ejemplo nos muestra el uso de gets() y cin con las cadenas. Asímismo podemos ver cómo acceder a cada uno de los elementos de la cadena.

• Se usa una de las funciones de la biblioteca del C++: strlen(), la cual nos devuelve la longitud de la cadena, sin considerar el carácter nulo (‘\0’);

#include <iostream.h>

#include <stdio.h> //para gets()

#include <string.h> //para strlen()

void main (){

char frase[80];

cout << "Escriba una frase (<de 80 caract):";

cin >> frase;

cout << "Frase con cin:" << frase << endl;

//con gets

cout << "Escriba otra frase (<de 80 caract):"<<endl;

gets(frase);

cout << "Frase con gets():" << frase << endl <<endl;

//imprimir los elementos, uno a uno

int len=strlen(frase);

for (int i=0;i<len;i++){

cout << frase[i] << " <-> " << (int)frase[i] << endl;

}

}

Estructuras y uniones

• Estructuras:

– Una estructura es una forma de agrupar un conjunto de datos de distinto tipo bajo un mismo nombre o identificador.

– A cada uno de los datos de la estructura se le denomina miembro.

– Diseñaremos una sencilla estructura que guarde los datos de un alumno: Nombre,

Apellidos, Carné y Edad.

struct alumno{

char nombre[30];

char apellidos[80];

int edad;

unsigned long carnet;

}; //no olvidar el “;” al final de “}”

– La estructura crea un nuevo tipo de datos (en nuestro ejemplo es alumno). Para poder utilizar este nuevo tipo, hay que crear una nueva variable (tal como se hace con los tipos estándar de C++):

alumno alumno1, alumno2; //se crean dos variables

alumno1 y alumno2 serán dos nuevas variables del tipo alumno.

– Para acceder a los miembros de una estructura, se utiliza el operador punto (.), precedido por el nombre de la estructura y seguido por el nombre del miembro.

alumno1.carnet = 900111;

– Se pueden realizar cualquier tipo de operaciones normales con los miembros de la estructura:

cout << alumno1.nombre;

struct nombre{

tipo1 miembro1;

tipo2 miembro2;

tipon miembron;};

Estructuras y uniones

– También se puede crear de forma directa las variables de una estructura, al declararla:

struct fecha{

short dia,mes,año;

} dia1,dia2;

Se han creado de forma directa dos nuevas variables (dia1 y dia2) del tipo fecha.

–– Array’s de estructuras: También se pueden crear array’s de estructuras, de la misma forma que se hace con los otros tipos. Por ejemplo, siguiendo con nuestra estructura alumno, podemos crear un array para almacenar los datos de 300 alumnos:

alumno datos[300];

datos[0].carnet=900111;

datos[1].carnet=900112;

...

datos[299].carnet=900410;

Para acceder a los miembros del array de estructuras se hace de la misma que los tipos estándar,

es decir con un índice entre los corchetes.

–– Ámbito de una estructura: Se refiere a que los nombres de los miembros de una estructura son locales a la estructura y no interfieren con nombres iguales de variables del mismo tipo que estén fuera de la estructura. Por ejemplo:

struct complejo{

float x1,y1;

} c1;

int x1;

c1.x1=2.5;

x1=5;

La variable x1, tipo float, no interfiere con la variable x1, tipo int, del programa, ya que se encuentra dentro del ámbito de la estructura y para acceder a ella se hace mediante el nombre de la nueva variable creada: c1.

Estructuras y uniones

• Uniones:

– Una unión es otro tipo de datos complejo o agregado (al igual que las estructuras), con la particularidad que consta de una sola posición de memoria que es compartida por dos o más variables. También utilizan un mismo nombre o identificador para agrupar dichos datos.

– A las variables de una unión también se les denomina miembros.

union nombre{

tipo miembro1;

tipo miembro2;

....

tipo miembroN;

} variables;

Ejemplo:

union dato{

unsigned char ch[4];

float valor;

}dat1;

Para acceder a los miembros de la unión, también se utiliza el operador punto (.):

dat1.valor=30.2525;

cout <<(int)dat1.ch[0] << " "<<(int)dat1.ch[3];

dat1.ch[3]=64;

cout << endl << dat1.valor << endl;

Ejemplos

Sistema de 2 ecuaciones

del tipo aX+bY=c

#include <iostream.h>

void main(void)

{

float MatA[2][2], MatC[2], det, x, y;

cout << "Sistema de ecuaciones:\n";

cout << " aX + bY = c1 \n";

cout << " cX + dY = c2 \n";

cout << "----------------- \n";

cout << "Dar los coeficientes a b c y d: ";

cin>>MatA[0][0]>>MatA[0][1]>>MatA[1][0]>>MatA[1][1];

cout << "Dar los coeficientes c1 y c2: ";

cin >> MatC[0] >> MatC[1];

// resolvemos

det = MatA[0][0]*MatA[1][1] - MatA[0][1]*MatA[1][0];

x = (MatC[0]*MatA[1][1] - MatC[1]*MatA[0][1])/det;

y = (MatA[0][0]*MatC[1] - MatA[1][0]*MatC[0])/det;

cout << x << " " << y << endl;

Escribir una frase invertida

#include <iostream.h>

void main(void)

{

float MatA[2][2], MatC[2], det, x, y;

cout << "Sistema de ecuaciones:\n";

cout << " aX + bY = c1 \n";

cout << " cX + dY = c2 \n";

cout << "----------------- \n";

cout << "Dar los coeficientes a b c y d: ";

cin>>MatA[0][0]>>MatA[0][1]>>MatA[1][0]>>MatA[1][1];

cout << "Dar los coeficientes c1 y c2: ";

cin >> MatC[0] >> MatC[1];

// resolvemos

det = MatA[0][0]*MatA[1][1] - MatA[0][1]*MatA[1][0];

x = (MatC[0]*MatA[1][1] - MatC[1]*MatA[0][1])/det;

y = (MatA[0][0]*MatC[1] - MatA[1][0]*MatC[0])/det;

cout << x << " " << y << endl;

PUNTEROS

Un puntero es una variable  que contiene la dirección de otra variable, también podiramos decir que un puntero es una variable que representa la posición (mas que el valor) de otro dato, tal como una variable o un elemento del array.

Sintaxis

int *punteroID, ID;

´punteroID´es un punter a int, mientras que la variable ID es solo una variable de tipo entero. Todo puntero debe ser precedido por un * en la declaración. Se puede declarar mas de un puntero en la misma sentencia.

Int *punteroX, *punteroy;

ID=8;

punteroID =&ID; // punter a ID

Operadores de punteros

Existen dos operadores a tener en cuenta cuando trabajamos con punteros, el operador de dirección (&) que devuelve la dirección de memoria de su operando y el operador de indirección (*) que devuelve un alias para el objeto al cual apunta el operando del puntero.

En el siguiente ejemplo vemos como se inicializa una variable X con el valor 15. Luego se crea un puntero a int y por último el puntero pasa a apuntar a la variable X. Esto es, punteroX es un puntero a X.

Int x=15;

Int *punteroX;

punteroX=&x;

PUNTEROS Y ARRAYS

Hay una relación muy cercana entre los punteros y los arrays .La explicación de ésto es ahora sencilla : el nombre de un array , para el compilador C , es un PUNTERO inicializado con la dirección del primer elemento del array . Sin embargo hay una importante diferencia entre ambos , que haremos notar más abajo.

Asignacion

float var1 , conjunto[] = { 9.0 , 8.0 , 7.0 , 6.0 , 5.0 );

float *punt ;

punt = conjunto ;    /* equivalente a hacer : punt = &conjunto [0] */

var1 = *punt ;

*punt = 25.1 ;

Es perfectamente válido asignar a un puntero el valor de otro , el resultado de ésta operación es cargar en el puntero punt la dirección del elemento [0] del array conjunto , y posteriormente en la variable var1 el valor del mismo (9.0) y para luego cambiar el valor de dicho primer elemento a 25.1 . 
Veamos cual es la diferencia entre un puntero y el denominador de un array : el primero es una VARIABLE , es decir que puedo asignarlo , incrementarlo etc , en cambio el segundo es una CONSTANTE , que apunta siempre al primer elemento del array con que fué declarado , por lo que su contenido NO PUEDE SER VARIADO . Si lo piensa un poco , es lógico , ya que "conjunto" implica la dirección del elemento conjunto [0] , por lo que , si yo cambiara su valor , apuntaría a otro lado dejando de ser , "conjunto" .

Incremento y decremento de un puntero

int *pint , arreglo_int[5] ;

double *pdou , arreglo_dou[6] ;

pint = arreglo_int ;      /* pint apunta a arreglo_int[0] */

pdou = arreglo_dou ;      /* pdou apunta a arreglo_dou[0] */ 

pint += 1 ;              /* pint apunta a arreglo_int[1]  */

pdou += 1 ;              /* pdou apunta a arreglo_dou[1]  */ 

pint++ ;                  /* pint apunta a arreglo_int[2] */

pdou++ ;                  /* pdou apunta a arreglo_dou[2] */ 

Hemos declarado y asignado dos punteros , uno a int y otro a double , con las direcciones de dos arrays de esas caracteristicas . Ambos estarán ahora apuntando a los elementos [0] de los arrays . En las dos instrucciones siguientes incrementamos en uno dichos punteros . ¿ adonde apuntaran ahora ?. 
Para el compilador , éstas sentencias se leen como : incremente el contenido del puntero ( dirección del primer elemento del array ) en un número igual a la cantidad de bytes que tiene la variable con que fué declarado . Es decir que el contenido de pint es incrementado en dos bytes (un int tiene 2 bytes ) mientras que pdou es incrementado 8 bytes ( por ser un puntero a double ) , el resultado entonces es el mismo para ambos , ya que luego de la operación quedan apuntando al elemento SIGUIENTE del array , arreglo_int[1] y arreglo_dou[1] . 
Vemos que de ésta manera será muy facil "barrer" arrays , independientemente del tamaño de variables que lo compongan , permitiendo por otro lado que el programa sea transportable a distintos hardwares sin preocuparnos de la diferente cantidad de bytes que pueden asignar los mismos , a un dado tipo de variable . 
De manera similar las dos instrucciones siguientes , vuelven a a incrementarse los punteros , apuntando ahora a los elementos siguientes de los arrays. 
Todo lo dicho es aplicable , en identica manera , al operador de decremento -- .

Punteros a funciones

Los punteros a funciones ya existían en C, aunque no se utilizan regularmente. Veamos un ejemplo:

#include<iostream.h>

voidprintMensaje (float dato);
voidprintNumero (float dato);
void (*funcPuntero)(float);

main()
{
  float pi = 3.14159;
  printMensaje(pi);
  funcPuntero = printMensaje;
  funcPuntero (pi);
  funcPuntero = printNumero;
  funcPuntero (pi);
  printNumero(pi);
}

voidprintMensaje(float dato)
{
  cout<<" Esta es la funcionprintMensaje " <<'\n';
}

voidprintNumero(float dato)
{
  cout<<" Este es el dato: " << dato << '\n';
}

La salida del programa será:

Esta es la funcionprintMensaje
Esta es la funcionprintMensaje
Este es el dato: 3.14159
Este es el dato: 3.14159

Hemos declarado dos funciones, printMensaje y printNumero, y después funcPuntero, que es un puntero a una función que recibe un parámetro real y no devuelve nada (void). Las dos funciones declaradas anteriormente se ajustan precisamente a este perfil, y por tanto pueden ser llamadas por este puntero.
En la función principal, llamamos a la función printMensaje con el parámetro pi, y en la línea siguiente asignamos al puntero a función funcPuntero el valor de printMensaje y utilizamos el puntero para llamar a la misma función de nuevo. Por tanto, las dos llamadas a la función printMensaje son idénticas gracias a la utilización del puntero funcPuntero.

Dado que hemos asignado el nombre de una función a un puntero a función, y el compilador no da error, el nombre de una función debe ser un puntero a una función. Esto es exactamente lo que sucede. Un nombre de una función es un puntero a esa función, pero es un puntero constante que no puede ser cambiado. Sucede lo mismo con los vectores: el nombre de un vector es un puntero constante al primer elemento del vector.
Ya que el nombre de una función es un puntero a esa función, podemos asignar el nombre de una función a un puntero constante, y usar el puntero para llamar a la función. Pero el valor devuelto, así como el número y tipo de parámetros deben ser idénticos. Muchos compiladores de C y C++ no avisan de las diferencias entre las listas de parámetros cuando se hacen las asignaciones. Esto se debe a que las asignaciones se hacen en tiempo de ejecución, cuando la información de este tipo no está disponible para el sistema.

Asignacion dinámica de memoria

Los operadores new ydelete se utilizan para reservar y liberar memoria dinamicamente. new ydelete son parte del lenguaje C++ y no parte de una libreria como sucedia con las funciones equivalentes malloc() yfree() de C. Ahora los operadores new y delete.

El proposito de new es crear arrays cuyo tamaño pueda ser determinado mientras el programa se ejecuta.

delete funciona igual que free() EN EL LENGUAJE C. La memoria a la que apunta el puntero es liberado, pero no el puntero en si.

A continuacion se presenta a modo de ejemplo un programa que reserva memoria de mododinamico para un vector de caracteres:

#include <iostream.h>

#include <string.h>

voidmain() {

char Nombre[50];

cout<< 'Introduzca su Nombre:';

cin>> Nombre;

char *CopiaNombre = new char[strlen(Nombre)+1];

strcpy(CopiaNombre, Nombre); //copio Nombre en la variable CopiaNombre

cout<<CopiaNombre;

delete [] CopiaNombre; //libero memoria

}

Se puede utilizar el operador new para crear variables de cualquier tipo. New devuelve, en todos los casos, un puntero a la variable creada. Tambien se

puedEN EL LENGUAJE Crear variables de tipos definidos por el usuario.

struct usuario {

..........

};

usuario* Un_Usuario;

Un_Usuario = new usuario;

Cuando una variable ya no es necesaria se destruye con el operador delete para poder utilizar