[C++]surch << et map<pair<int,int>,

Bonjour,

Sinon, il y a un problème : dans ton affichage tu ne regardes jamais ton attribut tableau de ta classe Tableau.
Je ne suis pas convaincu qu'il faille faire un attribut tableau dans ta classe.
Au lieu de faire tableau.balblablabl fais plutôt (*this).blablabla et tu n'auras pas besoin d'attribut.

Le tableau sera l'element instancié, du style
Tableau t;

Pas évident le TP6 :p

Hey! Non, pas facile le TP6!

Je vais essayé ce que tu dis. Mais honnêtement, je vois pas en quoi, c'est un pb pour l'affichage. L'attribut tableau comme tu dis, je m'en sert dans la surcharge de l'operateur(). Pour l'affichage, les deux iterateurs debut et end devrait suffire...

Sinon, la question 7 tu t'en sors?
Je ne suis pas allé en cours, et je comprend rien aux iterator_traits!!

Voici comment tu peux faire

#include <map>
#include <iostream>
#include <ostream>

std::ostream & operator<<(
    std::ostream & out,
    const std::map<std::pair<int,int> ,double> & x
){
    std::map<std::pair<int,int> ,double>::const_iterator
        xit (x.begin()),
        xend(x.end());
    for(;xit!=xend;++xit){
        const std::pair<int,int> & key = xit->first;
        const double & data = xit->second;
        out << '(' << key.first << ',' << key.second << ")\t"
            << data << std::endl;
    }
    return out;
}

int main (){
    std::pair<int,int>
        p12 = std::make_pair(1,2),
        p23 = std::make_pair(2,3),
        p13 = std::make_pair(1,3);
    std::map<std::pair<int,int> ,double> x;
    x[p12] = 5.456;
    x[p13] = 1.426;
    x[p23] = 4.759;
    std::cout << x << std::endl;
    return 0;
}

ce qui donne :

(mando@aldur) (~) $ g++ -W -Wall plop.cpp
(mando@aldur) (~) $ ./a.out
(1,2)   5.456
(1,3)   1.426
(2,3)   4.759

On peut même être encore plus générique :

#include <map>
#include <iostream>
#include <ostream>

template <typename T1,typename T2>
std::ostream & operator<<(
    std::ostream & out,
    const std::pair<T1,T2> & x
){
    out << '(' << x.first << ',' << x.second << ')';
    return out;
}

template <typename T1,typename T2>
std::ostream & operator<<(
    std::ostream & out,
    const std::map<T1,T2> & x
){
    typename std::map<T1,T2>::const_iterator
        xit (x.begin()),xend(x.end());
    for(;xit!=xend;++xit){
        out << xit->first << '\t' << xit->second << std::endl;
    }
    return out;
}

int main (){
    std::pair<int,int>
        p12 = std::make_pair(1,2),
        p23 = std::make_pair(2,3),
        p13 = std::make_pair(1,3);
    std::map<std::pair<int,int> ,double> x;
    x[p12] = 5.456;
    x[p13] = 1.426;
    x[p23] = 4.759;
    std::cout << x << std::endl;
    return 0;
}

Ainsi tu peux imbriquer des map et des paires comme tu le souhaites, il sera toujours possible de définir un opérateur <<.

Bonne chance

Probleme résolu! En fait mon problème venait d'ailleurs. Comme quoi la programmation ça peut vous bouffer les neurones!

Un grand merci pour ton aide mamiemando!
J'ai adapté ton code au mien pour l'esayer, et en effet, ça fonctionne nickel!
Cependant, j'ai relu le "cahier des charges", et j'étais assez loin de ce qu'il me demandait. Du coup, j'ai remodelé tout ça à ma sauce!

Un grand merci à vous deux!

Félicitations, bonne continuation :-)

;-)