Solidifier le recours aux tableaux bruts

#ifndef FORME_H
#define FORME_H
//
// Forme.h
//
#include <iosfwd>
class Forme {
public:
   using value_type = char;
private:
   value_type symbole_ { '*' };
public:
   Forme() = default;
   Forme(value_type symbole) : symbole_{symbole} {
   }
   value_type symbole() const {
      return symbole_;
   }
   virtual void dessiner(std::ostream &os) const = 0;
   virtual ~Forme() = default;
};
void afficher_formes(Forme *tab, std::size_t n);
#endif

#include "Forme.h"
#include <iostream>
using namespace std;
ostream& operator<<(ostream &os, const Forme &f) {
   return f.dessiner(os), os;
}
void vilain(Forme *tab, size_t n) {
   for (Forme *p = tab; p != tab + n; ++p)
      cout << *p << endl;
}

//
// Rectangle.h
//
#ifndef RECTANGLE_H
#define RECTANGLE_H
#include "Forme.h"
template <class T>
   constexpr bool est_entre_inclusif(T candidat, T minVal, T maxVal) {
      return minVal <= candidat && candidat <= maxVal;
   }
class DimensionIncorrecte {};
#include <ostream>
class Rectangle : public Forme {
public:
   using size_type = int;
private:
   static constexpr const size_type MIN_LARGEUR = 1, MAX_LARGEUR = 80;
   static constexpr const size_type MIN_HAUTEUR = 1, MAX_HAUTEUR = 25;
   size_type largeur_,
             hauteur_;
   static constexpr size_type valider_largeur(size_type largeur) {
      return est_entre_inclusif(largeur, MIN_LARGEUR, MAX_LARGEUR)? largeur : throw DimensionIncorrecte{};
   }
   static constexpr size_type valider_hauteur(size_type hauteur) {
      return est_entre_inclusif(hauteur, MIN_HAUTEUR, MAX_HAUTEUR)? hauteur : throw DimensionIncorrecte{};
   }
public:
   Rectangle(size_type largeur, size_type hauteur)
      : largeur_{ valider_largeur(largeur) },
        hauteur_{ valider_hauteur(hauteur) }
   {
   }
   Rectangle(size_type largeur, size_type hauteur, value_type symbole)
      : Forme{ symbole },
        largeur_{ valider_largeur(largeur) },
        hauteur_{ valider_hauteur(hauteur) }
   {
   }
   size_type largeur() const {
      return largeur_;
   }
   size_type hauteur() const {
      return hauteur_;
   }
   void dessiner(std::ostream &os) const {
      using std::endl;
      for (size_type hau = 0; hau < hauteur(); ++hau) {
         for (size_type lar = 0; lar < largeur(); ++lar)
            os << symbole();
         os << endl;
      }
   }
};
#endif

//
// Principal.cpp
//
#include "Rectangle.h"
#include "Forme.h"
int main() {
   Rectangle tab[] {
      Rectangle{1, 3}, Rectangle{4, 2}, Rectangle{3, 3}
   };
   enum { N = sizeof(tab) / sizeof(tab[0]) };
   vilain(tab, N); // BOUM!
}

#include <iostream>
using namespace std;
void vilain(Forme *tab, size_t n) {
   for (Forme *p = tab; p != tab + n; ++p)
      cout << *p << endl;
}

#include <cassert>
#include <iterator>
#include <type_traits>
template <class T>
   class array_ref {
   public:
      using size_type = std::size_t;
      using value_type = T;

   private:
      value_type *ptr;
      size_type nelems;
   public:
      array_ref(value_type *ptr, size_type nelems) : ptr{ptr}, nelems{nelems} {
         assert(ptr && nelems);
      }
      template <class It>
         array_ref(It debut, It fin)
            : ptr(&(*debut)), nelems(std::distance(debut, fin))
         {
            using std::is_convertible;
            static_assert(
               is_convertible<
                  typename std::iterator_traits<It>::iterator_category,
                  std::random_access_iterator_tag
               >::value,
               "array_ref requiert des random_access_iterators"
            );
         }

// ...
      size_type size() const noexcept {
         return nelems;
      }
      value_type& operator[](size_type n) {
         assert(n < size());
         return ptr[n];
      }
      value_type operator[](size_type n) const {
         assert(n < size());
         return ptr[n];
      }
      using iterator = value_type*;
      using const_iterator = const value_type*;
      iterator begin() noexcept {
         return ptr;
      }
      const_iterator begin() const noexcept {
         return ptr;
      }
      iterator end() noexcept {
         return begin() + size();
      }
      const_iterator end() const noexcept {
         return begin() + size();
      }
   };

template <class T>
   array_ref<T> make_array_ref(T *ptr, size_t n) {
      return { ptr, n };
   }
template <class It>
   array_ref<typename std::iterator_traits<It>::value_type>
      make_array_ref(It debut, It fin)
   {
      return { debut, fin };
   }

template <class T>
   void gentil(array_ref<T> tab) {
      using namespace std;
      for (auto p = begin(tab); p != end(tab); ++p)
         cout << *p << endl;
   }

#include <algorithm>
int main() {
   using namespace std;
   Rectangle tab[] {
      Rectangle{1, 3}, Rectangle{4, 2}, Rectangle{3, 3}
   };
   enum { N = sizeof(tab) / sizeof(tab[0]) };
   // vilain (tab, N);
   gentil(make_array_ref(tab, N));
   gentil(make_array_ref(begin(tab), end(tab)));
}

// dans Forme.h
#include <span>
#include <ostream>
// ...
template <class T>
   void dessiner_formes(span<T> tab, std::ostream <os) {
      for(auto < forme : tab)
         os << forme << std::endl;
   }
// ...
// programme principal
#include <span>
#include <iostream>
int main() {
   Rectangle tab[] {
      {1, 3}, {4, 2}, {3, 3}
   };
   afficher_formes(span{ tab, tab + 3 }, cout);
}

// dans Forme.h
#include <span>
#include <ostream>
// ...
template <class T>
   void dessiner_formes(span<T> tab, std::ostream <os) {
      for(auto < forme : tab)
         os << forme << std::endl;
   }
// ...
// programme principal
#include <span>
#include <iterator>
#include <iostream>
int main() {
   Rectangle tab[] {
      {1, 3}, {4, 2}, {3, 3}
   };
   afficher_formes(span{ begin(tab), end(tab) }, cout);
}

// dans Forme.h
#include <span>
#include <ostream>
// ...
template <class T>
   void dessiner_formes(span<T> tab, std::ostream <os) {
      for(auto < forme : tab)
         os << forme << std::endl;
   }
template <class T, std::size_t N>
   void dessiner_formes(span<T, N> tab, std::ostream <os) {
      for(auto < forme : tab)
         os << forme << std::endl;
   }
// ...
// programme principal
#include <span>
#include <iterator>
#include <iostream>
int main() {
   Rectangle tab[] {
      {1, 3}, {4, 2}, {3, 3}
   };
   afficher_formes(span{ tab }, cout);
}