Exercice c++

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;

Soit tu la retailles pour l'adapter spécialement aux booléens : tu vire les template <T>, tu changes tout les T dans le code par des bool et ca deviendra plus clair normalement :

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;
}
...

Si tu utilises using namespace std; en début de fichier tu peux supprimer tous les std:: ce qui allègera le code (personnellement je n'aime pas trop les using namespace donc bon... c'est d'ailleurs à proscrire dans les .h (.hpp) mais bref...)

Une fois que tu auras fait tout ça, vu ton code, il ne restera plus qu'à comprendre :
- la classe STL vector
- les références

Une vector c'est un tableau contigu en mémoire qui se comporte de manière assez semblable à un int tab[255] pour std::vector<int>, sauf que tu n'as plus à te préocupper de la taille grace au pusj_back (qui greffe un élément en fin de tableau). Cf :
http://www.sgi.com/tech/stl/Vector.html

Si les std::size_t te perturbent, tu peux les changer par des unsigned int.

Les références : c'est presque la même chose qu'un pointeur, sauf que ça permet de manipuler syntaxiquement parler le paramètre comme s'il s'agissait de l'objet pointé directement. Exemple :

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;
}

En particulier, quand tu appelles une fonction, ses paramètres sont une copie (c'est pour ça que le incrementer3 ne marche pas. cf cours sur les ponteurs (=adresses) si quelque chose t'échappe, ou ballade toi dans le forum.

Passer un paramètre ni par référence ou par pointeru c'est donc mal, car s'il est gros il est très long à copier, alors qu'une référence est très rapide à copier ^^ Cependant lors d'un passage par référence il faut garantir la constance quand c'est possible (par exemple afficher une matrice ne la modifie pas) et c'est le rôle du const.

Ainsi

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

Pour les méthodes (fonctions internse à une classe comme size1 dans le code que je t'ai filé) tu peux voir unconst qui n'est pas rattaché à un paramètre. Il correspond au const s'appliquant à *this :

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

D'autres questions ? ;-)

Bonne chance

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. ;)