Problème de débogage avec Visual Studio

bonjour,

"il semble se bloquer", as-tu vérifié qu'il ne bouclait pas?

as-tu ajouté des instructions qui affichaient la progression dans ton code?

Bonjour

commence par essayer d'exécuter en mode debug, s'il y a un plantage VS t'affichera la ligne concernée.

Par contre, s'il y a une boucle infinie, comme le suggère yg_be. Il faut mettre des points d'arrêt un peu partout et voir si ça passe au suivant. Et quand tu trouves le point d'arrêt qui n'est pas atteint, tu relances jusqu'au précédent et tu exécutes en pas à pas. Ça aussi, il faut le faire en debug.

Bonjour, 

Je suis en première année, je vous remercie de vos conseils mais je comprends pas trop... 

Je vous met le code associés ici : 

CMatrice.h : 

#pragma once
#include<iostream>   
#include<cstdlib>   
#include<fstream> 
using namespace std;

class CMatrice
{

private:

    double** m_pMatrice;
    int m_nNL;
    int m_nNC;

public:

    CMatrice();
    CMatrice(int, int);
    CMatrice(int, int, double**);
    CMatrice(const CMatrice&);
    ~CMatrice();

    CMatrice operator = (const CMatrice&);

    friend ostream& operator << (ostream&, const CMatrice&);
    friend istream& operator >> (istream&, CMatrice&);

    void Writetxt(const char[]);
    void Readtxt(const char[]);

    CMatrice FillRand();

    double Determinant2x2();
    double Puissance(double, int)const;
    //int Cofacteur(int, int);
    double Determinant();

    CMatrice Transposée()const;
    CMatrice inverse(CMatrice&);
    CMatrice Comatrice();
    CMatrice Mineur(int, int);

    CMatrice operator += (const CMatrice&);
    CMatrice operator += (double);
    CMatrice operator + (const CMatrice&)const;
    CMatrice operator + (double)const;

    CMatrice operator -= (const CMatrice&);
    CMatrice operator -= (double);
    CMatrice operator - (const CMatrice&)const;
    CMatrice operator - (double)const;

    CMatrice operator *= (const CMatrice&);
    CMatrice operator *= (double);
    CMatrice operator * (const CMatrice&);
    CMatrice operator * (double)const;

};
CMatrice.cpp : 

#include<iostream>
#include"CMatrice.h"
#include<fstream>
using namespace std;

CMatrice::CMatrice()
    :m_nNC(0), m_nNL(0), m_pMatrice(NULL)
{

}

CMatrice::CMatrice(int nNL, int nNC)
    :m_nNC(nNC), m_nNL(nNL), m_pMatrice(NULL)
{
    if ((m_nNC > 0) && (m_nNL > 0))
    {
        m_pMatrice = new double* [m_nNL];

        for (int i = 0; i < m_nNL; ++i)
        {
            m_pMatrice[i] = new double[m_nNC];

            for (int j = 0; j < m_nNC; ++j)
            {
                m_pMatrice[i][j] = 0.0;
            }
        }
    }
}

CMatrice::CMatrice(int nNL, int nNC, double** dMatrice)
    :m_nNC(nNC), m_nNL(nNL), m_pMatrice(NULL)
{
    if ((nNC > 0) && (nNL > 0))
    {
        m_pMatrice = new double* [m_nNL];
        if (m_pMatrice == NULL) // Vérifiez si l'allocation de mémoire a réussi
        {
            cout << "Erreur d'allocation de mémoire." << endl;
            return;
        }

        if (dMatrice != NULL)
        {
            for (int i = 0; i < m_nNL; ++i)
            {
                m_pMatrice[i] = new double[m_nNC];
                if (m_pMatrice[i] == NULL) // Vérifiez si l'allocation de mémoire a réussi
                {
                    cout << "Erreur d'allocation de mémoire." << endl;
                    for (int j = 0; j < i; ++j) // Libérez la mémoire déjà allouée
                    {
                        delete[] m_pMatrice[j];
                    }
                    delete[] m_pMatrice;
                    m_pMatrice = NULL;
                    return;
                }

                for (int j = 0; j < m_nNC; ++j)
                {
                    m_pMatrice[i][j] = dMatrice[i][j];
                }
            }
        }
    }
}

