Mensajes

Deberias apoyarte en algún libro para estas dudillas jeje... te pasa lo mismo que en tu anterior duda.

Código [Seleccionar] Expandir

#include <iostream>
using namespace std;

Si estas empezando, para enviar mensajes a pantallas te aconsejo cout.

Enga, saludos!

Has incluido el archivo de cabecera?

Código [Seleccionar] Expandir

#include <fstream>
using namespace std;

Y con esto, todo solucionado. Yo tb utilizo Visual Studio 2008 y no me da problemas.. enga suerte!

[fword.h]

¡Muy Buenas!

Aqui os dejo mi pequeño aporte. Se trata de un código que se encarga de cargar 'palabras' de un fichero en una lista simple para que después pueda ser leida e interpretada por otro código. Espero os resulte útil, y cualquier error, duda o crítica que me comuniqueis será bienvenida. De antemano ¡Gracias! 

Nombre Original del Archivo: fword.h

Código [Seleccionar] Expandir

#ifndef _FWORD_
#define _FWORD_
#endif

#ifndef _FSTREAM_
#include <fstream>
#endif

#ifndef NULL
#define NULL 0
#endif

struct L_word{
int wordc;
char* wordv;
struct L_word* next;
};
void L_word_add(struct L_word *&p,char* argv,int argc){
struct L_word* new_node;
struct L_word* aux_node;
new_node=new struct L_word;
new_node->next=NULL;
new_node->wordc=argc;
new_node->wordv=argv;
if(p==NULL){
p=new_node;
}else{
aux_node=p;
while(aux_node->next!=NULL){
aux_node=aux_node->next;
}
aux_node->next=new_node;
}
};
struct L_word* L_fword(char* file_name){
struct L_word* pointer=NULL;
fstream file(file_name,ios::in|ios::binary);
if(file.good()){
bool w=false;
while(!w){
int argc;
char aux;

do{
argc=0;
do{
file.read(reinterpret_cast<char*>(&aux),sizeof(char));
w=file.eof();
argc++;
}while((aux!=' ')&&(aux!='\n')&&(aux!='\t')&&(aux!='\0')&&(aux!=char(13))&&(!w));
}while((argc<2)&&(!w));

char* argv;
argv=new char[argc];

if(w){
file.clear();
file.seekg(-argc+1,ios::cur);
file.read(reinterpret_cast<char*>(argv),sizeof(char)*(argc-2));
file.read(reinterpret_cast<char*>(&aux),sizeof(char));
argv[argc-2]=aux;
}else{
file.seekg(-argc,ios::cur);
file.read(reinterpret_cast<char*>(argv),sizeof(char)*(argc-1));
}
argv[argc-1]='\0';
L_word_add(pointer,argv,argc);
file.seekg(1,ios::cur);
}
}
file.close();
return pointer;
};



Microsoft Visual Studio 2008

Libera Y y despues X...  a ver q tal... Saludos

EDIT: Olvida este comentario xD es que me acabo de parar y nu vi bien... jeje

Imagino xDD... no veía nada que liberar xDDD... enga, saludos

De hecho, eso mismo he leido... Se recomienda que se libere. De todas formas, no me fio de mis fuentes y al parecer Lambda tiene razón sobre el comportamiento del compilador... Si actúa así por default ó simplemente es como debe ser, para solucionar mi problema y liberar la memoria asignada dentro del un mismo ámbito simplemente hay que tomar punteros.

Un pseudocodigo

Código [Seleccionar] Expandir

class Objeto{...};

int main(int argc,char*argv[]){
Objeto* puntero;
puntero=new Objeto; /*se reserva la memoria*/
/*Operaciones con el objeto*/{...};
delete puntero; /*se libera la memoria*/
return 0;
}

Considero pues, solucionado el tema  

PD:Releyendo mis fuentes, no sé cómo puede presentarse en un libro de este tipo (programación) frases ambigüas que llevan a confuciones...

Es de sabios rectificar xDD...

Lambda me he dado cuenta que tienes razón. No tengo porque llamar al destructor, el error es ese... GRACIAS!!

Entonces, entiendo que se libera la memoria dinámica tras salir del ámbito?? y que no es necesario definir un método que la libere??

El problema es que NO debes de llamar tu al destructor, de eso ya se encarga el compilador.

Si no llamo al destructor la memoria no es liberada hasta el final del programa. Cosa que no deseo...

Por Default, el compilador aporta un destructor, pero si lo empleo no me libera la memoria (lo he comprobado)... asi que estamos en las mismas. Tengo que definir un método que libere la memoria...

En la práctica, lo mismo me da definir un funcion void que el destructor propiamente dicho... pero este error que comento, a priori, no debería ocurrir...

Si alguien sabe algo¿?

[¿Por qué el destructor es invocado una segunda vez cuando la hinstancia de la clase ya se ha 'destruido'?]

¡Muy buenas!

Les comento. Desde hace tiempo llevo teniendo problemas al intentar liberar un array dinámico incluido en una clase, a traves de un destructor de clase.

A modo ilustrativo propongo el siguiente ejemplo:

Código [Seleccionar] Expandir

class A{
private:
int** dato;
int Indice_1,Indice_2;
public:
void crear(int X,int Y){
//Se define el tamaño del array dato
Indice_1=X;
Indice_2=Y;
//Se reserva la memoria (Array Dinámico)
dato=new int *[X];
for(int i=0;i<X;i++){
dato[i]=new int [Y];
for(int j=0;j<Y;j++){
dato[i][j]=0;
}
}
}
~A(){
//Se libera la memoria
for(int i=0;i<Indice_1;i++){
delete[] dato[i];
}
delete[] dato;
}
};

El error que genera dice así:

Excepción no controlada en 0x102d31ea (msvcr90d.dll) en PRINCIPAL.exe: 0xC0000005: Infracción de acceso al leer la ubicación 0xfeeefee2.

Lo curioso del caso es que empleando el prefijo del destructor de clase ~ se produce el error pero, renombrando el algoritmo como una función void, esto no ocurre y funciona correctamente (se libera la memoria correctamente y el programa actua sin anomalías).

Código [Seleccionar] Expandir

void borrarA(){
       //Se libera la memoria
       for(int i=0;i<Indice_1;i++){
delete[] dato[i];
}
delete[] dato;
}

Empleando el primer código, pero situando un testigo en el destructor (tipo cout<<"DESTRUCTOR INVOCADO"<<endl), resulta que éste es invocado dos veces.  Una, cuando yo lo llamo, y otra, cuando el programa intenta finalizar. Siendo esta segunda vez la que causa el error.

Por lo que mis preguntas son:

¿Por qué el destructor es invocado una segunda vez cuando la hinstancia de la clase ya se ha 'destruido'?

¿Por qué funciona correctamente bien con void y no asi con ~ (propio del destructor de clase)?

Menciono que empleo como compliador el Visual Studio C++ 2008... creo que los tiros van por aqui jeje

¡¡Gracias por la ayuda!!