Segmentation fault (core dumped) [c++]

[84f45e194ee50365c2aa8ead271e4a9d9bb017bb]

Salve il mio programma quando entra in un ciclo for mi fa segmentation fault e non capisco cosa sbaglio...
Nel senso capisco perché arriva il segmentation fault, perché cerca degli indici che in realtà non esistono, infatti (credo) che quando entra nella funzione afficher e faccio

 size_t i (contenu.size());

la taglia di contenu è "vuota", quindi probabilmente sbaglio qualcosa nel costruttore oppure dopo negli operatori di overloading, ma non trovo l'errore. Qualcuno potrebbe aiutarmi? Grazie anticipatamente.

#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(Forme f="", Couleur c="")
: forme(f), couleur(c)
{}

ostream& afficher(ostream& sortie) const{
	if( couleur!=""){
	sortie << "(" << forme << ", " << couleur << ")" << endl;
    }else{
		sortie << forme << endl;}
    return sortie;
}
};

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



class Construction
{
  friend class Grader;
  
  private:
  vector<vector<vector<Brique>>> contenu;
  
  public:
  Construction(Brique b)
  {
     vector<vector<vector<Brique>>> contenu(1,vector<vector<Brique>>(1,vector<Brique>(0)));
     contenu[0][0].push_back(b);
	  
 }
 

  
  ostream& afficher(ostream& sortie) const{
	  size_t i (contenu.size());
	  for(size_t j(i); j >= 0; j--){
		  sortie << "Couche numéro : " << j << endl;
		  for(size_t k(0); k < contenu[j].size(); k++){
			  for(size_t l(0); l < contenu[j][k].size(); l++){
				   contenu[j][k][l].afficher(sortie);
	  } cout << endl; } }
	  return sortie;
  }
  
  vector<vector<vector<Brique>>> getcontenu()const{
	  return contenu;
  }
	  
  
 void operator^=(Construction const& A){
	 for(size_t i(0); i < A.getcontenu().size(); i++){
	 contenu.push_back(A.getcontenu()[i]);
    }
 }
 
 void operator-=(Construction const& A){
	 if( contenu.size() <= A.getcontenu().size() ){
	 for(size_t i(0); i < contenu.size(); i++){
		 
		 for(size_t j(0); j < A.getcontenu()[i].size(); j++){
	 contenu[i].push_back(A.getcontenu()[i][j]);
    } }
 }
}
 
void operator+=(Construction const& A){
	 if( contenu.size() <= A.getcontenu().size() ){
	 for(size_t i(0); i < contenu.size(); i++){
		 if(contenu[i].size() <= A.getcontenu()[i].size()){
		 for(size_t j(0); j < contenu[i].size(); j++){
			 for(size_t k(0); k < A.getcontenu()[i][j].size(); k++){
	 contenu[i][j].push_back(A.getcontenu()[i][j][k]);
    } } } }
 }
}
 
	  
};



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

const Construction operator^(Construction const& A, Construction const& B){
	for(size_t i(0); i < B.getcontenu().size(); i++){
	 A.getcontenu().push_back(A.getcontenu()[i]);
    }
    return A;
}

const Construction operator-(Construction const& A, Construction const& B){
	 if( A.getcontenu().size() <= B.getcontenu().size() ){
	 for(size_t i(0); i < A.getcontenu().size(); i++){
		 
		 for(size_t j(0); j < B.getcontenu()[i].size(); j++){
	 A.getcontenu()[i].push_back(A.getcontenu()[i][j]);
    } }
 }
 return A;
}

const Construction operator+(Construction const& A, Construction const& B){
	 if( A.getcontenu().size() <= B.getcontenu().size() ){
	 for(size_t i(0); i < A.getcontenu().size(); i++){
		 if(A.getcontenu()[i].size() <= B.getcontenu()[i].size()){
		 for(size_t j(0); j < A.getcontenu()[i].size(); j++){
			 for(size_t k(0); k < B.getcontenu()[i][j].size(); k++){
	 A.getcontenu()[i][j].push_back(B.getcontenu()[i][j][k]);
    } } } }
 }
 return A;
}