CMatrice::CMatrice(const CMatrice& M)
    :m_nNC(M.m_nNC), m_nNL(M.m_nNL), m_pMatrice(NULL)
{
    if ((m_nNC > 0) && (m_nNL > 0))
    {
        m_pMatrice = new double* [m_nNL];

        if (m_pMatrice != NULL)
        {
            for (int i = 0; i < m_nNL; ++i)
            {
                m_pMatrice[i] = new double[m_nNC];

                if (m_pMatrice[i] != NULL)
                {
                    for (int j = 0; j < m_nNC; ++j)
                    {
                        m_pMatrice[i][j] = M.m_pMatrice[i][j];
                    }
                }
                else
                {
                    // Gestion de l'erreur d'allocation de mémoire
                    for (int k = 0; k < i; ++k)
                    {
                        delete[] m_pMatrice[k];
                    }
                    delete[] m_pMatrice;
                    m_pMatrice = NULL;
                    break;
                }
            }
        }
    }
}

CMatrice::~CMatrice()
{
    if (m_pMatrice != NULL)
    {
        for (int i = 0; i < m_nNL; ++i) // Utilisez m_nNL au lieu de m_nNC
        {
            if (m_pMatrice[i] != NULL)
            {
                delete[] m_pMatrice[i];
            }
        }

        delete[] m_pMatrice;
    }
}

CMatrice CMatrice::operator = (const CMatrice& M)
{
    if (this != &M)
    {
        if (m_pMatrice != NULL)
        {
            for (int i = 0; i < m_nNL; ++i)
            {
                if (m_pMatrice[i] != NULL)
                {
                    delete[] m_pMatrice[i];
                }
            }

            delete[] m_pMatrice;
        }

        m_nNC = M.m_nNC;
        m_nNL = M.m_nNL;

        if ((m_nNC > 0) && (m_nNL > 0))
        {
            m_pMatrice = new double* [m_nNL];

            if (m_pMatrice != NULL)
            {
                for (int i = 0; i < m_nNL; ++i)
                {
                    m_pMatrice[i] = new double[m_nNC];

                    if (m_pMatrice[i] != NULL)
                    {
                        for (int j = 0; j < m_nNC; ++j)
                        {
                            m_pMatrice[i][j] = M.m_pMatrice[i][j];
                        }
                    }
                    else
                    {
                        // Gestion de l'erreur d'allocation de mémoire
                        for (int k = 0; k < i; ++k)
                        {
                            delete[] m_pMatrice[k];
                        }
                        delete[] m_pMatrice;
                        m_pMatrice = NULL;
                        break;
                    }
                }
            }
        }
    }

    return *this;
}

ostream& operator << (ostream& os, const CMatrice& M)
{
    os << "Affichage des données: " << endl;

    if (M.m_pMatrice != NULL)
    {
        for (int i = 0; i < M.m_nNL; ++i)
        {
            for (int j = 0; j < M.m_nNC; ++j)
            {
                os.width(11);
                os.fill(' ');
                os.setf(ios::left, ios::adjustfield);
                os << M.m_pMatrice[i][j];
            }

            os << endl;
        }
    }

    return os;
}

istream& operator >> (istream& is, CMatrice& M)
{
    cout << "Entrez le nombre de lignes de la matrice : ";
    is >> M.m_nNL;

    cout << "Entrez le nombre de colonnes de la matrice : ";
    is >> M.m_nNC;

    if (M.m_pMatrice != NULL)
    {
        for (int i = 0; i < M.m_nNL; ++i)
        {
            if (M.m_pMatrice[i] != NULL)
            {
                delete[] M.m_pMatrice[i];
            }
        }
        delete[] M.m_pMatrice;
    }

    if ((M.m_nNC > 0) && (M.m_nNL > 0))
    {
        M.m_pMatrice = new double* [M.m_nNL];

        if (M.m_pMatrice != NULL)
        {
            for (int i = 0; i < M.m_nNL; ++i)
            {
                M.m_pMatrice[i] = new double[M.m_nNC];

                if (M.m_pMatrice[i] != NULL)
                {
                    for (int j = 0; j < M.m_nNC; ++j)
                    {
                        is >> M.m_pMatrice[i][j];
                    }
                }
            }
        }
    }

    return is;
}

