calculatrice matricielle avec boost::shared_array

//fichier Matrix.h
#ifndef MATRIX_H
#define MATRIX_H
class Matrix{
         

          public  :
                    // Matrix(){}
                     Matrix(const int d);
                    ~Matrix(){};
                     float operator ()(int i,int j){return this->myshared_matrix[i*dim+j];}
                     void initialisation(); 
                     Matrix operator +(Matrix M1);
                     Matrix operator -(Matrix M1);
                     Matrix operator *(Matrix M1);
                     Matrix operator /(Matrix M1);
         friend ostream& operator <<(ostream& os,Matrix M);   
         private :
                     int dim,DIM;
                     boost::shared_array<float> myshared_matrix;         
                       
};
Matrix::Matrix(const int d){
          dim=d,DIM=d*d;           
          boost::shared_array<float> myshared_matrix(new float[DIM] );                  
          }
//Matrix::~Matrix(){delete [] myshared_matrix ; }
void Matrix::initialisation(){
               for(int i=0;i<dim;++i)
               for(int j=0;j<dim;++j)myshared_matrix[i*dim+j]=i*dim+j;}
                          
Matrix Matrix::operator +(Matrix M1){
               Matrix somm(dim);
               for(int i=0;i<DIM;++i)
               somm.myshared_matrix[i]=myshared_matrix[i]+M1.myshared_matrix[i];
               return somm;}
Matrix Matrix::operator -(Matrix M1){
               Matrix somm(dim);
               for(int i=0;i<DIM;++i)
               somm.myshared_matrix[i]=myshared_matrix[i]-M1.myshared_matrix[i];
               return somm;}
Matrix Matrix::operator *(Matrix M1){
               Matrix somm(dim);
               for(int i=0;i<DIM;++i)
               somm.myshared_matrix[i]=myshared_matrix[i]*M1.myshared_matrix[i];
               return somm;} 
Matrix Matrix::operator /(Matrix M1){
               Matrix somm(dim);
               for(int i=0;i<DIM;++i){
               if(M1.myshared_matrix[i]==0) M1.myshared_matrix[i]=1;
               somm.myshared_matrix[i]=myshared_matrix[i]/M1.myshared_matrix[i];}
               return somm;}               
               
ostream& operator <<(ostream& os,Matrix M){
         for(int i=0;i<M.dim;++i,os<<'\n')  
         for(int j=0;j<M.dim;++j) os<<M(i,j)<<'\t';
         return os;}             
 
#endif 
//fichier main.cpp
#include <cstdlib>
#include <iostream>
#include <boost/shared_array.hpp>
using namespace std;

#include "Matrix.h"
int main(int argc, char *argv[])
{
    Matrix M(2);
    M.initialisation();
    cout<<M<<endl; 
    system("PAUSE");
    return EXIT_SUCCESS;
}

         
    //boost::shared_array<float> myshared_matrix(new float[DIM]);                  
    myshared_matrix = boost::shared_array<float>(new float[DIM]);