Bon tu peux déjà t'inspirer de cet ancien post pour découvrir un peu le c++. La classe codée prend en template le type de donnée stockée donc tu peux mettre du bool si tu le souhaites.
http://www.commentcamarche.net/forum/affich-1907231-produit-­matriciel-en-C
Si tu ne comprends pas certains passages n'hésite pas à demander (le c++ c'est important ^^).

Tu peux conserver toute l'implémentation de la classe (actuellement les operations matricielles usuelles). Le problème c'est que je ne peux pas t'en dire plus sinon je fais l'exo à ta place et ce n'est pas le but de la manip, car tu es là pour apprendre, mais à ce stade il ne reste quasi rien à faire ;)

Si toutefois tu bloques encore, n'hésite pas à repasser.

Bonne chance

J'ai compris pas de pb ;-) C'est vrai que ce que j'ai mis sur le post en lien est un peu hardcore pour quelqu'un qui débute, mais idéalement c'est comme ça que dans le futur tu devras programmer (enfin un style voisin je ne prétends pas avoir la science infuse ^^)

En fait soit tu reprends le code de la classe matrice que je t'ai filé et tu fais des :

matrix<bool> A;

class matrix{
    protected:
        std::vector<std::vector<bool> > data;
    public:

        /**
         * \brief Constructeur par defaut
         */
        matrix(){}

        /**
         * \brief Alloue en memoire une matrice
         * \param nb_lig Nombre de ligne
         * \param nb_col Nombre de colonne
         */
        matrix(std::size_t nb_lig,std::size_t nb_col){
            for(std::size_t lig=0;lig<nb_lig;++lig){
                std::vector<bool> tmp;
                tmp.reserve(nb_col);
                for(std::size_t col=0;col<nb_col;++col){
                    tmp.push_back(0);//valeur par defaut
                }
                data.push_back(tmp);
            }
        }
...
        /**
         * \brief Accesseur vers un element de la matrice
         * \param lig son numero de ligne
         * \param col son numero de colonne
         * \return la valeur stockee
         */
        inline bool get(std::size_t lig,std::size_t col) const{
            assert(lig<size1());
            assert(col<size2());
            return data[lig][col];
        }
...
};

/**
 * \brief Operateur << pour les matrices
 * \param o Le flux de sortie
 * \param m la matrice a ecrire
 */
std::ostream& operator << (std::ostream& o,const matrix & m){
    for(std::size_t lig=0;lig<m.size1();++lig){
        for(std::size_t col=0;col<m.size2();++col){
            o<<m.get(lig,col)<<" ";
        }
        o<<std::endl;
    }
    return o;
}
...

void incrementer1(int *p){ ++(*p);}
void incrementer2(int &p){ ++p;}
void incrementer3(int p){ ++p;}

int main(){
  int p=0;
  incrementer1(&p); //p==1
  incrementer2(p); //p==2
  incrementer3(p); //p==2 !!!
  return 0;
}

incrementer(int const & i){++i;} //ne compile pas car i est modifié

const matrix<int> m; //m ne doit pas varier on ne peut appeler que des methodes const dessus
m.size2() ; //ok 
m.set(0,0,1); //pas ok

En fait , ce qui ce passe c'est que nous on utilise principalement des boucles , (for ou while..) et mon problème est que je n'arrive pas à associer tout cela avec ce qu'on a vu .
Tu ma bcp aidé jusqa present et je sais que j'en fait un peu trop la mais je ne sais pas quoi faire :( désolé .

Il n'y a pas de problème si ça me gonflait de t'aider je ne le ferais pas.

Je ne sais pas quel est ton code actuellement, mais supposons que tu aies simplifié ce que j'ai fait :

1- tu as une structure de matrice de boolean

2- tu as les operateurs de multiplication

Il faut que tu fasses

