Как улучшить C++ реализацию конвейерного ленточного решения в C++

---

постановка задачи:

Существует заводская производственная линия вокруг одной конвейерной ленты.

Компоненты (типа А и в) приходят на начало ремня случайным образом

интервалы; рабочие должны взять один компонент каждого типа из ленты
как только они пройдут мимо, соедините их и получите готовый продукт.

Пояс разделен на пазы фиксированного размера; каждый слот может вместить только один
компонент или один готовый продукт. Есть целый ряд рабочих

станции по обе стороны от пояса, расположенные на расстоянии, соответствующем размеру пояса.
прорези на поясе, вот так (шрифт фиксированной ширины ASCII pic):
в В В В В работники
---------------------
- и GT; | А | | Б | А | П | -&ГТ; ленточный конвейер

---------------------
^ ^ ^ ^ ^ рабочие

В каждую единицу времени пояс перемещается вперед на одно положение, и там
это время для работника на одной стороне каждого слота либо взять предмет

из гнезда или заменить предмет на ремне. Рабочий напротив
они не могут касаться одного и того же гнезда ремня, пока делают это.
(Таким образом, вы не можете позволить одному работнику выбрать что-то из слота, пока
их двойник кладет что-то на то же место).


Как только работник собрал один из обоих типов компонентов, он может
начните сборку готового изделия. Это занимает определенное количество времени,
таким образом, они будут готовы только к тому, чтобы поместить собранный продукт обратно на стол.

ремень на четвертом последующем пазу. В то время как они собирают
продукт, они не могут коснуться конвейерной ленты. Рабочие могут только держать
два предмета (компонент или продукт) одновременно: по одному в каждой руке.

Создайте имитацию этого, с тремя парами рабочих. На каждом из них

интервал времени, слот в начале конвейерной ленты должен иметь
равный (1/3) шанс ничего не содержать, компонент А или А
компонент В.

Запустите симуляцию на 100 шагов и вычислите, сколько из них закончено

продукты сходят с производственной линии, и сколько компонентов каждого из них
тип пройдите через производственную линию без быть подобранным любым
рабочие.


Я реализовал это решение следующим образом:

Есть ли другой лучший способ сделать это,если мы можем использовать любой шаблон дизайна или сделать его более универсальным?

Что я уже пробовал:

#include <string>
#include <iostream>
#include <vector> 
#include <list>
#include<ctime>
#include <math.h>

using namespace std;

#define NULL 0

enum {
	STATE_WORKING = 0,
	STATE_FINISHED = 1,
	STATE_SUBMITTED = 2
} WORKER_STATE;

enum CACHE_STATE {
	CACHE_STATE_EMPTY = 0,
	CACHE_STATE_ONLY_PART_A = 1,
	CACHE_STATE_ONLY_PART_B = 2,
	CACHE_STATE_BOTH_PARTA_PARTB = 3
};

class Conveyor {
public:
	string move();
private:
	vector<string> parts;
};

std::vector<string> randomize()
{
	srand(time(0));
	string choices[] = { "Part_A", "Part_B", "Part_A" };

	std::vector<string> random;
	for (int i = 0; i < 3; i++)
	{
		random.push_back(choices[rand() % 3]);
	}
	return random;
}

string Conveyor::move()
{
	srand(time(0));

	randomize();
	std::vector<string> randomResult = randomize();

	return randomResult[0];

	/*
	for (iter = randomResult.begin(), iterEnd = randomResult.end();
		iter != iterEnd; ++iter)
		cout << *iter << endl;

	return *iter;


	string partno;
	partno = parts.front();

	parts.erase(parts.begin());
	
	return partno;
	*/
}

class Worker {
public:
	void getPart(Conveyor& conveyor);
	void putItem(Conveyor& conveyor);
	void assembleItem(string part_a, string part_b);
	bool isAssembling;
	bool hasAllParts;
	bool hasAssembly;


	int cachestate;
private:
	int parts_reqd;
	int time_reqd;
	string slave;
	int worker_position;
};