void CMatrice::Writetxt(const char pNom[])
{
    ofstream f(pNom, ios::out);
    if (!f)
    {
        cout << "Erreur lors de l'ouverture du fichier pour l'écriture." << endl;
        return;
    }

    if (m_pMatrice != NULL)
    {
        for (int i = 0; i < m_nNL; ++i)
        {
            for (int j = 0; j < m_nNC; ++j)
            {
                f << m_pMatrice[i][j] << " ";
            }
            f << endl;
        }
    }
    f.close();

    cout << "Le fichier a correctement été sauvegardé" << endl;
}

void CMatrice::Readtxt(const char pNom[])
{
    ifstream f(pNom, ios::in);
    if (!f)
    {
        cout << "Erreur lors de l'ouverture du fichier pour la lecture." << endl;
        return;
    }

    if (m_pMatrice != NULL)
    {
        for (int i = 0; i < m_nNL; ++i)
        {
            for (int j = 0; j < m_nNC; ++j)
            {
                f >> m_pMatrice[i][j];
            }
        }
    }
    f.close();
}


CMatrice CMatrice::FillRand()
{
    srand((unsigned)time(NULL));

    cout << "Saisissez le nombre de lignes de la matrice : " << endl;
    cin >> m_nNL;

    cout << "Saisissez le nombre de colonnes de la matrice : " << endl;
    cin >> m_nNC;

    if ((m_nNL > 0) && (m_nNC > 0))
    {
        m_pMatrice = new double* [m_nNL];

        if (m_pMatrice != NULL)
        {
            for (int i = 0; i < m_nNL; ++i)
            {
                m_pMatrice[i] = new double[m_nNC];
            }
            for (int i = 0; i < m_nNL; ++i)
            {
                for (int j = 0; j < m_nNC; ++j)
                {
                    m_pMatrice[i][j] = ((double)rand() / RAND_MAX) * 100;
                }
            }
        }
    }

    return *this;
}

double CMatrice::Determinant2x2()
{
    if ((m_nNC == 2) && (m_nNL == 2))
    {
        return m_pMatrice[0][0] * m_pMatrice[1][1] - m_pMatrice[1][0] * m_pMatrice[0][1];
    }
    else
    {
        cout << "On arrête le programme, cette matrice ne correspond pas à une matrice 2X2" << endl;
        cout << "Changez l'opération à effectuer et prenez l'opération <Déterminant d'une matrice d'ordre n>" << endl;
        return 0; // ou une autre valeur qui indique une erreur
    }
}

double CMatrice::Puissance(double dVal, int nExposant)const
{
    if (nExposant == 0)
    {
        return 1.0;
    }
    else if (nExposant == 1)
    {
        return dVal;
    }
    else
    {
        double dRes = dVal;

        for (int i = 1; i < nExposant; ++i)
        {
            dRes *= dVal;
        }

        return dRes;
    }
}

double CMatrice::Determinant()
{
    if ((m_nNC == m_nNL))
    {
        if (m_nNC == 1)
        {
            return m_pMatrice[0][0];
        }
        else if (m_nNC == 2)
        {
            return Determinant2x2();
        }
        else
        {
            double dDéterminant = 0.0;

            for (int i = 0; i < m_nNC; ++i)
            {
                double dCofacteur = m_pMatrice[0][i];
                double dSigne = Puissance(-1, i); // Utilisez la fonction Puissance ici

                CMatrice Mineur(m_nNL - 1, m_nNC - 1);

                for (int j = 1; j < m_nNL; ++j)
                {
                    int nCofacteur = 0;
                    for (int k = 0; k < m_nNC; ++k)
                    {
                        if (k == i)
                        {
                            continue;
                        }
                        else
                        {
                            Mineur.m_pMatrice[j - 1][nCofacteur] = m_pMatrice[j][k];
                            nCofacteur++;
                        }
                    }
                }

                double dDet = Mineur.Determinant();
                dDéterminant += dCofacteur * dSigne * dDet;
            }


            return dDéterminant;
        }
    }
    else
    {
        cout << "La matrice choisie n'est pas carrée donc elle ne possède aucun déterminant !" << endl;
    }

    return 0;
}