1- une fonction pour construire la matrice In (patrice identité d'ordre n)

2- un operateur pour faire la disjonction v (c'est en fait l'operateur ||. Il suffit de chager les + dans le corps de l'operateur + par un || (et encore avec un + ca doit marcher))

3- un operateur de conjonction ^ (qui est en fait le * en changeant les * par des && (mais avec * ca doit quand même marcher))

4- un operateur d'égalité (qui compare chacun des termes des deux matrices à comparer)

Ensuite on a tout les outils pour chercher la fameuse fermeture transitive. Tant que (oh une boucle :p) la conjonction varie incrementer k et continuer la conjonction. Transforme ca en code est c'est gagné. Je peux pas faire plus come je te l'ai dit sinon je fais l'exo à ta place et tu n'en tireras rien.

Bonne chance

SAlut c'est encore moi.J'ai finalement réussi a faire qqchose de bon (enfin je crois).Grace a tes conseils et avec l'aide d'internet ( surtout grace a un lien sur c++ que j'ai pu trouver sur le forum).
Voila ce que j'obtiens:
#include <iostream>

using namespace std;

//////////////////////////////////////////////////////////////////////////

const int Dim(50);

//////////////////////////////////////////////////////////////////////////

void Affichage(bool Mat[Dim][Dim], int n)
{
for(int i(0); i < n; ++i)
{
for(int j(0); j < n; ++j)
cout << Mat[i][j] << " ";
cout << endl;
}
}

//////////////////////////////////////////////////////////////////////////
void FermTransi(bool A[Dim][Dim], bool Identite[Dim][Dim], int n)
{

bool Interm[Dim][Dim];
// Addition de la matrice A avec l'identité.
for(int i(0); i < n; ++i)
for(int j(0); j < n; ++j)
Interm[i][j] = A[i][j]+Identite[i][j];

// Stockage de la matrice obtenue ci-dessus dans une nouvelle matrice.
bool C[Dim][Dim];
for(int i(0); i < n; ++i)
for(int j(0); j < n; ++j)
C[i][j] = Interm[i][j];

// Multiplication de la matrice C par elle même jusqu'à ce que ses éléments
// ne changent plus.
bool FermTran[Dim][Dim];
int nb_ele(n*n), cpt;
while(cpt < nb_ele)
{
cpt = 0;
for(int i(0); i < n; ++i)
for(int j(0); j < n; ++j)
{
for(int l(0); l < n; ++l)
C[i][j] += Interm[i][l]*C[l][j];
if(C[i][j] != FermTran[i][j])
FermTran[i][j] = C[i][j];
else
++cpt;
}
cout << cpt << endl;
}

cout << "La fermeture transitive de A est: " << endl;
Affichage(FermTran, n);
}

//////////////////////////////////////////////////////////////////////////

int main()
{
bool A[Dim][Dim] = {{0,0,1},{1,0,0},{1,0,0}};
bool Identite[Dim][Dim] = {{1,0,0},{0,1,0},{0,0,1}};
cout << "Entrez la taille des deux matrices de depart: " << endl;
int n(0);
cin >> n;
FermTransi(A, Identite, n);
}

Voila et encore merci.
Mais j'aurais encore une derniere fois besoin de votre aide ;)
Je voulais inclure tout ca ds un main.J'ai essayé de le faire moi meme, mais ya tjrs un truc qui cloche et j'arrive pas a le faire.
Cette exercice ma cree bcp de peine surtout que je dois le rendre ce vendredi.

Euh tutoies moi s'il te plaît ^^ Bon là tu as programmé plus en c qu'en c++, puisque tu n'as pas trop utilisé les méthodes et les operators, mais sinon le code m'a l'air juste.

Je voulais inclure tout ca ds un main.J'ai essayé de le faire moi meme, mais ya tjrs un truc qui cloche et j'arrive pas a le faire.

NON :). Au contraire. Idéalement c'est plein de petites fonctions éventuellement réutilisable par la suite, come par exemple une fonction pour calculer la somme de deux matrices.

Si tu veux aller plus loin essaye découper ton programme comme dans le lien que je t'ai filé. Encore mieux, définis une classe matrice et des opérateurs d'addition et tu auras un code plus "c++" que c.

Mais rassure-toi, je critique mais c'est bien ce que tu as fait (comme quoi les efforts, ça paye ^^) Encore bravo

Tiens ca me sert a moi aussi ca merci bcp. ;)