Visiblement, il fonctionne mais il n'affiche pas ce qu'il f

#include <iostream>
#include <string>
#include <vector>
using namespace std;

// Pour simplifier
typedef string Forme   ;
typedef string Couleur ;

class Brique
{
private:
  Forme   forme   ;
  Couleur couleur ;

public:
  /*****************************************************
    Compléter le code à partir d'ici
  *******************************************************/
    Brique(const string & f,const string & c)
    :forme(f),couleur(c)
    {}

    string getCouleur()
    {
        return couleur;
    }

    void afficher(ostream& sortie) const
    {
        if(couleur.size() > 0){
            sortie << "(" << forme << ", " << couleur << ")";
        } else {
            sortie << forme;
        }
    }
};

ostream& operator<<(ostream &cout, Brique const& b)
{
    b.afficher(cout);
    return cout;
}

class Construction
{
  friend class Grader;
public:

    Construction(const Brique& b)
    :contenu({{{b}}})
    {}

    Construction(const Construction& c)
    :contenu(c.contenu)
    {}

    vector<vector<vector<Brique>>> getContenu() const
    {
        return contenu;
    }

    vector<vector<Brique>> getPlateform(size_t i) const
    {
        return contenu[i];
    }

    vector<Brique> getLigne(size_t i, size_t j) const
    {
        return contenu[i][j];
    }

    Brique getBrique(size_t i, size_t j, size_t k) const
    {
        return contenu[i][j][k];
    }

    ostream& afficher(ostream& sortie) const
    {
        for(size_t i(contenu.size()-1); i > 0; i--){
            sortie << "couche " << i << " :\n";
            for(size_t j(contenu[i].size()-1); j > 0; j--){
                for(size_t k(contenu[i][j].size()-1); k > 0; k--){
                    contenu[i][j][k].afficher(sortie);
                }
            }
            sortie << "\n";
        }
        return sortie;
    }

    Construction operator^=(Construction const& c)
    {
        cout << "OPERATOR ^=" << endl;
        size_t taille_before(c.contenu.size());
        for(size_t i(0); i < taille_before; i++){
            contenu.push_back(c.contenu[i]);
        }
        return *this;
    }

    Construction operator-=(Construction const& c)
    {
        cout << "OPERATOR -=" << endl;
        if(c.contenu.size() > contenu.size()){
            for(size_t i(0); i < contenu.size(); i++){
                for(size_t j(0); j < contenu[i].size(); j++){
                    contenu[i].push_back(c.contenu[i][j]);
                }
            }
        }
        return *this;
    }

    Construction operator+=(Construction const& c)
    {
        cout << "OPERATOR +=" << endl;
        if(c.contenu.size() > contenu.size()){
            for(size_t i(0); i < contenu.size(); i++){
                for(size_t j(0); j < contenu[i].size(); j++){
                    for(size_t k(0); k < contenu[i][j].size(); k++){
                        contenu[i][j].push_back(c.contenu[i][j][k]);
                    }
                }
            }
        }
        return *this;
    }
private:
    vector<vector<vector<Brique>>> contenu;
    /*contenu[HAUTEUR(i)][PROFONDEUR(j)][LARGEUR(k)]*/
};

const Construction operator+(Brique const& b, Brique const& c)
{
    cout << "OPERATOR : BRIQUE + BRIQUE" << endl;
    Construction a(b);
    Construction d(c);
    a+=d;
    return a;
}

ostream& operator<<(ostream& cout, Construction const& c)
{
    c.afficher(cout);
    return cout;
}

const Construction operator-(Construction& a, Construction const& c)
{
    cout << "OPERATOR -" << endl;
    Construction b(a);
    return b-=c;
}

const Construction operator+(Construction& a, Construction const& c)
{
    cout << "OPERATOR +" << endl;
    Construction b(a);
    return b+=c;
}

const Construction operator^(Construction& a, Construction const& c)
{
    cout << "OPERATOR ^" << endl;
    Construction b(a);
    return b^=c;
}

const Construction operator+(Brique const& b, Construction const& c)
{
    cout << "BRIQUE + CONSTRUCTION" << endl << endl;
    Construction a(b);
    return a+=b;
}

const Construction operator+(Construction const& c, Brique const& b)
{
    cout << "CONSTRUCTION + BRIQUE" << endl << endl;
    Construction a(b);
    return a+=b;
}

const Construction operator*(unsigned int n, Brique const& b)
{
    cout << "N * BRIQUE" << endl << endl;
    Construction a(b);
    for(unsigned int i(0); i < n; i++){
        a+=a;
    }
    return a;
}

const Construction operator*(unsigned int n, Construction const& a)
{
    cout << "OPERATOR * : " << endl;
    Construction c(a);
    for(unsigned int i(0); i <= n; i++){
        c+=c;
    }
    return c;
}

const Construction operator/(unsigned int n, Construction const& a)
{
    cout << "OPERATOR / : " << endl;
    Construction c(a);
    for(unsigned int i(0); i < n; i++){
        c^=c;
    }
    return c;
}

const Construction operator%(unsigned int n, Construction const& a)
{
    cout << "OPERATOR % : " << endl;
    Construction c(a);
    for(unsigned int i(0); i < n; i++){
        c-=c;
    }
    return c;
}

/*******************************************
 * Ne rien modifier après cette ligne.
 *******************************************/

int main()
{
  // Modèles de briques
  Brique toitD("obliqueD", "rouge");
  Brique toitG("obliqueG", "rouge");
  Brique toitM(" pleine ", "rouge");
  Brique mur  (" pleine ", "blanc");
  Brique vide ("                 ", "");

  unsigned int largeur(4);
  unsigned int profondeur(3);
  unsigned int hauteur(3); // sans le toit

  // on construit les murs
  cout << "---------------------------\n" << "1. Construction de la maison :\n" << endl;
  Construction maison( hauteur / ( profondeur % (largeur * mur) ) );

  // on construit le toit
  cout << "---------------------------\n" << "2. Construction du toit : \n" << endl;
  Construction toit(profondeur % ( toitG + 2*toitM + toitD ));

  cout << "---------------------------\n" << "3. Ajout au dessus du toit : \n" << endl;
  toit ^= profondeur % (vide + toitG + toitD);

  // on pose le toit sur les murs
  cout << "---------------------------\n" << "4. Pose du toit sur les murs : \n" << endl;
  maison ^= toit;

  // on admire notre construction
  cout << "---------------------------\n" << "5. Affichage de la construction : \n" << endl;
  cout << maison << endl;

  return 0;
}