[c++] sto scrivendo una classe per la gestione di matrici...

[mamo139]

sto scrivendo una classe per la gestione delle matrici...

matrici.h

#include <cstdlib>
#include <iostream>

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#ifndef _MATRICI_H
#define _MATRICI_H 1

//**************** class ******************//

class matrice {
public:
int r;
int c;
double ** m;

//costruttore e distruttore
matrice();
~matrice();

//crea matrice
void create(int r, int c);
void create_with_value(int r, int c, double value);

//visualizza matrice
void print();

//caricamento - salvataggio matrici
void load_from_file(char * file);
void save_in_file(char * file);

//operazioni su matrici
friend matrice operator+(matrice, matrice);


};

#endif


matrici.cpp

#include "matrici.h"

//costruttore
matrice::matrice(){
r = 0;
c = 0;
}

//distruttore
matrice::~matrice(){

}

//creazione matrice
void matrice::create(int r, int c){ // r = righe, c = colonne

int x,y;

this->r = r;
this->c = c;
m = new double *[r];
for(x=0;x<r;x++)
m[x] = new double[c];


}
void matrice::create_with_value(int r, int c, double value){

int x,y;

this->r = r;
this->c = c;
m = new double *[r];
for(x=0;x<r;x++)
m[x] = new double[c];

for(x=0;x<r;x++)
for(x=0;x<r;x++)
m[x][y] = value;

}

//visualizza matrice
void matrice::print(){

int x,y;

for(x=0;x<r;x++){
for(y=0;y<c;y++)
printf("%12.6f\x20",m[x][y]);
printf("\n");
}
printf("\n");

}

//caricamento - salvataggio matrici
void matrice::load_from_file(char * file){

FILE *stream;
char *buffer, *number;
long filesize, readed;
long x, y=0, mr=0, mc=0, r=0, c=0;

stream = fopen(file,"rb");
fseek(stream,0,SEEK_END);
filesize = ftell(stream);
rewind(stream);

buffer = (char *) malloc(filesize * sizeof(char));
number = (char *) malloc(100 * sizeof(char));
readed = fread(buffer,1,filesize,stream);

for(x=0; x<filesize ;x++){ //conta colonne
if(buffer[x] == '\x09')
mc++;
if(buffer[x] == '\x0D'){
mc++;
break;
}
}
for(x=0; x<filesize ;x++){ //conta righe
if(buffer[x] == '\x0D')
mr++;
}

create(mr, mc);

for(x=0; x<filesize ;x++){
if(buffer[x] == '\x0A')
continue;
if(buffer[x] == '\x09' || buffer[x] == '\x0D'){
number[y] = '\x00';
this->m[r][c] = atof(number);
y=0;
c++;
if(buffer[x] == '\x0D'){
r++;
c=0;
}
}
else{
number[y] = buffer[x];
y++;
}
}

}

void matrice::save_in_file(char * file){

int x,y;
FILE * stream;
stream = fopen(file, "w+");

for(x=0;x<r;x++){
for(y=0;y<c;y++){
fprintf(stream,"%.6f",m[x][y]);
if(y<c-1) fprintf(stream,"\x09");
}
fprintf(stream,"\n");
}
fclose(stream);

}

//operazioni su matrici
matrice operator+(matrice a,matrice b){

matrice c;
int x,y,i;

if(a.r != b.r || a.c != b.c)
exit(0);

c.create(a.r, a.c);

for(x=0;x<c.r;x++)
for(y=0;y<c.c;y++)
c.m[x][y] = a.m[x][y]+b.m[x][y];

return c;
}


possiamo provarla con questo codice

#include "matrici.h"


int main(int argc, char *argv[])
{
long x;

matrice a,b;
a.load_from_file("a.txt");
a.save_in_file("b.txt");

a.print();

for(x=0;x<1000000000;x++)
b = a + a;

b.print();

getchar();
return 1;
}


questo esempio di codice espone molto bene il problema: effettuando 1000000000 l'operazione b = a + a; la memoria utilizzata dal programma continua ad aumentare all'infinito... devo riuscire a liberare la memoria quando essa non serve piu.
Solo che non so come fare...

grazie :)

[british]

credo proprio che tu debba implementare l'overload dell'operatore di assegnamento ( e quindi anche il costruttore di copia e il distruttore)

ciao!

british

[fero86]

banalmente: quel programma contiene un tot di operatori new e nemmeno un delete, l'effetto collaterale che esponi mi sembra il minimo.
hint: il distruttore della classe matrice é vuoto. riempilo :D

[mamo139]

banalmente: quel programma contiene un tot di operatori new e nemmeno un delete, l'effetto collaterale che esponi mi sembra il minimo.
hint: il distruttore della classe matrice é vuoto. riempilo :D

riempito con un bel po di delete :sofico:

credo proprio che tu debba implementare l'overload dell'operatore di assegnamento ( e quindi anche il costruttore di copia e il distruttore)

ciao!

british

hai ragione... ho risolto il problema mettendo un copy constructor, un assignment operator e dei bei delete nel distruttore...

grazie a tutti e due ;)