Erstellen einer MultiClass Queue C++

Question

Ist es möglich, eine Warteschlange für verschiedene Arten von Objekten zu erstellen, aber mit derselben Schnittstelle?

Als Beispiel habe ich eine Schnittstelle SensorItem und 4 Arten von Klasse, SensorItemA , SensorItemB, SensorItemC , SensorItemD `

queue <SensorItem> cola; 
void encolar(SensorItem* dato) 
{ 
    cola.push (*dato); 
} 
SensorItem* sacar() 
{ 
    SensorItem* d=cola.front(); 
    cola.pop(); 
    return d; 

} 

Das ist meine Klasse Queue (Cola) und hier i genannt versuchen Sie es zu verwenden

void main() 
{ 
    Cola c=new Cola(); 
    TemperatureItem t=new TemperatureItem(3.25); 
    c.encolar(t); 
    ImuItem i=new ImuItem(3,4,8); 
} 

ist es etwas falsch in meiner Syntax? oder ist es einfach nicht möglich?

Answer 1

Polymorphie in C++ funktioniert nur mit Referenzen und Zeigern. Objekte in C++ sind Objekte, keine Referenzen. Wenn Sie ein SensorItem erstellen, wird es immer ein SensorItem, kein TemperatureItem oder ein ImuItem sein. Wenn Sie eine std::queue<SensorItem> haben, sind die Elemente immer SensorItem s, nie TemperatureItem s oder ImuItems.

Wenn Sie eine Warteschlange von Objekten aus SensorItem abgeleitet machen wollen, müssen Sie SensorItem s eine Warteschlange von Zeigern verwenden:

#include <iostream> 
#include <queue> 
#include <memory> 

struct SensorItem 
{ 
    virtual void doAThing() = 0; 
    virtual ~SensorItem() {} 
}; 

struct TemperatureItem : SensorItem 
{ 
    void doAThing() { std::cout << "TemperatureItem\n"; } 
}; 

struct ImuItem : SensorItem 
{ 
    void doAThing() { std::cout << "ImuItem\n"; } 
}; 

class Cola 
{ 
private: 
    std::queue<std::unique_ptr<SensorItem>> cola; 

public: 
    void encolar(std::unique_ptr<SensorItem> dato) 
    { 
     cola.push(std::move(dato)); 
    } 
    std::unique_ptr<SensorItem> sacar() 
    { 
     std::unique_ptr<SensorItem> d = std::move(cola.front()); 
     cola.pop(); 
     return d; 
    } 
}; 

int main() 
{ 
    Cola c; 
    c.encolar(std::make_unique<TemperatureItem>()); 
    c.encolar(std::make_unique<ImuItem>()); 
    std::unique_ptr<SensorItem> item = c.sacar(); 
    item->doAThing(); 
    item = c.sacar(); 
    item->doAThing(); 
} 

Live on Coliru

Here I std::unique_ptr verwendet habe, um zu vermeiden, manuelle Speicherverwaltung durchführen. Sie könnten rohe SensorItem* s verwenden, aber ich würde davon abraten.