const Construction operator*(unsigned int n, Construction const& a)
{
	for(unsigned int i(1); i<=n; i++){
		a+a ;
		}
		return a;
}

const Construction operator/(unsigned int n, Construction const& a)
{
	for(unsigned int i(1); i<=n; i++){
		a^a ;
		}
		return a;
}

const Construction operator%(unsigned int n, Construction const& a)
{
	for(unsigned int i(1); i<=n; i++){
		a-a ;
		}
		return a;
}

/*******************************************
 * 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
  Construction maison( hauteur / ( profondeur % (largeur * mur) ) );

  // on construit le toit
  Construction toit(profondeur % ( toitG + 2*toitM + toitD ));
  toit ^= profondeur % (vide + toitG + toitD); 

  // on pose le toit sur les murs
  maison ^= toit;

  // on admire notre construction
  cout << maison << endl;

  return 0;
}

Quando eseguo il programma sul terminale esce
Couche numéro : 0
Segmentation fault (core dumped)

Mentre dovrebbe uscire:
Couche 4 :
(obliqueG, rouge) (obliqueD, rouge)
(obliqueG, rouge) (obliqueD, rouge)
(obliqueG, rouge) (obliqueD, rouge)
Couche 3 :
(obliqueG, rouge) ( pleine , rouge) ( pleine , rouge) (obliqueD, rouge)
(obliqueG, rouge) ( pleine , rouge) ( pleine , rouge) (obliqueD, rouge)
(obliqueG, rouge) ( pleine , rouge) ( pleine , rouge) (obliqueD, rouge)
Couche 2 :
( pleine , blanc) ( pleine , blanc) ( pleine , blanc) ( pleine , blanc)
( pleine , blanc) ( pleine , blanc) ( pleine , blanc) ( pleine , blanc)
( pleine , blanc) ( pleine , blanc)( pleine , blanc) ( pleine , blanc)
Couche 1 :
( pleine , blanc) ( pleine , blanc) ( pleine , blanc) ( pleine , blanc)
( pleine , blanc) ( pleine , blanc) ( pleine , blanc) ( pleine , blanc)
( pleine , blanc) ( pleine , blanc) ( pleine , blanc) ( pleine , blanc)
Couche 0 :
( pleine , blanc) ( pleine , blanc) ( pleine , blanc) ( pleine , blanc)
( pleine , blanc) ( pleine , blanc) ( pleine , blanc) ( pleine , blanc)
( pleine , blanc) ( pleine , blanc) ( pleine , blanc) ( pleine , blanc)

[84f45e194ee50365c2aa8ead271e4a9d9bb017bb]

Credo sia proprio un problema tra il costruttore e la funzione afficher, perché modificandoli in questo modo e lasciando invariate le altri parti (qui le modifiche)
Modifica costruttore e afficher

 Construction(Brique b)
  {
     vector<vector<vector<Brique>>> contenu(1,vector<vector<Brique>>(1,vector<Brique>(0)));
     contenu[0][0].push_back(b);
	  size_t i(contenu.size());
	    size_t j(contenu[0].size());
	      size_t k(contenu[0][0].size());
	  cout << i << " " << j << " " << k << endl;
	  cout << b << endl;
	  cout << "ok " << contenu[0][0][0] << endl;
 }
 
  ostream& afficher(ostream& sortie) const{
	  size_t i (contenu.size());
	  cout << i << endl;
	  if( i > 0){
	  for(size_t j(i); j >= 0; j--){
		  sortie << "Couche numéro : " << j << endl;
		  for(size_t k(0); k <= contenu[j].size(); k++){
			  for(size_t l(0); l <= contenu[j][k].size(); l++){
				   contenu[j][k][l].afficher(sortie);
	  } cout << endl; } } }else{
		  sortie << "errore altrove?" << endl;}
	  return sortie;
  } 

E modificando la main in questo modo

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

Construction maison(toitD);
cout << maison.getcontenu().size() << endl;
maison.afficher(cout);

  return 0;
}

Ottengo nel terminale:

1 1 1
(obliqueD, rouge)

ok (obliqueD, rouge)

0
0
errore altrove?