Eine Frage. Wenn ich sowas habe:

building::building(int id_, int floors_, int rooms_per_floor_)
  : _id(id_), _floors(floors_), _rooms_per_floor(rooms_per_floor_)
{
    // Hier sollte der Code eingefügt werden

	std::vector< std::vector<person*> >  _assignments;
}

..und ich den Konstruktor implementieren soll, um den assignment Vektor zu initialisieren - wie könnte das aussehen?
(der Vektor _assignments habe ich schon mal eingefügt. Ich nehme an, der wird gebraucht, oder?)

Was genau hast du eigentlich vor?

Wenn du den im Konstruktor definierst wie in deinem obigen Code, ist alles was du dann damit machst, Zeitverschwendung (am Ende des Konstruktors geht er aus dem Scope und wird wieder gelscht - im schlimmsten Fall hast du noch ein Speicherleck, weil niemand die personen freigibt, die du dort reingepumpt hast). Wenn er außerhalb existiert, sollte er am Anfang des Konstruktors auf jeden Fall schon angelegt sein (wobei du die Möglichkeit hast, ihn schon in der Initialisierungsliste zu füllen). Du kannst dann direkt damit arbeiten, um alle bentigten Werte reinzupumpen.

Deshalb hab ich ihn auch "manuell" eingefügt, weil man ja nicht direkt auf den Vektor zugreifen kann, oder doch?

(achja, push_back() nimmt nur einen Parameter entgegen - wenn du mehrere Elemente haben willst, mußt du jedes einzelne angeben. In C++0x gibt es einige Änderungen/Erweiterungen für die Initialisierung, da könnte der Code etwas kürzer werden)

PS: Was soll diese Konstruktion eigentlich darstellen? Und woher kommen die person-Zeiger auf der innersten Ebene des Vector?

#include "building.hpp"
// STL
#include <iostream>
#include <vector>

building::building(int id_, int floors_, int rooms_per_floor_)
  : _id(id_), _floors(floors_), _rooms_per_floor(rooms_per_floor_)
{
	this->_id = id_;
	this->_floors = floors_;
	this->_rooms_per_floor = rooms_per_floor_;
}

building::~building()
{

    // Code 
}

void
building::assign_room(person* tenant_, int floor_, int room_)
{

         //??
	_assignments.push_back(tenant_);

}

person*
building::free_room(int floor_, int room_)
{

    // Code
}

void
building::print_floor(int floor_number_)
{

    std::cout << "Floor: " << floor_number_ << std::endl;

    for(int index = 0; index < _rooms_per_floor; ++index)
    {

        std::cout << "Room: " << index + 1;
        if(_assignments[floor_number_ - 1][index] != NULL)
        {
            std::cout << std::endl;
            _assignments[floor_number_ - 1][index]->print();
        }
        else
        {
            std::cout << " not assigned!" << std::endl;
        }

    }

}

void
building::print()
{

    std::cout << "Building: " << _id << std::endl;
    std::cout << "Number of Floors: " << _floors << std::endl;
    std::cout << "Number of Rooms: " << _floors * _rooms_per_floor << std::endl;

}

Das header-file sieht so aus:

#ifndef BUILDING_H
#define BUILDING_H

// Task3
#include "person.hpp"
// STL
#include <string>
#include <vector>

class building
{

    public:
        /**
        * @brief create a new building with specified number of
        *        floors and number of rooms per floor
        */
        building(int id_, int floors_, int rooms_per_floor_);

        /**
        * @brief the destructor is responsible for removing all
        *        the persons from the building and freeing the 
        *        memory occupied by them.
        */
        ~building();

        /**
        * @brief assign a person to the own room
        */
        void
        assign_room(person* tenant_, int floor_, int room_);

        /**
        * @brief remove the tenant associated to the room
        */
        person*
        free_room(int floor_, int room_);

        /**
        * @brief print the information about the room, that is
        *        - id of the building
        *        - floor number
        *        - room number + person occupying it
        */
        void
        print_floor(int floor_number_);

        /**
        * @brief prints informations about the building
        */
        void
        print();

        /**
        * @brief swap the tenants living in two rooms in the
        *        actual building
        */
        bool 
        swap_tenants(int source_room_, int destination_room_);

    private:
        /* id of the building */
        int _id;

        /* number of floors in the building */
        int _floors;

        /* number of rooms contained in each floor */
        int _rooms_per_floor;

