Angenommen, ich habe folgenden Code-Ausschnitt:

world::world()
{
    grid_row row_one;
    row_one.push_back(new creature("max"));
    row_one.push_back(new creature("moritz"));
    row_one.push_back(new creature("tim"));

    grid_row row_two;
    row_two.push_back(new creature("sarah"));
    row_two.push_back(new creature("bla"));
    row_two.push_back(new creature("blabla"));

    grid_row row_three;
    row_three.push_back(new creature("1"));
    row_three.push_back(new creature("2"));
    row_three.push_back(new creature("3"));

    _creatures.push_back(row_one);
    _creatures.push_back(row_two);
    _creatures.push_back(row_three);

    /* Wie kann ich die Nachbarn herausfinden? (damit jede creature ihren Nachbarn kennt? */
	}

Ich nehme ja nicht an, dass man für jede creature den Namen des Nachbarn "von Hand" eigeben muss, oder?
(Kann man das nicht per get_name() machen?)

Besten Dank im Voraus für die Vorschläge.

Du kannst ja via Indizes zugreifen. Bei [2][2] sind die Nachbarn eben [1][2], [3][2], [2][1], [2][3]. Und? Die eingefügten Objekte selbst kennen ihre Nachbarn nicht, die müssen bei ner oberen Instanz nachfragen oder müssten die Info über nen Parameter bei der jeweiligen Funktion wissen.

Jedem Viech alle Nachbarn zuzuweisen ist schlecht, da du für jede Änderung alles aktualisieren musst.

Also etwa so:
max sarah 1
moritz bla 2
tim blabla 3

Beispiel:

test::~test()
{
   	grid; // Wird der Inhalt von grid so gelöscht?
}

Wo hast du denn so nen Käse her?

Was Du mit new angelegt hast, musst Du auch selbst deleten. Also kannst Du schön durch die in den inneren vector eingefügten Objekte durchiterieren und alle einzeln löschen.

Die vectoren selbst, die auf dem Stack liegen, werden automatisch gelöscht, wenn der dtor durchlaufen worden ist.

grid::iterator row = _creatures.begin();

Nur: Löscht das nun schon alle meine creatures?

Was zu löschen ist, ist das, was mit new erstellt wurde. Um etwas mit new erstelltes zu löschen, muss das durch delete geschehen. Um alle mit new erstellten Objekte zu erfassen, musst Du durchiterieren.

for(iterator1 it = _creatures.begin(); it != _creatures.end(); ++it)
    for(iterator2 it2 = it->begin(); it2 != it->end(); ++it2)
        delete *it2;

Überdenke aber, ob Du wirklich mit new erstellte Objekte hineinschmeißen möchtest. Wieso willst Du das? Und Du kannst auch boost::ptr_vector nutzen, welches das delete automatisch übernimmt.

#include <cstdlib>
#include <iostream>
#include "world.hpp"

world::world()
{
    grid_row row_one;
    row_one.push_back(new creature("moritz"));
    row_one.push_back(new creature("max"));
    row_one.push_back(new creature("tim"));

    //blabla..

    _creatures.push_back(row_one);

    //blabla..

  	_creatures[0][0]->add_neighbor(_creatures[0][1]);
	//blabla..

}

world::~world()
{
    /* Hier sollten alle Ressourcen freigegeben werden. Wir haben den Tipp:            
For example, we have a std::vector that holds another std::vector holding pointers of type creature.
           We use a typedef to rename the type:

               typedef std::vector<std::vector<creature*> > grid;

           Whenever we use this type, we can now write 'grid' instead. This also works if we use iterators:

               grid::iterator row = _creatures.begin();

 */

}

void world::proceed_time()
{
    for(grid::iterator row = _creatures.begin(); row != _creatures.end(); ++row)
    {
        for(grid_row::iterator creature_iter = row->begin(); creature_iter != row->end(); ++creature_iter)
        {
            creature* a_creature = *creature_iter;
            int new_activity = rand() % 4;

            switch(new_activity)
            {
            case 0:
                a_creature->sleep();
                break;
            case 1:
                a_creature->eat();
                break;
            case 2:
                if( a_creature->get_neighbors().size() > 0 )
                {
                    std::vector<creature*> neighbors = a_creature->get_neighbors();

                    int playmate_index = rand() % neighbors.size();
                    creature* playmate = neighbors.at(playmate_index);

                    a_creature->play_with( playmate );
                    playmate->play_with( a_creature );

                    break;
                }
            case 3:
                a_creature->clean();
                break;
            }
        }
    }
}

void world::print() const
{
    const int GRID_WIDTH = 26;

    for(grid::const_iterator row = _creatures.begin(); row != _creatures.end(); ++row)
    {
        for(grid_row::const_iterator creature_iter = row->begin(); creature_iter != row->end(); ++creature_iter)
        {
            creature* a_creature = *creature_iter;
            creature* b_creature = *++creature_iter;
            creature* c_creature = *++creature_iter;

            //blabla..
}

Okey. Hier vielleicht trotzdem alles.
Etwas funktioniert nicht so, wie gewünscht.
Namentlich stimmt was mit den Pointern beim deleten nicht...

Du hast es nicht implementiert, könnte das die Unstimmigkeit sein?