problem z delete

Witam.
Mam taki kod

#include <iostream>


struct turystyka
{
	int pocz;
	int kon;
	int wartosc;
	int drzewo;
};


class Turystyka
{
private:
	int iloscdrog=0;
	int iloscmiast=1;
	int skad;
	int dokad;
	int ileosob;

	turystyka * droga = new turystyka[iloscdrog];
	turystyka * drogasort = new turystyka[iloscdrog];
	turystyka * drzewa = new turystyka[iloscmiast-1];


public:
	~Turystyka();
	void setiledrog(int X);
	void setilemiast(int N);

	void settab(int miastoa, int miastob, int wart, int i);
	void sety(int sskad, int gdzie, int ile);


	void przypisz();
	void sort();





	void wyswietldroga();
	void wyswietldrogasort();
	void wyswietldrzewa();
};

Turystyka::~Turystyka()
{
	delete[] droga;
	delete[] drogasort;
	delete[] drzewa;

}



void Turystyka::setilemiast(int N)
{
	iloscmiast = N;
}


void Turystyka::setiledrog(int X)
{
	iloscdrog = X;
}


void Turystyka::settab(int miastoa, int miastob, int wart, int i)
{

	droga[i].pocz = miastoa;
	droga[i].kon = miastob;
	droga[i].wartosc = wart;
}


void Turystyka::sety(int sskad, int gdzie, int ile)
{
	skad = sskad;
	dokad = gdzie;
	ileosob = ile;
}

void Turystyka::przypisz()
{
	drogasort = droga;
}

void Turystyka::sort()
{
	for (int i = 0; i < iloscdrog; i++)
	{
		for (int j = 1; j < iloscdrog - i; j++)
		{
			if (drogasort[j - 1].wartosc < drogasort[j].wartosc)
			{
				std::swap(drogasort[j - 1], drogasort[j]);
			}
		}
	}
}









void Turystyka::wyswietldroga()
{
	for (int j = 0; j < iloscdrog; j++)
	{
		std::cout << droga[j].pocz << "  ";
		std::cout << droga[j].kon << "  ";
		std::cout << droga[j].wartosc << std::endl;
	}
}

void Turystyka::wyswietldrogasort()
{
	for (int j = 0; j < iloscdrog; j++)
	{
		std::cout << drogasort[j].pocz << "  ";
		std::cout << drogasort[j].kon << "  ";
		std::cout << drogasort[j].wartosc << std::endl;
	}
}


void Turystyka::wyswietldrzewa()
{
	for (int j = 1; j < iloscmiast; j++)
	{
		std::cout << drzewa[j].pocz << "  ";
		std::cout << drzewa[j].kon << "  ";
		std::cout << drzewa[j].wartosc << "  ";
		std::cout << drzewa[j].drzewo << std::endl;
	}
}





int main()
{
	Turystyka t;

	int ilemiast;
	int iledrog;

	std::cin >> ilemiast;
	std::cin >> iledrog;

	t.setiledrog(iledrog);
	t.setilemiast(ilemiast);

	int miastoa;
	int miastob;
	int ile;

	for (int i = 0; i < iledrog; i++)
	{
		std::cin >> miastoa;
		std::cin >> miastob;
		std::cin >> ile;
		t.settab(miastoa, miastob, ile, i);
	}

	int skad;
	int dokad;
	int ileosob;


	std::cin >> skad;
	std::cin >> dokad;
	std::cin >> ileosob;

	t.sety(skad, dokad, ileosob);



	t.wyswietldroga();
	//t.przypisz();
	//t.sort();
	//t.wyswietldrogasort();

	system("pause");
	return 0;
}

Nie widzę tutaj błędu, Program wywala się przy końcu programu co wskazywało by na destruktor, ale według mnie jest on poprawny.
Co może być tutaj problemem ?

class Turystyka
{
private:
    int iloscdrog=0;
    int iloscmiast=1;
    int skad;
    int dokad;
    int ileosob;

    turystyka * droga = new turystyka[iloscdrog];
    turystyka * drogasort = new turystyka[iloscdrog];
    turystyka * drzewa = new turystyka[iloscmiast-1];
// ...
};

Alokujesz 0 elementów (nie wspominając już o dziwnym sposobie tejże alokacji), a potem próbujesz zapisywać do 0-elementowej tablicy elementy. Nic dziwnego, że się wysypuje. Użyj std::vector zamiast takich dziwnych wymysłów: https://dsp.krzaq.cc/post/176/ucze-sie-cxx-kiedy-uzywac-new-i-delete/

Przy okazji: https://en.cppreference.com/w/cpp/language/rule_of_three - w obecnym kodzie ta klasa łamie rule of zero/three/five i jest absolutnie niebezpieczna w użyciu.