CMatrice CMatrice::Transposée() const
{
    CMatrice Transposée(m_nNC, m_nNL); // Notez le changement ici

    if (m_pMatrice != NULL)
    {
        for (int i = 0; i < m_nNL; ++i)
        {
            for (int j = 0; j < m_nNC; ++j)
            {
                Transposée.m_pMatrice[j][i] = m_pMatrice[i][j]; // Et ici
            }
        }
    }

    return Transposée;
}


CMatrice CMatrice::inverse(CMatrice& M)
{
    // Vérifiez d'abord si la matrice est carrée
    if (M.m_nNC != M.m_nNL)
    {
        cout << "La matrice n'est pas carrée. Ainsi, il est impossible de calculer sa matrice inverse." << endl;
        return *this;
    }

    // Ensuite, calculez le déterminant
    double dDét = M.Determinant();

    // Vérifiez si le déterminant est nul
    if (dDét == 0)
    {
        cout << "Le déterminant de la matrice est nul. Ainsi, il est impossible de calculer sa matrice inverse." << endl;
        return *this;
    }

    CMatrice Résultat(M.m_nNL, M.m_nNC, 0);
    CMatrice comatrice(M.m_nNL, M.m_nNC, 0);
    CMatrice transposée(M.m_nNL, M.m_nNC, 0);

    if (M.m_pMatrice != NULL) // Ajoutez cette vérification
    {
        comatrice = M.Comatrice();
        transposée = comatrice.Transposée();
        dDét = 1 / dDét;

        for (int i = 0; i < M.m_nNL; ++i)
        {
            for (int j = 0; j < M.m_nNC; ++j)
            {
                Résultat.m_pMatrice[i][j] = transposée.m_pMatrice[i][j] * dDét;
            }
        }
    }

    return Résultat;
}


CMatrice CMatrice::Comatrice()
{
    // Assurez-vous que la matrice est carrée
    if (m_nNL != m_nNC)
    {
        cout << "Erreur ! La matrice n'est pas carrée." << endl;
        return *this;
    }

    CMatrice comatrice(m_nNL, m_nNC);

    for (int i = 0; i < m_nNL; ++i)
    {
        for (int j = 0; j < m_nNC; ++j)
        {
            // Calculer le cofacteur avec le signe approprié
            comatrice.m_pMatrice[i][j] = Puissance(-1, i + j) * Mineur(i, j).Determinant();
        }
    }

    return comatrice;
}

CMatrice CMatrice::Mineur(int nNL, int nNC)
{
    if ((nNL < 0) || (nNL >= m_nNL) || (nNC < 0) || (nNC >= m_nNC)) // Notez le changement ici
    {
        cout << "Erreur ! Vous êtes en dehors des limites de la matrice." << endl;
        return *this;
    }

    CMatrice mineur(m_nNL - 1, m_nNC - 1); // Notez le changement ici

    if (mineur.m_pMatrice == NULL) // Ajoutez cette vérification
    {
        cout << "Erreur ! L'allocation de mémoire a échoué." << endl;
        return *this;
    }

    int nS = 0;

    for (int i = 0; i < m_nNL; ++i)
    {
        if (i != nNL)
        {
            int nK = 0; // Déplacez cette ligne ici

            for (int j = 0; j < m_nNC; ++j)
            {
                if (j != nNC)
                {
                    if (nS < m_nNL - 1 && nK < m_nNC - 1) // Ajoutez cette vérification
                    {
                        mineur.m_pMatrice[nS][nK] = m_pMatrice[i][j];
                        nK++; // Ajoutez cette ligne
                    }
                }
            }

            nS++;
        }
    }

    return mineur;
}

