555

// ConsoleApplication33.cpp: определяет точку входа для консольного приложения.
//

#include "stdafx.h"




#include <iostream>
#include "cstdlib"
#include<ostream>
#include <vector>
#include <algorithm>
#include <string>
#include <math.h>



template <typename station, typename number>
class Train
{
protected:
	station destination, expedition;
	number train, vanNum;
public:


	//template <typename station, typename number>friend std::ostream& operator<<(std::ostream& s, const Train<station, number> &obj);
//	template <typename station, typename number>friend std::istream& operator>>(std::istream& s, Train &obj);

Train& operator+(Train<station, number>& obj);
	//friend Train<station, number>& operator + (const Train<station, number>& obj, const Train<station, number>& obj1);
	Train<station, number>& operator=(Train<station, number> &obj);


	void getData();
	void addVan();
	void changeDestination();
	void changeExpedition();
	void setTrain();
	void getTrain();
	Train();
	Train(number tarin, number vNum, station exp, station dest);
	Train(const Train &p);
	~Train();
};
/*
template <typename station, typename number>
std::ostream& operator<<(std::ostream& s, const Train<station, number>& obj)
{
	s << "Train number : " << obj.train << "   " << obj.expedition << " - " << obj.destination << std::endl
		<< "Number of vans : " << obj.vanNum << std::endl;
	return s;
}

template <typename station, typename number>
std::istream& operator >> (std::istream& s, Train &obj)
{
	std::cout << std::endl << " Please enter the number of the train :";
	s >> obj.train;
	std::cout << std::endl << "Number of vans :";
	s >> obj.vanNum;
	std::cout << std::endl << "Expedition :";
	s >> obj.expedition;
	std::cout << std::endl << "Destination :";
	s >> obj.destination;
	return s;
}
*/

template<typename station, typename number>
class advTrain : public Train<station, number>
{
protected:
	station destination, expedition;
	number train, vanNum;
	number **places;
	number *eachVan;

public:


	//friend advTrain<station, number> operator +(advTrain<station, number>& obj1, advTrain<station, number>& obj);
	advTrain<station, number>& operator+(advTrain<station, number> &obj);
	advTrain<station, number>& operator=(const advTrain<station, number> &obj);


	advTrain();
	advTrain(const advTrain &p);
	advTrain(number tra, number vanNum, station dest, station exp);
	void advAddVan();
	~advTrain();
	void getInfo();
};




/*
Train<typename station,typename  number> operator + (const Train<station, number>& obj, const Train<station, number>& obj1)
{
	Train<std::string, float> Fr;
	Fr.vanNum = obj.vanNum + obj1.vanNum;
	return Fr;
}
*/

template<typename station, typename number>
Train<station, number>& Train<station, number>::operator+(Train<station, number>& obj)
{
	this->vanNum = this->vanNum + obj.vanNum;
	return *this;

}

template<typename station, typename number>
Train<station, number>& Train<station, number>::operator=(Train<station, number> &obj)
{
	this->vanNum = obj.vanNum;
	return *this;
}




/*advTrain<station, number> operator+(advTrain<station, number>& obj1, advTrain<station, number>& obj)
{
	advTrain<std::string, double> Friended;
	for (int i = 0; i < Friended.vanNum; i++)
	{
		delete[] Friended.places[i];
	}
	delete[] Friended.places;
	delete[] Friended.eachVan;
	Friended.vanNum = obj1.vanNum + obj.vanNum;
	Friended.train = obj1.train + 1;
	Friended.destination = obj1.destination;
	Friended.expedition = obj1.expedition;
	int count = 1;
	Friended.eachVan = new number[Friended.vanNum];
	for (int i = 0; i < Friended.vanNum; i++)
	{
		if (count <= obj1.vanNum)
		{
			Friended.eachVan[i] = obj1.eachVan[i];
			count++;
		}
		else
		{

			Friended.eachVan[i] = obj.eachVan[i - obj1.vanNum];
		}
	}


	count = 1;
	Friended.places = new number*[Friended.vanNum];
	for (int i = 0; i < Friended.vanNum; i++)
	{
		Friended.places[i] = new number[Friended.eachVan[i]];
	}
	for (int i = 0; i < Friended.vanNum; i++)
	{
		for (int j = 0; j < Friended.eachVan[i]; j++)
		{
			if (count <= obj1.vanNum)
			{
				Friended.places[i][j] = obj1.places[i][j];


			}
			else
			{
				Friended.places[i][j] = obj.places[i - obj1.vanNum][j];
			}
		}
		count++;

	}
	return Friended;
}
*/