        /* data structure representing the rooms placed in each
           floor of the building. In each room there is a person
           assigned to it. It is also possible that no person is
           initially assigned to it.

           NB: indexes start with 0 but the numbers to be shown
               start with 1! */
        std::vector< std::vector<person*> >  _assignments;
};

#endif  // BUILDING_H

Allerdings habe ich eine Frage zur assign_room-Funktion. Man soll dort ja einen Raum einer Person zuweisen. (1 Raum pro Person)
Ich weiss aber nicht, was ich hier aufrufen und was wem zuweisen sollte...

building::building(int id_, int floors_, int rooms_per_floor_)
  : _id(id_), _floors(floors_), _rooms_per_floor(rooms_per_floor_),
    _assignments(floors_, vector<person*>(rooms_per_floor))
    //das initialisiert den vector mit den übergebenen Größen
{
/*  // das hier brauchst du nicht, die Werte wurden schon durch die Initialisierungsliste übernommen
    this->_id = id_;
    this->_floors = floors_;
    this->_rooms_per_floor = rooms_per_floor_;
*/
}

void
building::assign_room(person* tenant_, int floor_, int room_)
{
    _assignments[floor_][room_] = tenant_;
}

Allerdings habe ich eine Frage zur assign_room-Funktion. Man soll dort ja einen Raum einer Person zuweisen. (1 Raum pro Person)
Ich weiss aber nicht, was ich hier aufrufen und was wem zuweisen sollte...

Über so etwas macht man sich normalerweise Gedanken bevor man eine Klasse programmiert... Du solltest dich fragen, wie der Zugriff passieren soll, soll der Raum die Person kennen oder die Person den Raum. Muss der Raum die Personen kennen die in ihm sind? usw.

Vielleicht solltest du dein komplettes Design ändern!? z.B. Eine "Klasse Gebäude", hat einen oder mehrere "Klasse Stock", diese haben keinen, einen oder mehrere "Klasse Raum"... und ein Raum hat einen Zeiger auf eine Person.

@HighLigerBiMBam
Naja..ich hätte auch einiges anders gemacht. Aber übungshalber muss (sollte) ich es so lassen und so implementieren, wie es halt im header vorgegeben wurde.

@BimBam: Man kann es mit der Abstraktion auch übertreiben. Wenn du nicht gerade eine Software für Architekten entwirfst, dürfte es ausreichen, die Raumaufteilung in der Gebäude-Klasse zu speichern.

Eine Schlussfrage habe ich noch.
Es gibt ja die Destruktor-Funktion.
Dort muss ich doch den _assignments-vector löschen.
Wie aber schreibe ich das korrekt?
Mit "delete _assignments;" reklamiert mein Compiler...

main(void)
{
    person* first  = new person("Valentino", "Rossi", "via Bologna 84",1);

    building woko_first(1,2,4);

    woko_first.assign_room(first,2,4);

    /...
}

Allerdings gelingt es mir trotzdem nicht, die Person-Objekte zu deleten.

Nächstbeste Lösung: Verwende einen vernünftigen Smart-Pointer anstelle der nackten Zeiger (z.B. shared_ptr)

Wenn du dich unbedingt selber darum kümmern willst, mußt du mit einer doppelten Schleife durch den Vector durchlaufen und jedes einzelne Element per delete löschen.

PS:

MaxC++ schrieb:

building woko_first(1,2,4);

    woko_first.assign_room(first,2,4);
}

Autsch - Die Indizes beginnen bei 0, d.h. der Raum 2/4 liegt außerhalb des vom Vector verwalteten Speicherbereiches.

Zu deiner Bemerkung:
Schau Dir mal das Header-File aus einem vorherigen Post an. Das ist doch so gedacht, oder seh' ich das falsch?

MaxC++ schrieb:

Zu deiner Bemerkung:
Schau Dir mal das Header-File aus einem vorherigen Post an. Das ist doch so gedacht, oder seh' ich das falsch?

Stimmt auch wieder - da mußt du dann in allen Methoden die Koordinaten umrechnen.

for(int x=1; x<_floors; x++)
	{
		for(int y=1; y<_rooms_per_floor; y++)
		{
			delete _assignments[x-1][y-1];
		}
	}

for(int x=1; x<_floors+1; x++)
    {
        for(int y=1; y<_rooms_per_floor+1; y++)
        {
            delete _assignments[x-1][y-1];
        }
    }