problème avec l'affichage d'une classe matrice

J'ai recontrer un problème complètement fou à mes yeux en voulant creer un classe matrice, qui effectue des calcul de base sur les matrice.
voilà le code complet :

//---------------------------------------------------------------------------------
//    matrice.h
//---------------------------------------------------------------------------------

class matrice{

    int *tab;      // pointeur sur le tableau représentant la matrice
    int L;         // dimensions effective de la matrice
    int C;
    char *NOM;
    
public:
    
    // definition d'une matrice "vide": L=C=0
    matrice(char *nom);

    ~matrice();
        
    void init(int lignes, int colonnes);

    friend ostream& operator<<(ostream& o, matrice M);
};

//---------------------------------------------------------------------------------
//    matrice.cpp
//---------------------------------------------------------------------------------

#include <iostream>
using namespace std;

#include "matrice.h"

matrice::matrice(char *nom)
{   
    L=0;
    C=0;
    tab=((int *)0);
    NOM=nom;
}

matrice::~matrice()
{
    if(tab!=((int *)0)) delete[] tab;
}

void matrice::init(int lignes, int colonnes)
{
    int i=0;
    if(lignes<=0 || colonnes<=0){       
        L=0; C=0;              // matrice "vide"
    }
    else if(tab!=((int *)0)){        // première initialisation

        C=colonnes;
        L=lignes;
        tab = new int[L*C];
        }
        else{                    // réinitialisation ultérieur avc d'autre dimensions

            delete[] tab;
            L=lignes;
            C=colonnes;
            tab= new int [L*C];

        }

        for(i=0; i<L*C; i++) tab[i]=1;   // on créé une matrice avc que d 1
}

ostream& operator<<(ostream& o, matrice M)
{
    int i,j;
    o<<endl<<M.NOM<<"=";
    for(i=1; i<=M.L; i++){
        o<<"\t";
        for(j=1; j<=M.C; j++)
            o<<M.tab[(i-1)*M.C+j-1]<<"\t";
        o<<endl;
    }

    o<<endl;
    
    return o;
}

//---------------------------------------------------------------------------------
//    main.cpp
//---------------------------------------------------------------------------------


#include <cstdlib>
#include <iostream>

using namespace std;

#include "matrice.h"

int main()
{
    int lignes,colonnes;
    matrice M = matrice("M");
    M.init(3,3);
    
    cout<<M;

    cout<<M;

    cout<<M;

    M.~matrice();

    system("PAUSE");
    return EXIT_SUCCESS;
}

//---------------------------------------------------------------------------------
//    Après avoir compilé, j'obtient ça comme résultat :
//---------------------------------------------------------------------------------


M=      1       1       1     // première affichage ok !
        1       1       1
        1       1       1


M=      0       1       1       // pourquoi la première valeur est modifiée ???
        1       1       1
        1       1       1


M=      4013776 1       1   // est là encore une fois ?
        1       1       1
        1       1       1

Merci d'avance pour votre aide.

Tu organises tes boucles d'affichage en commençant à 1, alors qu'il faut commencer à 0.
De plus tu gagnerais en visibilité en créant une vrai matrice.

Exemple :

class Matrice
{
    int** m_t;
    int   m_nbrLignes;
    int   m_nbrColonnes;
public:
    Matrice(int=3, int=3);
    Matrice(const Matrice&);
    ~Matrice();
    friend Matrice operator * (int, const Matrice&);
    Matrice operator + (const Matrice&) const;
    const Matrice& oprator = (const Matrice&);
    friend istream& operator >> (istream&, Matrice&);
    friend ostream& operator << (ostream&, const Matrice&);
};

// Attrention au constructeur de copie !
Matrice::Matrice(const Matrice& matCopie)
{
    m_nbrLignes = matCopie.m_nbrLignes;
    m_nbrColonnes = matCopie.m_nbrColonnes;
    m_t = new int*[m_nbrLignes];
 
    for(int i=0; i<m_nbrLignes; i++)
    {
        m_t[i] = new int[m_nbrColonnes];
           for(int j=0; j<m_nbrColonnes; j++)
               m_t[i][j] = matCopie.m_t[i][j];
    }
}

// ect...

En fait le bug vient d'ici :

o << M.tab[(i-1) * M.C + j-1] << "\t";

pour chaque J tu es toujours a 0, donc tu affiches toujours la premiere case.

merci, d'vaoir ajouter quelque infos supplémentaire sur l'amélioration mon code.

Malheureusement je suis un débutant en C++ (j'en fait que depuis 2 mois), et donc je viens à peine de voir la notion de classe, ce qui fait que je ne vois pas très bien le sens de "vraie matrice", mais n'empêche que je vais essayer de comprendre ce que tu me propose.

Pour la critique sur l'affichage en commençant à 1 et non pas à 0, c'est pour que mes matrices puissent être utilisées avec la terminologie mathématique qui nomme le premier élément M[1][1] et non pas M[0][0]. (ce qui facilite le passage des "astuces" en maths aux "astuces" en info).

Si g bien compris l'utilité du for.
   for(j=1; j<=M.C; j++)
      o << M.tab[(i-1) * M.C + j-1] << "\t";
Ce bout de code implique que j varie.