CMatrice CMatrice::operator += (const CMatrice& M)
{
    if ((m_nNL == M.m_nNL) && (m_nNC == M.m_nNC))
    {
        for (int i = 0; i < m_nNL; ++i)
        {
            for (int j = 0; j < m_nNC; ++j)
            {
                m_pMatrice[i][j] += M.m_pMatrice[i][j];
            }
        }
    }
    else
    {
        // Gestion d'erreur
        cout << "Les dimensions des matrices ne correspondent pas." << endl;
    }

    return *this;
}

CMatrice CMatrice::operator += (double dValeur)
{
    if ((m_nNL > 0) && (m_nNC > 0))
    {
        for (int i = 0; i < m_nNL; ++i)
        {
            for (int j = 0; j < m_nNC; ++j)
            {
                m_pMatrice[i][j] += dValeur;
            }
        }
    }
    else
    {
        // Gestion d'erreur
        cout << "Les dimensions de la matrice sont nulles." << endl;
    }

    return *this;
}

CMatrice CMatrice::operator + (const CMatrice& M) const
{
    return CMatrice(*this) += M;
}

CMatrice CMatrice::operator + (double dVal) const
{
    CMatrice temp(*this);
    for (int i = 0; i < temp.m_nNL; ++i)
    {
        for (int j = 0; j < temp.m_nNC; ++j)
        {
            temp.m_pMatrice[i][j] += dVal;
        }
    }
    return temp;
}

CMatrice CMatrice::operator -= (const CMatrice& M)
{
    if ((m_nNL == M.m_nNL) && (m_nNC == M.m_nNC))
    {
        for (int i = 0; i < m_nNL; ++i)
        {
            for (int j = 0; j < m_nNC; ++j)
            {
                m_pMatrice[i][j] -= M.m_pMatrice[i][j];
            }
        }
    }
    else
    {
        // Gestion d'erreur
        cout << "Les dimensions des matrices ne correspondent pas." << endl;
    }

    return *this;
}

CMatrice CMatrice::operator -= (double dValeur)
{
    if ((m_nNL > 0) && (m_nNC > 0))
    {
        for (int i = 0; i < m_nNL; ++i)
        {
            for (int j = 0; j < m_nNC; ++j)
            {
                m_pMatrice[i][j] -= dValeur;
            }
        }
    }
    else
    {
        // Gestion d'erreur
        cout << "Les dimensions de la matrice sont nulles." << endl;
    }

    return *this;
}

CMatrice CMatrice::operator - (const CMatrice& M) const
{
    return CMatrice(*this) -= M;
}

CMatrice CMatrice::operator - (double dVal) const
{
    CMatrice temp(*this);
    for (int i = 0; i < temp.m_nNL; ++i)
    {
        for (int j = 0; j < temp.m_nNC; ++j)
        {
            temp.m_pMatrice[i][j] -= dVal;
        }
    }
    return temp;
}

CMatrice CMatrice::operator *= (const CMatrice& M)
{
    if (m_nNL != M.m_nNC)
    {
        cout << "Les matrices ne peuvent pas être multipliés. Arrêt du programme" << endl;
    }

    CMatrice res(m_nNL, M.m_nNC);

    for (int i = 0; i < m_nNL; ++i)
    {
        for (int j = 0; j < M.m_nNC; ++j)
        {
            res.m_pMatrice[i][j] = 0;

            for (int k = 0; k < m_nNC; ++k)
            {
                res.m_pMatrice[i][j] += m_pMatrice[i][k] * M.m_pMatrice[k][j];
            }
        }
    }

    (*this) = res;

    return *this;

}

CMatrice CMatrice::operator *= (double dVal)
{
    for (int i = 0; i < m_nNL; ++i)
    {
        for (int j = 0; j < m_nNC; ++j)
        {
            m_pMatrice[i][j] *= dVal;
        }
    }

    return *this;
}