template<typename station, typename number>
advTrain<station, number>& advTrain<station, number>::operator+(advTrain<station, number>& obj)
{
	number* tempMass = new number[vanNum];
	for (int i = 0; i < vanNum; i++)
	{
		tempMass[i] = eachVan[i];
	}
	delete[] this->eachVan;
	int tempVanNum = this->vanNum;
	this->vanNum = this->vanNum + obj.vanNum;
	this->eachVan = new number[vanNum];
	int eachVanCounter = 0;
	for (int i = 0; i < vanNum; i++)
	{

		if (i < tempVanNum)
		{
			this->eachVan[i] = tempMass[i];
		}
		else
		{
			this->eachVan[i] = obj.eachVan[eachVanCounter];
			eachVanCounter++;
		}
	}
	int **pls = new number*[tempVanNum];
	for (int i = 0; i < tempVanNum; i++)
	{
		pls[i] = new number[tempMass[i]];
	}
	for (int i = 0; i < tempVanNum; i++)
	{
		for (int j = 0; j < tempMass[i]; j++)
		{
			pls[i][j] = places[i][j];
		}
	}
	for (int i = 0; i < tempVanNum; i++)
	{
		delete[]this->places[i];
	}
	delete[]this->places;
	this->places = new number*[vanNum];
	for (int i = 0; i < vanNum; i++)
	{
		this->places[i] = new number[eachVan[i]];
	}
	int VanCounter = 0;
	for (int i = 0; i < vanNum; i++)
	{
		if (i < tempVanNum)
		{
			for (int j = 0; j < eachVan[i]; j++)
			{
				this->places[i][j] = pls[i][j];
			}
		}
		else
		{
			for (int j = 0; j < eachVan[i]; j++)
			{
				this->places[i][j] = obj.places[VanCounter][j];
			}
			VanCounter++;
		}
	}
	delete[]tempMass;
	for (int i = 0; i < tempVanNum; i++)
	{
		delete[]pls[i];
	}
	delete[]pls;
	return *this;
}

template<typename station, typename number>
advTrain<station, number>& advTrain<station, number>::operator=(const advTrain<station, number> &obj)
{
	for (int i = 0; i < vanNum; i++)
	{
		delete[]this->places[i];
	}
	delete[]this->places;
	delete[]this->eachVan;
	this->vanNum = obj.vanNum;
	this->eachVan = new number[this->vanNum];
	for (int i = 0; i < this->vanNum; i++)
	{
		this->eachVan[i] = obj.eachVan[i];
	}
	this->places = new number*[vanNum];
	for (int i = 0; i < this->vanNum; i++)
	{
		this->places[i] = new number[this->eachVan[i]];
	}
	for (int i = 0; i < vanNum; i++)
	{
		for (int k = 0; k < eachVan[i]; k++)
		{
			this->places[i][k] = obj.places[i][k];
		}
	}
	return *this;
}



template<typename station, typename number>
Train<station, number>::~Train() {}

template<typename station, typename number>
Train<station, number>::Train()
{
	train = 734.5;
	vanNum = 9;
	expedition = "Kyiv";
	destination = "Pokrovs'k";
}

template<typename station, typename number>
void Train<station, number>::getData()
{
	std::cout << "Train number : " << train << "   " << expedition << " - " << destination << std::endl
		<< "Number of vans : " << vanNum << std::endl;
}

template<typename station, typename number>
Train<station, number>::Train(const Train<station, number> &p)
{
	train = p.train;
	vanNum = p.vanNum;
	expedition = p.expedition;
	destination = p.destination;
}

template<typename station, typename number>
Train<station, number>::Train(number tarin, number vNum, station exp, station dest)
{
	train = tarin;
	vanNum = vNum;
	expedition = exp;
	destination = dest;
}



template<typename station, typename number>
void   Train<station, number>::addVan()
{
	std::cout << "Please enter amount of additional vans " << std::endl;
	number additionalVans;
	std::cin >> additionalVans;
	vanNum = vanNum + additionalVans;
}

template<typename station, typename number>
void Train<station, number>::setTrain()
{
	std::cout << "Please enter the number of the Train ";
	std::cin >> this->train;
}

template<typename station, typename number>
void  Train<station, number>::getTrain()
{
	std::cout << " The number of the train : " << train << std::endl;
}

template<typename station, typename number>
void  Train<station, number>::changeExpedition()
{
	std::cout << "Change expedition station for train number # " << train << std::endl;
	std::cin >> expedition;
}

template<typename station, typename number>
void  Train<station, number>::changeDestination()
{

	std::cout << "Change destination station for train number # " << train << std::endl;
	std::cin >> destination;
}




template<typename station, typename number>
void advTrain<station, number>::getInfo()
{
	std::cout << "Train number : " << train << "   " << expedition << " - " << destination << std::endl
		<< "Number of vans : " << vanNum << std::endl;
	std::cout << "Free places : " << std::endl;
	for (int j = 0; j < vanNum; j++)
	{

		std::cout << "Van #" << j + 1 << " : ";
		for (int k = 0; k < eachVan[j]; k++)
		{

			std::cout << places[j][k] << ",  ";
		}
		std::cout << std::endl;
	}
}

template<typename station, typename number>
advTrain<station, number>::~advTrain()
{
	delete[]eachVan;
	for (int i = 0; i < vanNum; i++)
	{
		delete[]places[i];
	}
	delete[]places;
}



