sample, C++ (vc++)

Language: Layout:

//Microsoft (R) C/C++ Optimizing Compiler Version 19.00.23506 for x86

#include <iostream>

class Cars {
public:
    Cars &operator=(Cars &right);
	virtual void Print() = 0;
	virtual ~Cars(){};
    
    virtual Cars* Clone()const = 0;
};

class Sedan :public Cars {
public:
	Sedan();
	Sedan(int cost, float road_clearance);
	Sedan(std::istream& is1, std::istream& is2);
	Sedan(const Sedan &orig);
	void Print();
	Sedan &operator=(Sedan &right);
	friend std::istream& operator>>(std::istream& is, Sedan &Sedan);
	friend std::ostream& operator<<(std::ostream &os, const Sedan &obj);
	~Sedan();
    
    virtual Cars* Clone()const override
    {
        return new Sedan(*this);
    }
private:
	int cost;
	int speed;
};

Sedan::Sedan() :Sedan(1000000, 10.8) {
}

Sedan::Sedan(int a, float b) : cost(a), speed(b) {
	std::cout << "Sedan created" << std::endl;
}

Sedan::Sedan(std::istream& is1, std::istream &is2) {
	is1 >> cost;
	is2 >> speed;
}

Sedan::Sedan(const Sedan &orig) {
	cost = orig.cost;
	speed = orig.speed;
	std::cout << "Sedan copy created" << std::endl;
}

void Sedan::Print() {
	std::cout << "S:" << cost << ", " << speed << std::endl;
}

Sedan& Sedan::operator=(Sedan &right) {
	if (this == &right)
		return *this;
	(*this).cost = right.cost;
	(*this).speed = right.speed;
	std::cout << "operator =: success" << std::endl;
	return (*this);
}

std::istream &operator>>(std::istream &is, Sedan &Sedan) {
	is >> Sedan.cost;
	is >> Sedan.speed;
	return is;
}

std::ostream& operator<<(std::ostream& os, const Sedan &Sedan) {
	std::cout << Sedan.cost << ", " << Sedan.speed;
	return os;
}

Sedan::~Sedan(){
	std::cout << "Sedan deleted" << std::endl;
}    
    
class TQueueItem {
public:
	TQueueItem();
	TQueueItem(Cars& car);
	TQueueItem(TQueueItem& orig);
	friend std::ostream& operator<<(std::ostream& os, const TQueueItem& obj);
	
	TQueueItem *GetNext();
	Cars *GetCar() const ;
	~TQueueItem();
	TQueueItem *next;
private:
	Cars *car;
};

TQueueItem::TQueueItem() : car(nullptr), next(nullptr){}

TQueueItem::TQueueItem(Cars &cars):car(cars.Clone()) ,next(nullptr) {
	std::cout << "Queue item: created" << std::endl;
}

TQueueItem::TQueueItem(TQueueItem& orig) {
	car = orig.car;
	next = orig.next;
}

Cars *TQueueItem::GetCar() const {
	return this->car;
}

TQueueItem* TQueueItem::GetNext() {
	return this->next;
}

std::ostream &operator<<(std::ostream& os, const TQueueItem &obj) {
	os << "[";
	obj.GetCar()->Print();
	os<< "] ";
	return os;
}

TQueueItem::~TQueueItem() {
    delete car;
	std::cout << "Queue item: deleted" << std::endl;
}

class TQueue {
public:
	TQueue();
	TQueue(const TQueue &orig);
	TQueue(Cars &car);
	int GetSize();
	void PushBack(Cars &car);
	void PushBack(Cars *car);
	Cars *PopFront();
	bool Empty();
    friend std::ostream& operator<<(std::ostream &os, const TQueue &queue);
	
	void ISize();
	void DSize();
	
	~TQueue();
	
private:
	TQueueItem *head;
	TQueueItem *tail;

int size;	
};

TQueue::TQueue() :head(nullptr), tail(nullptr), size(0){ /*head = tail;*/ }

TQueue::TQueue(const TQueue &orig) {
	head = orig.head;
	tail = orig.tail;
	size = orig.size;
}

TQueue::TQueue(Cars &car) {
	head = tail = new TQueueItem(car);
	size = 1;
	tail->next = nullptr;
    tail->GetCar()->Print();
}

std::ostream& operator<<(std::ostream &os, const TQueue &queue) {
	std::cout << "in print" << std::endl;
	TQueueItem *ptr = queue.head;
	while (ptr != nullptr) {
		os << *ptr << std::endl;
		
		ptr = ptr->GetNext();
	}
	return os;
}

void TQueue::PushBack(Cars &car) {

TQueueItem *item = new TQueueItem(car);
	item->next = nullptr;
	tail->next = item;
	tail = item;
	tail->GetCar()->Print();
	size++;
}

void TQueue::PushBack(Cars *car) {
	
	TQueueItem *item = new TQueueItem(*car);
	item->next = nullptr;
	tail->next = item;
	tail = item;
	tail->GetCar()->Print();
	
	size++;
}

Cars *TQueue::PopFront() {
	static Cars *car;
	TQueueItem *tmp = head;
	if (head != nullptr)
		 car = tmp->GetCar();
	head = head->GetNext();
	delete tmp;
	DSize();
	
	return car;
}

int TQueue::GetSize() {
	return size;
}

void TQueue::ISize() {
	size++;
}

void TQueue::DSize() {
	if (size>0)
		size--;
}

bool TQueue::Empty() {
	return (head == nullptr);
}

TQueue::~TQueue() {
	delete head;
}

int main()
{
    TQueue q(Sedan(1000000,120));
	q.PushBack(Sedan(3400000, 210));
    Cars *car1 = new Sedan();
    q.PushBack(car1);
    std::cout << q;
    
}

Show compiler warnings [ + ] Compiler args [ + ] Show input
Compilation time: 1,62 sec, absolute running time: 0,22 sec, absolute service time: 1,85 sec