[C++] Gestione di matrici e aumento memoria all'infinito

[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

[Pacio88]

Non capisco cosa intendi quando dici che la memoria cresce all'infinito. Dove e perchè cresce?

[mamo139]

Originariamente inviato da Pacio88
Non capisco cosa intendi quando dici che la memoria cresce all'infinito. Dove e perchè cresce?

cresce nel senso che ad ogni iterazione del cliclo for si crea un nuovo oggetto ma nessun oggetto viene distrutto... quindi se ci fossero infinite iterazioni la memoria occupata diventerebbe infinita

il problema l'ho risolto utilizzando questi due sistemi per ottimizzare la copia

http://en.wikipedia.org/wiki/Copy_constructor
http://en.wikipedia.org/wiki/Assignm...tor_in_C%2B%2B

e mettendo nel distruttore il codice per disallocare l'array bidimensionale