void Worker::getPart(Conveyor& conveyor)
{
	bool cache_empty = true;
	CACHE_STATE cachestate;
	string incoming_part;
	
	incoming_part = conveyor.move();
	if (strcmp(incoming_part.c_str(), "part_A") == 0)
	{
		cachestate = CACHE_STATE::CACHE_STATE_ONLY_PART_A; 
		cache_empty = false;
	}

	if (strcmp(incoming_part.c_str(), "part_B") == 0)
	{
		cachestate = CACHE_STATE::CACHE_STATE_ONLY_PART_B;
		cache_empty = false;
	}
	if (strcmp(incoming_part.c_str(), "part_NULL") == 0)
	{
		cachestate = CACHE_STATE::CACHE_STATE_EMPTY;
		cache_empty = true;
	}
}

void Worker::putItem(Conveyor& conveyor)
{
	unsigned int finished_part = 0;
	
	finished_part++;
	cout << "No of finished part = ", finished_part;
}

void Worker::assembleItem(string part_a,string part_b)
{
	string fin_part;
	unsigned int time_taken = 0;
	fin_part = part_a + part_b;
	time_taken = 5;
}

class ProductionLine {
public:
	Conveyor the_conveyor;
	std::vector<Worker> workers;
	void runprodline(unsigned int pairs,int no,string ar[2]);
};

void ProductionLine::runprodline(unsigned int worker_pairs,int totalworkers,string partposns[2])
{
	string part[100];

	Worker workerone;

	Conveyor objConv;
	unsigned int  i = 0;
	   

	unsigned int assembled_part = 0;
	unsigned int elapsed_time_part_complete = 0;

	unsigned int finished_part = 0;
	Worker workeronline[2];
	Worker worker_two;

	cout << "Part no 0 = " << partposns[0] << endl;
	cout << "Part no 1 = " << partposns[1] << endl;
	cout << "Part no 1 = " << partposns[2] << endl;

	workeronline[1].hasAllParts = false;
	workeronline[1].isAssembling = false;

	for (i = 0; i < 3; i++)
	{
		for (int workerposition = 0; workerposition < 2; workerposition++)
		{
			if (strcmp(partposns[i].c_str(), "part_A") == 0)
			{
				workeronline[workerposition].cachestate = CACHE_STATE_ONLY_PART_A;

				partposns[i] = "";
			}
			if (strcmp(partposns[i].c_str(), "part_B") == 0)
			{
				workeronline[workerposition].cachestate = CACHE_STATE_ONLY_PART_B;

				partposns[i] = "";
			}
			if( (strcmp(partposns[i].c_str(), "part_A") == 0) && (workeronline[workerposition].cachestate == CACHE_STATE_ONLY_PART_B))
			{
				workeronline[workerposition].cachestate = CACHE_STATE_BOTH_PARTA_PARTB;

				workeronline[workerposition].hasAllParts = true;

				partposns[i] = "";
			}
			if ((strcmp(partposns[i].c_str(), "part_B") == 0) && (workeronline[workerposition].cachestate == CACHE_STATE_ONLY_PART_A))
			{
				workeronline[workerposition].cachestate = CACHE_STATE_BOTH_PARTA_PARTB;

				workeronline[workerposition].hasAllParts = true;

				partposns[i] = "";
			}
			if (workeronline[workerposition].hasAllParts == true)
			{
				workeronline[workerposition].isAssembling = true;

				elapsed_time_part_complete++;
			}
			if ((workeronline[workerposition].isAssembling == true) && (elapsed_time_part_complete % 4) == 0)
			{
				workeronline[workerposition].hasAssembly = true;

				workeronline[workerposition].isAssembling = false;

			}
			if ((strcmp(partposns[i].c_str(), "part_NULL") == 0) && (workeronline[workerposition].hasAssembly == true))
			{
				finished_part = finished_part + 1;

				workeronline[workerposition].hasAssembly = false;
			}
		}
	}		
	
	cout << "No of finished parts = " << finished_part << endl;
}

int main()
{
	ProductionLine obj_prodline;
	unsigned int pair = 3;
	unsigned int workerspositions;
	string partone;
	Conveyor conveyor;

	workerspositions = pair * 2;
	string conveyorpartposition[3];
	conveyorpartposition[0] = "";
	conveyorpartposition[1] = "";
	conveyorpartposition[2] = "";

	string part[2];

	for (int i = 0; i < 100; i++)
	{
		partone = conveyor.move();
		conveyorpartposition[0] = partone;

		obj_prodline.runprodline(pair, workerspositions, conveyorpartposition);

		conveyorpartposition[2] = conveyorpartposition[1];
		conveyorpartposition[1] = conveyorpartposition[0];		
	}
}

---