CMatrice CMatrice::operator*(const CMatrice& M)
{
    if (m_nNC != M.m_nNL)
    {
        cout << "Dimensions incompatible pour la multiplications de matrices" << endl;
    }

    CMatrice resultat(m_nNL, M.m_nNC);

    for (int i = 0; i < m_nNL; ++i)
    {
        for (int j = 0; j < M.m_nNC; ++j)
        {
            for (int k = 0; k < m_nNC; ++k)
            {
                resultat.m_pMatrice[i][j] += m_pMatrice[i][k] * M.m_pMatrice[k][j];
            }
        }
    }

    return resultat;
}

CMatrice CMatrice:: operator * (double dVal) const
{
    CMatrice temp(*this);
    for (int i = 0; i < temp.m_nNL; ++i)
    {
        for (int j = 0; j < temp.m_nNC; ++j)
        {
            temp.m_pMatrice[i][j] *= dVal;
        }
    }
    return temp;
}

Source.cpp : 

#include<iostream>
#include<stdlib.h>
#include"CMatrice.h"
using namespace std;

int main(void)
{
    setlocale(LC_CTYPE, "fra");
    cout << "===Le calcul matriciel===" << endl;

    CMatrice m1;
    CMatrice m2;
    CMatrice m3;
    CMatrice m4;

    int nScalaire = 0;
    int nCalcul = 0;

    const char cNomduFichier[] = "Matrice.txt";


    cout << "Choisissez l'une des propositions suivantes : " << endl;
    cout << "1 : Additionner deux matrices. " << endl;
    cout << "2 : Additionner un scalaire et une matrice." << endl;
    cout << "3 : Soustraire deux matrices." << endl;
    cout << "4 : Soustraire un scalaire et une matrice." << endl;
    cout << "5 : Multiplier deux matrices." << endl;
    cout << "6 : Multiplier une matrice et un scalaire." << endl;
    cout << "7 : Calculer le déterminant d'une matrice carrée." << endl;
    cout << "8 : Calculer le déterminant d'une matrice d'ordre n." << endl;
    cout << "9 : Calculer la transposée d'une matrice." << endl;
    cout << "10 : Calculer la comatrice d'une matrice." << endl;
    cout << "11 : Calculer la matrice inverse." << endl;
    cout << "12 : Tester l'écriture dans un fichier." << endl;
    cout << "13 : Tester la lecture dans un fichier." << endl;

    cout << "Que voulez-vous faire comme calcul matriciel ?" << endl;
    cin >> nCalcul;

    switch (nCalcul)
    {
    case 1: cout << "Démarrage de l'opération + entre deux matrices." << endl;
        cout << "Attention ! Les dimensions des 2 matrices doivent être identiques, sinon l'opération + retournera la matrice 1 sans effectuer le calcul ! " << endl;
        cout << "Saisissez le nombre de lignes et de colonnes de la Matrice n°1 : " << endl;
        m1.FillRand();
        cout << m1 << endl;
        cout << "Saisissez le nombre de lignes et de colonnes de la Matrice n°2 : " << endl;
        m3.FillRand();
        cout << m3 << endl;
        cout << "Le résultat du calcul m1 + m2 = " << endl;
        m4 = m1 + m3;
        cout << m4 << endl;
        break;

    case 2: cout << "Démarrage de l'opération + entre un scalaire et une matrice." << endl;
        cout << "Saisissez le nombre de lignes et de colonnes de la Matrice : " << endl;
        m1.FillRand();
        cout << m1 << endl;
        cout << "Saisissez le scalaire : " << endl;
        cin >> nScalaire;
        cout << nScalaire << endl;
        cout << "Le résultat du calcul m1 + " << nScalaire << " = " << endl;
        m4 = m1 + nScalaire;
        cout << m4 << endl;
        break;

    case 3: cout << "Démarrage de l'opération - entre deux matrices." << endl;
        cout << "Attention ! Les dimensions des 2 matrices doivent être identiques, sinon l'opération - retournera la matrice 1 sans effectuer le calcul ! " << endl;
        cout << "Saisissez le nombre de lignes et de colonnes de la Matrice n°1 : " << endl;
        m1.FillRand();
        cout << m1 << endl;
        cout << "Saisissez le nombre de lignes et de colonnes de la Matrice n°2 : " << endl;
        m3.FillRand();
        cout << m3 << endl;
        cout << "Le résultat du calcul m1 - m2 = " << endl;
        m4 = m1 - m3;
        cout << m4 << endl;
        break;

    case 4: cout << "Démarrage de l'opération - entre un scalaire et une matrice." << endl;
        cout << "Saisissez le nombre de lignes et de colonnes de la Matrice : " << endl;
        m1.FillRand();
        cout << m1 << endl;
        cout << "Saisissez le scalaire : " << endl;
        cin >> nScalaire;
        cout << nScalaire << endl;
        cout << "Le résultat du calcul m1 - " << nScalaire << " = " << endl;
        m4 = m1 - nScalaire;
        cout << m4 << endl;
        break;

    case 5: cout << "Démarrage de l'opération * entre deux matrices." << endl;
        cout << "Attention ! Le nombre de colonne de la première matrice et le nombre de lignes de la deuxième matrice doivent être identiques ! " << endl;
        cout << "Saisissez le nombre de lignes et de colonnes de la Matrice n°1 : " << endl;
        m1.FillRand();
        cout << m1 << endl;
        cout << "Saisissez le nombre de lignes et de colonnes de la Matrice n°2 : " << endl;
        m3.FillRand();
        cout << m3 << endl;
        cout << "Le résultat du calcul m1 * m2 = " << endl;
        m4 = m1 * m3;
        cout << m4 << endl;
        break;

    case 6: cout << "Démarrage de l'opération * entre un scalaire et une matrice." << endl;
        cout << "Saisissez le nombre de lignes et de colonnes de la Matrice : " << endl;
        m1.FillRand();
        cout << m1 << endl;
        cout << "Saisissez le scalaire : " << endl;
        cin >> nScalaire;
        cout << nScalaire << endl;
        cout << "Le résultat du calcul m1 * " << nScalaire << " = " << endl;
        m4 = m1 * nScalaire;
        cout << m4 << endl;
        break;

    case 7: cout << "Démarrage du calcul du déterminant d'une matrice carrée" << endl;
        cout << "Attention le nombre de ligne et de colonnes doivent être de 2 ! Exemple : une matrice 2x2. " << endl;
        cout << "Saisissez le nombre de lignes et de colonnes de votre Matrice : " << endl;
        m1.FillRand();
        cout << m1 << endl;
        cout << "Le résultat du déterminant de cette matrice carrée est : " << endl;
        cout << m1.Determinant2x2() << endl;
        break;

    case 8: cout << "Démarrage du calcul du déterminant d'une matrice d'ordre n" << endl;
        cout << "Attention la matrice doit être carrée donc le nombre de ligne et de colonnes doivent être identiques ! Exemple : une matrice 5x5. " << endl;
        cout << "Saisissez le nombre de lignes et de colonnes de votre Matrice : " << endl;
        m1.FillRand();
        cout << m1 << endl;
        cout << "Le résultat du déterminant de cette matrice d'ordre n est : " << endl;
        cout << m1.Determinant() << endl;
        break;

    case 9: cout << "Démarrage du calcul de la transposée d'une matrice" << endl;
        cout << "Saisissez le nombre de lignes et de colonnes de votre Matrice : " << endl;
        m1.FillRand();
        cout << m1 << endl;
        cout << "Le résultat de la transposée de cette matrice est : " << endl;
        m4 = m1.Transposée();
        cout << m4 << endl;
        break;

    case 10: cout << "Démarrage du calcul de la comatrice d'une matrice" << endl;
        cout << "Saisissez le nombre de lignes et de colonnes de votre Matrice : " << endl;
        m1.FillRand();
        cout << m1 << endl;
        cout << "Le résultat de la comatrice de cette matrice est : " << endl;
        m4 = m1.Comatrice();
        cout << m4 << endl;
        break;

    case 11: cout << "Démarrage du calcul de la matrice inverse" << endl;
        cout << "Saisissez le nombre de lignes et de colonnes de votre Matrice : " << endl;
        m1.FillRand();
        cout << m1 << endl;
        cout << "Le résultat de cette matrice inverse est : " << endl;
        m4 = m1.inverse(m1);
        cout << m4 << endl;
        break;

    case 12: cout << "Démarrage du test de l'écriture dans un fichier" << endl;
        m1.Writetxt(cNomduFichier);
        break;

    case 13: cout << "Démarrage du test de la lecture dans un fichier" << endl;
        m1.Readtxt(cNomduFichier);
        cout << m1;
        break;

    default: cout << "Erreur, veuillez ressaisir le calcul matriciel que vous voulez effectuer." << endl; break;

    }

    return 0;

}