template<typename station, typename number>
advTrain<station, number>::advTrain()
{
	train = 734.5;
	vanNum = 10;
	expedition = "Kyiv";
	destination = "Pokrovs'k";
	places = new number*[vanNum];
	eachVan = new number[vanNum];
	for (int h = 0; h < vanNum; h++)
	{
		eachVan[h] = rand() % 15;
	}

	for (int i = 0; i < vanNum; i++)
	{
		places[i] = new number[eachVan[i]];
	}

	std::vector<int> plcs(15);

	int n = 0;

	for (int j = 0; j < vanNum; j++) //vn-1
	{
		for (int i = 0; i < plcs.size(); i++)
		{
			plcs[i] = i + 1;
		}
		std::random_shuffle(plcs.begin(), plcs.end());
		for (int k = 0; k < eachVan[j]; k++)
		{
			places[j][k] = plcs[n];
			n++;
		}
		n = 0;
	}
	plcs.erase(plcs.begin(), plcs.end());
}

template<typename station, typename number>
void advTrain<station, number>::advAddVan()
{
	std::cout << "Please enter how many vans you want to add : ";
	number additionalVans, tempVN;
	std::cin >> additionalVans;
	tempVN = vanNum;
	vanNum = vanNum + additionalVans;

	int *tempEachVan;
	tempEachVan = new number[tempVN];
	for (int i = 0; i < tempVN; i++)
	{
		tempEachVan[i] = eachVan[i];
	}
	delete[]eachVan;


	this->eachVan = new number[vanNum];
	for (int i = 0; i < vanNum; i++)
	{
		if (i < tempVN)// ili bez =
		{
			eachVan[i] = tempEachVan[i];
		}
		else
		{
			eachVan[i] = 15;
		}
	}

	int **tempMass;
	tempMass = new number*[tempVN];
	for (int i = 0; i < tempVN; i++)
	{
		tempMass[i] = new number[eachVan[i]];
	}

	for (int j = 0; j < tempVN; j++)
	{
		for (int k = 0; k < eachVan[j]; k++)
		{
			tempMass[j][k] = places[j][k];
		}
	}

	for (int i = 0; i < tempVN; i++)
	{
		delete[]places[i];
	}
	delete[]places;

	places = new number*[vanNum];
	for (int i = 0; i < vanNum; i++)
	{
		if (i < tempVN)
		{
			places[i] = new number[eachVan[i]];
		}
		else
		{
			places[i] = new number[15];
		}

	}

	int n = 1;
	for (int j = 0; j < vanNum; j++)
	{
		if (j < tempVN)
		{
			for (int k = 0; k < tempEachVan[j]; k++)
			{
				places[j][k] = tempMass[j][k];
			}

		}
		else
		{
			for (int k = 0; k < 15; k++)
			{
				places[j][k] = n;
				n++;
			}
		}
		n = 1;
	}


	delete[]tempEachVan;
	for (int i = 0; i < tempVN; i++)
	{
		delete[]tempMass[i];
	}
	delete[]tempMass;
}




template<typename station, typename number>
advTrain<station, number>::advTrain(const advTrain<station, number> &p)
{
	train = p.train;
	vanNum = p.vanNum;
	destination = p.destination;
	expedition = p.expedition;
	places = new number*[vanNum];
	eachVan = new number[vanNum];
	for (int i = 0; i < vanNum; i++)
	{
		eachVan[i] = p.eachVan[i];
	}
	for (int i = 0; i < vanNum; i++)
	{
		places[i] = new number[eachVan[i]];
	}
	for (int j = 0; j < vanNum; j++)
	{
		for (int k = 0; k < eachVan[j]; k++)
		{
			places[j][k] = p.places[j][k];
		}
	}
}

template<typename station, typename number>
advTrain<station, number>::advTrain(number tra, number vanNumero, station dest, station exp)
{
	train = tra;
	vanNum = vanNumero;
	destination = dest;
	expedition = exp;
	places = new number*[vanNum];
	eachVan = new number[vanNum];
	for (int h = 0; h < vanNum; h++)
	{
		eachVan[h] = rand() % 15;
	}

	for (int i = 0; i < vanNum; i++)
	{
		places[i] = new number[eachVan[i]];
	}

	std::vector<number> plcs(15);

	int n = 0;

	for (int j = 0; j < vanNum; j++)
	{
		for (int i = 0; i < plcs.size(); i++)
		{
			plcs[i] = i + 1;
		}
		std::random_shuffle(plcs.begin(), plcs.end());
		for (int k = 0; k < eachVan[j]; k++)
		{
			places[j][k] = plcs[n];
			n++;
		}
		n = 0;
	}
}



int main()
{


	Train<std::string, float> asdtestT;
	asdtestT.getData();

	Train<std::string, float> qw;

	qw = qw + asdtestT;
	qw.getData();

	advTrain<std::string, int> Testing;
	Testing.getInfo();

	std::cin.get();
	std::cin.get();

	return 0;
}