Destructeur d'un modèle appelé en fin de constructeur d'une classe de modèle


Poooolop

J'ai quelques problèmes avec une classe de modèle sur laquelle je travaille. Voici la définition de mes classes (je n'ai gardé que les parties essentielles, d'où vient l'erreur):Sampler.h

#ifndef SAMPLER_H
#define SAMPLER_H

#include "matrix.h"
#include "MatrixOperations.h"

template <class T>
class Sampler
{
      public:
             virtual T getnumber()=0;
};

const Matrix ZEROS = zeros_mat(1,1);
const Matrix UNIT = unit_mat(1);

class NormalSampler_multi:public Sampler<Matrix>
{
   public:
           virtual Matrix getnumber();
           NormalSampler_multi(Matrix m=ZEROS, Matrix VarCovar=UNIT);
           void printMean();
           void printVar();
   private:
            Matrix mu;
            Matrix var;


};
#endif


Et le fichier cpp: Sampler.cpp

#include "Sampler.h"
#include"matrix.h"
#include "MatrixOperations.h"

#include<iostream>
#include<cstdlib>
#include<cmath>
using namespace std;

NormalSampler_multi::NormalSampler_multi(Matrix m, Matrix VarCovar){
    if(m.get_nbColumns()>1 && m.get_nbRows()>1){
        cout << "The mean should be a 1d-matrix\n";
        exit(EXIT_FAILURE);
    }
    if(VarCovar.isSymmetric()==false){
        cout << "The Variance-Covariance matrix should be symmetric\n";
        exit(EXIT_FAILURE);
    }
    mu = m;
    var = VarCovar;
}

void NormalSampler_multi::printMean(){mu.print_matrix();}
void NormalSampler_multi::printVar(){var.print_matrix();}


Matrix NormalSampler_multi::getnumber(){//Not implemented yet};

Voici mon problème. Lorsque j'exécute le code suivant:main.cpp

#include <iostream>
#include <math.h>
#include <cstdlib>
#include <time.h>
using namespace std;

#include "matrix.h"
#include "MatrixOperations.h"
#include "Sampler.h"

int main(){

    //Vector of means
    Matrix mean(5,1);
    for(int i=0;i<5;i++){
        mean(i,0) = i;
    }

    //Creation of the multidimensional sampler
    NormalSampler_multi Z(mean, variance);
    cout << "Print of the mean after assignment:" << endl;
    Z.printMean();
    cout << "Print of the variance after assignment" << endl;
    Z.printVar();
    return 0;

}

Les valeurs de muet varne sont pas les mêmes que les valeurs de meanet variance(comme elles devraient l'être). Quand je l'ai regardé, j'ai découvert que le destructeur de la Matrixclasse est appelé à la fin du constructeur de NormalSampler_multi. Donc, je suppose que cela supprime les valeurs de muet sigma, mais je ne comprends vraiment pas pourquoi et comment le résoudre.

La (partie essentielle de la) classe Matrix est définie ci-dessous: Matrix.h

#ifndef MATRIX_H
#define MATRIX_H


class Matrix{
public:
    Matrix(int nbRows=0, int nbColumns=0); 
    Matrix(const Matrix& a); 
    ~Matrix(); 

    //Access to elements
    double& operator()(int i, int j);  

    int get_nbRows(void) const;
    int get_nbColumns(void) const;

    //Useful functions
    void print_matrix(void);

protected:
    int n; //Number of rows
    int p; //Number of columns
    double **pt; //Pointer to elements

};

#endif // MATRIX_H

et leur mise en œuvre: Matrix.cpp

#include "matrix.h"
#include "MatrixOperations.h"
#include <iostream>
#include <cstdlib>
#include <math.h>
#include <cmath>
using namespace std;

Matrix::Matrix(int nbRows, int nbColumns){
    n = nbRows;
    p = nbColumns;
    pt = new double*[n];
    for(int i=0; i<n; i++){
        pt[i] = new double[p];}
    //Initialize the array to 0
    for(int i=0; i<n; i++){
        for(int j=0; j<p; j++){
            pt[i][j] = 0;
        }
    }
}

Matrix::Matrix(const Matrix& a){
    n = a.n;
    p = a.p;
    pt = new double*[n];
    for(int i=0; i<n; i++){
        pt[i] = new double[p];
        for(int j=0; j<p; j++){
            pt[i][j] = a.pt[i][j];
        }
    }

}

Matrix::~Matrix(){
    cout << "destructor called\n";
    delete[] pt;}

int Matrix::get_nbRows(void) const {return n;}
int Matrix::get_nbColumns(void) const {return p;}


double &Matrix::operator()(int i, int j){
    if ((i < 0)||(i>=n)||(j < 0)||(j>=p))
    {
        cout << "Index out of bounds! \n";
        exit(EXIT_FAILURE);
    }
    return pt[i][j];
}

//Print a matrix on the console
void Matrix::print_matrix(void){
    cout << "[";
    for(int i=0; i<n; i++){
            cout << "[";
        for(int j=0; j<p; j++){
            cout << (*this)(i,j);
            if(j<p-1){cout  << ",";}
        }
        cout << "]";
        if(i<n-1){cout << ",\n";}
        else{}
    }
    cout << "]\n";
    cout << endl;
}

Merci!

MM

NormalSampler_multi(Matrix m, Matrix VarCovar) {- les paramètres met VarCovarseront détruits lorsque le constructeur se terminera.

Vos problèmes peuvent être dus au Matrixnon-respect de la règle 3/5/0 . L'opérateur d'affectation généré par défaut, mu = m; var = VarCovar;appelé par, effectue une affectation par membre et cela perturbe vos invariants de classe. Vous vous retrouvez avec mu.pt == m.pt, et quand mest détruit, mu.ptest un pointeur suspendu.

Une solution simple à cela consiste à remplacer ptpar vector<vector<double>>et votre classe correspondra à la règle de zéro. Vous pouvez également implémenter un opérateur d'affectation correct.

(Note de bas de page - il pourrait y avoir d'autres problèmes, ce n'était que l'un qui se démarquait).

Articles connexes