Dziedziczenie, wielokrotne implementowanie konstruktora

Hey.
Mam problem teoretyczny, wynikający trochę z braków w wiedzy ale nie bardzo wiem jak zadać to pytanie w wyszukiwarce (o ile taki mechanizm o którym za chwilę napiszę istnieje). A więc do rzeczy.

Mam klasę Obiekt. Jest prosta bo nie ma ciała, jest tylko po to by po niej dziedziczyć

class Obiekt { };

I mam teraz masę innych klas: Dom, Mur, Płot itd. Wszystkie one dziedzą z klasy Obiekt

class Dom : public Obiekt
{
     short int id;
     std::string type;

     Dom(short int id, std::string type) {
            this->id = id;
            this->type = type;
     }
};

class Płot : public Obiekt
{
     short int id;
     std::string type;

     Płot(short int id, std::string type) {
            this->id = id;
            this->type = type;
     }
};

class Mur : public Obiekt
{
     short int id;
     std::string type;

     Mur(short int id, std::string type) {
            this->id = id;
            this->type = type;
     }
};

Wszystkie nazwy tych klas mają ze sobą coś wspólnego. Wszystkie te obiekty w realnym życiu mogą być budowane. Teraz mam nadzieję wiecie co chciałem osiągnąć. Mając kolejkę budowania mogę ją zdefiniować np jako wektor

Vector<Obiekt> kolejka

i wszyskie te obiekty (dom, mur i płot) będzie można dodać do tej kolejki. To się bodajże nazywa polimorfizm.

Moje pytanie jest następujące: Mając setki obiektów, które mogę budować mam setki implementacji tych konstruktorów, które jak widać są praktycznie takie same. Wszystkie te klasy są takie same, różnią się jedynie nazwami oraz wartościami pól "id" oraz "type". Chciałbym osiągnąc taki efekt, że raz definiuję konstruktor (np. w klasie Obiekt) i pisząc coś w stylu

Obiekt dom = new Dom(1, "blabla");

w klasie Dom mam wartości pól id=1 i type="blabla". Da się takie coś osiągnąć?

To nie jest polimorfizm. W tym przypadku masz źle to zaprojektowane. Powinieneś zrobić coś w stylu:

class TerrainObject {
  enum class Type {
    BUILDING,
    BAREER,
    ...
  };

  const unsigned int id;
  const Type type;
  
  public:
  TerrainObject(unsigned int id, Type type) : id(id), type(type) {}
  virtual ~TerrainObject() {}
};

class House : public TerrainObject {
  public:
  House(unsigned int id, Type type) : TerrainObject(id, type) {}
};

// etc.

Następnie jeśli chcesz mieć jakąś metodę, która jest niezależna od obiektu to należy ją umieścić jako metodę wirtualną w klasie TerrainObject i nadpisać w odpowiedni sposób w klasach potomnych.

No to mniej więcej tak jak ja mam, nie licząc tego typu wyliczeniowego enum i konstrukcji z dwukropkiem. Co to za konstrukcja?

House(unsigned int id, Type type) : TerrainObject(id, type) {}

? Konstruktor kopiujący? To dzięki temu uzyskam ten efekt o którym pisałem?

Dzięki, już wszystko rozumiem. Sprytne i wyrafinowane.

Aby w c++ działał polimorfizm musisz operować na wskaźnikach i referencjach, czego nie robisz w przykładowym vector<object>.

Tak, wiem to, to był pseudokod akurat, chciałem zobrazować co chcę osiągnąć.