Operadores new y delete para gestión dinámica de memoria
Con los operadores new y delete se tiene entera libertad para decidir crear o destruir las variables cuando se necesite. Además una variable creada con new puede ser utilizada y manipulada por instrucciones de otros bloques.
¿Pero no existe luego una función llamada malloc()? Un aspecto diferente con la función malloc(), que es el método más utilizado para reservar dinámicamente memoria en C, es que ésta devuelve un puntero a void (*void) que es después convertido al tipo de variable que se desea. Esa conversión se evita con new, eliminando así una posible fuente de problemas.
Se puede utilizar el operador new para crear variables de cualquier tipo. New devuelve, en todos los casos, un puntero a la variable creada.
Cuando una variable ya no es necesaria se destruye con el operador delete para poder utilizar la memoria que estaba ocupando, mediante una instrucción del tipo:
Considerense los siguientes ejemplos:
Código:
/* Asignación dinámica de memoria en C */
#include<stdio.h>
#include<malloc.h>
#include<string.h>
main()
{
char *str=NULL;
/*Pide memoria para una cadena de 10 caracteres*/
str=(char *) malloc(10*sizeof(char));
strcpy(str,"Hola");
printf("La cadena es %s",str);
free(str);/*Libera la memoria*/
getchar();
}
Código:
// Asignación dinámica de memoria en C++
#include<iostream.h>
#include<string.h>
main()
{
char *str=NULL;
//Pide memoria para una cadena de 10 caracteres
str=new char(10);
strcpy(str,"Hola");
cout<<"La cadena es “<<str;
delete str;//Libera la memoria
getchar();
}
En C++ además de las funciones printf() y scanf(), que siguen estando vigentes, se pueden utilizar los operadores cin y cout. Para utilizar estos nuevos operadores es necesario incluir la librería iostream.h con la instrucción #include <iostream.h>. Así en un programa en C habría que hacer
algo de este estilo:
Código:
char nombre;
int num=2;
printf ("Introduzca el nombre del fichero %d: ", num);
scanf (" %s", nombre)
En C++ podría escribirse así:
Código:
char nombre;
int num=2;
cout << "Introduzca el nombre del fichero " << num << ": ";
cin >> nombre;
Pero aquí ¿cuál es la mejora?, si nos fijamos con los operadores << y >> (que además se pueden sobrecargar) no es necesario especificar el tipo de dato que va a ser impreso o leído, asociándolo con un formato determinado. Es el propio programa el que decide el tipo de dato en tiempo de ejecución. Estos operadores están sobrecargados de tal manera que admiten tanto los tipos predefinidos como aquellos tipos de datos definidos por el usuario.
Para poder escribir o leer desde ficheros es necesario incluir la librería <fstream.h>. A continuación se presenta un sencillo ejemplo en el que primero se escriben unas frases en un fichero y después se imprimen en la pantalla leídas desde ese fichero:
Código:
/* E/S en C*/
#include<stdio.h>
main()
{
FILE *out;
out=fopen("fichero.txt","w+");
fputs("Es mas difícil crear, declarar e inicializar flujos en C",out);
fclose(out);
// Ahora comienza la lectura
FILE *in;
in=fopen("fichero.txt","r");
char line[81];
fgets(line,sizeof(line),in);
printf("%s",line);
fclose(in);
getchar();
}
Código:
// E/S en C++
#include <fstream>
#include <iostream>
using namespace std;
main()
{
ofstream out("fichero.txt"); // se define un flujo de salida a fichero
out<<"Es mas fácil crear flujos de E/S en C++";
out.close();
// Ahora comienza la lectura
ifstream in("fichero.txt"); // se define un flujo de entrada de fichero
char line[81];
in.getline(line,81);
cout<<line<<endl;
getchar();
}
Como pueden observar, lo que se hace es declarar flujos de E/S, con lo cual se puede utilizar, en este caso, el operador << para crear el canal al archivo, mediante el cual se escribe en el, como si fuera una salida normal con el cout.
El ejemplo anterior necesita algunas explicaciones extras; se declara un objeto (ya esto hace parte de la llamada POO) del tipo ofstream llamado out. Este será un objeto que almacenará la información necesaria para llevar los datos de salida hasta un fichero llamado fichero.txt. Esto es el equivalente a utilizar la función fopen() de C para abrir un fichero de escritura de datos.
Hay que darse cuenta de que la primera vez que se abre el fichero se abre en modo de escritura. Por eso hay que cerrarlo para después poder abrirlo en modo de lectura. Para realizar esta última operación es necesario declarar un objeto, al que se llama in, del tipo ifstream. El endl que hemos venido manejando, hace que se imprima un carácter de salto de línea y que se vacíe el buffer de salida de modo inmediato.
La función getline se utiliza para leer los datos que se introduzcan desde el teclado de forma similar a la que lo haría la función scanf() leyendo una línea completa hasta el '\n'.
AGREGRACIONES DEL C++
Como ya se dijo este texto solo pretende mostrar las características del C++ frente al C. Pero no sobra mostrar una lista de las funcionalidades que no tiene C, y que en su mayoría se deben al la Programación Orientada a Objetos (POO):
●Clases y Objetos
●Clase con y sin secciones privadas
●Expansión inline
●Entrada y salida de datos mejorada
●Operadores new y delete con clases
●Constructores y destructores
●Clases y funciones friend
●El puntero this
●Sobrecarga de operadores
●Clase cadena para manejo de cadenas de caracteres
●Objetos miembro de otros objetos
●Herencia simple y herencia múltiple
●Clases base virtuales
●Polimorfismo
●Funciones miembro width(), precision() y fill()
●Manipuladores de entrada/salida
●Sobrecarga de los operadores de entrada/salida (<< y >>)
●Excepciones
http://foro.elhacker.net/index.php/topic,92989.0.html