Merci beaucoup de votre aide ! 

Bonjour 

tout d'abord, merci à @madmyke StatutModérateur d'avoir rendu ton code lisible.

Pour tes prochains posts, merci de faire comme décrit là https://codes-sources.commentcamarche.net/faq/11288-poster-un-extrait-de-code

Pour ton problème, apprendre à débogguer est aussi important qu'apprendre à coder. Avec VS, on débbogue en mode debug ( comme son nom l'indique ).

Mettre des cout partout est une façon de faire, et quand tu codes dans un "simple" éditeur de texte, c'est la seule.

Mais VS te propose d'autres outils (comme beaucoup d'IDE d'ailleurs) qu'il est bon de savoir utiliser https://learn.microsoft.com/fr-fr/visualstudio/debugger/debugger-feature-tour?view=vs-2019

Bonjour

Quelques suggestions complémentaires :

• évite les accents pour nommer tes symboles (variables, fonctions, classes, etc.), je te recommande d'ailleurs de tout nommer en anglais pour prendre de bonnes habitudes pour l'avenir
• à défaut d'utiliser un débogueur, tu peux afficher à différentes étapes de ton programme ou tu en es et petit à petit resserrer où le programme est bloqué.
• mais normalement, ton débogueur permet d'interrompre un programme (bouton stop, ctrl c selon ce que tu utilises) et de voir la pile d'exécution.

