Wie schon der Titel sagt. Ich bekomme keine Fehlermeldung, aber das Programm stürzt ab. Das Kompilieren klappt aber anstandslos.

#include <iostream>
#include <cstdlib>
#include <forward_list>
#include <exception>
#include <stdexcept>
using namespace std;

class Edge
{
   public:
      Edge(int);
      int getI();
   private:
      int i;
};
Edge::Edge(int _i)
{
    i = _i;
}
int Edge::getI()
{
    return i;
}
void terminateHandler()
{
    std::cerr << "Exception" << std::endl;
    abort();
}
int main(int argc, char *argv[])
{
   try
   {
   	set_terminate(terminateHandler);

      Edge edge0(0);
      Edge edge1(1);

      std::forward_list<Edge> edges;
      edges.insert_after(edges.end(), edge0);
      edges.insert_after(edges.end(), edge1);

      for
      (
         auto edgePtr = std::begin(edges);
         edgePtr != std::end(edges);
         ++edgePtr
      )
      {
         std::cout << ' ' << (*edgePtr).getI();
      }
   }
   catch(const std::exception& e)
   {
   	std::cerr << e.what();
   }

   return EXIT_SUCCESS;
}

Was mache ich denn falsch?

das wird nicht hinhauen.
EDIT: weil damit würde hinter hinter dem Ende eingefügt. Da ist aber schon lange keine Liste mehr

Davon abgesehen rate ich davon ab bei einer forward_list ans ende einzufügen.
Ansonsten verweise ich einfach mal zu Stackoverflow:
http://stackoverflow.com/questions/8742462/stdforward-list-and-stdforward-listpush-back?answertab=active#tab-top

EDIT2: muss es wirklich eine forward_list sein?

Gibts vielleicht eine andere Liste, wo man ganz einfach am Ende anhängen kann?

EDIT: Für Arrays konstanter größen, natürlich std::array

EDIT: findet sich bestimmt auch auf Channel 9

Im Vergleich zu vector und deque werden neuen Elemente im Inneren wesentlich schneller eingefügt, weil nur Adressen veränder werden müssen.

Also demnach wären lists nicht grundsätzlich schlecht.

Im Vergleich zu vector und deque werden neuen Elemente im Inneren wesentlich schneller eingefügt, weil nur Adressen veränder werden müssen.

Also demnach wären lists nicht grundsätzlich schlecht.

Nö, sind sie auch nicht.
Sie sind ideal wenn du häufig in der Mitte einfügen musst [Edit:] oder iterator stability wichtig ist.
Dieser Fall kommt aber idR selten vor [Edit:] bzw. der Nachteil des langsam Random Access (der kein richtiger Random Access ist) überwiegt.