Exemple :

1) Soit le fichier main.c suivant :

#include <unistd.h>

int main() {
    while (1) {
        sleep(3);
    }
    return 0;
}

2) On compile de sorte à pouvoir déboguer. Par exemple, sous Linux, si on compile avec gcc, on lancerait :

gcc -g main.c   # Compile l'exécutable a.out

Dans un IDE, cela revient à compiler en mode "Debug".

3) On lance le débogueur, par exemple gdb : 

gdb ./a.out

Dans un IDE, cela revient à lancer le débogueur

4) Dans le débogueur on lance le programme (r), puis on l'interrompt (ctrl c) et on affiche la trace d'appel (bt) :

(mando@cenedra) (~) $ gdb ./a.out 
GNU gdb (Debian 13.1-3) 13.1
Copyright (C) 2023 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.
Type "show copying" and "show warranty" for details.
This GDB was configured as "x86_64-linux-gnu".
Type "show configuration" for configuration details.
For bug reporting instructions, please see:
<https://www.gnu.org/software/gdb/bugs/>.
Find the GDB manual and other documentation resources online at:
    <http://www.gnu.org/software/gdb/documentation/>.

For help, type "help".
Type "apropos word" to search for commands related to "word"...
Reading symbols from ./a.out...
(gdb) r
Starting program: /home/mando/a.out 
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
^C
Program received signal SIGINT, Interrupt.
0x00007ffff7e96443 in clock_nanosleep () from /lib/x86_64-linux-gnu/libc.so.6
(gdb) bt
#0  0x00007ffff7e96443 in clock_nanosleep () from /lib/x86_64-linux-gnu/libc.so.6
#1  0x00007ffff7e9ad93 in nanosleep () from /lib/x86_64-linux-gnu/libc.so.6
#2  0x00007ffff7e9acca in sleep () from /lib/x86_64-linux-gnu/libc.so.6
#3  0x0000555555555147 in main () at main.c:5

Dans un cet exemple, on voit que le programme était rendu ligne 5 dans main.c, sur la fonction sleep.

Dans un IDE, cela revient à lancer l'exécution dans le débogueur (souvent le bouton "Lecture") puis à interrompre l'exécution (bouton "Stop") et regarder où est positionné le curseur.

Bonne chance