exception thrown visual studio

[theleonicking]

I'm working on my lab for a class and my code is throwing an exception and I'm not sure how to fix it. I would really appreciate some help on what to do because I'm at a complete loss. The last thing I did was change my strtok to strtok_s in my load function but I'm not sure if that's the cause or not.

#include <iostream>
#include <cstring>
#include <fstream>

using namespace std;

const int MAX_CHAR = 101;

class Wagon
{
public:
	Wagon();
	Wagon(const char Name[], const char Team[], float Weight, float Animals);
	Wagon(const Wagon& wagon);
	~Wagon();

	void operator= (const Wagon& wagon);
	void nameget(char Name[]) const;
	void teamget(char Team[]) const;
	void nameset(const char Name[]);
	void teamset(const char Team[]);
	void weightset(float Weight);
	void animalsset(float Animals);
	float weightget() const;
	float animalsget() const;
	void wagonget();
	void create(const char Name[], const char Team[], float Weight, float Animals);
private:
	char* Name;
	char* Team;
	float	Weight;
	float	Animals;
};

class Wagonlist
{
public:
	Wagonlist();
	~Wagonlist();

	void addwagon(const Wagon& wagon);
	void removewagon(const Wagon& wagon);
	void print(const Wagon& wagon);
	void loadwagons(const char file[]);
	void savewagons(const char file[]) const;
private:
	struct Node
	{
		Node(const Wagon& wagon)
		{
			list = wagon;
			next = nullptr;
			index = 0;
		}

		int index;
		Wagon list;
		Node* next;
	};

	Node* head;
	Node* tail;
	int	size;
};


void displayMenu();
char commandget();
void execute(char command, Wagonlist& list);

int main()
{
	char		command;
	Wagonlist	collection;
	char		file[] = "wagons.txt";

	collection.loadwagons(file);
	displayMenu();
	command = commandget();

	while (command != 'q')
	{
		execute(command, collection);
		displayMenu();
		command = commandget();
	}

	//collection.savesongs(file);
	return 0;
}

Wagonlist::Wagonlist()
{
	head = nullptr;
	tail = nullptr;
	size = 0;
}

Wagonlist::~Wagonlist()
{
	Node* curr = head;

	while (curr)
	{
		head = curr->next;
		delete curr;
		curr = head;
	}
}


void Wagonlist::addwagon(const Wagon& wagon)
{
	Node* newnode = new Node(wagon);
	newnode->next = head;
	head = newnode;
	size++;
}


void Wagonlist::print(const Wagon& wagon)
{
	char	Name[MAX_CHAR];
	char	Team[MAX_CHAR];
	int		Weight;
	int		Animals;
	int		i;

	Node* curr = head;
	i = 0;

	while (curr)
	{
		cout << "[" << i << "]" << endl;
		curr->list.nameget(Name);
		curr->list.teamget(Team);
		Weight = curr->list.weightget();
		Animals = curr->list.animalsget();

		cout << "Family Name: " << Name << endl;
		cout << "Team: " << Team << endl;
		cout << "Weight: " << Weight << endl;
		cout<<"Number of Animals: " << Animals << endl;
		curr = curr->next;
		i++;
	}
}

void Wagonlist::loadwagons(const char file[])
{
	char		buffer[MAX_CHAR];
	char*		pch;
	char        Name[MAX_CHAR];
	char        Team[MAX_CHAR];
	float       Weight;
	float       Animals;
	int         counter;
	int         length;
	char* next_token;
	Wagon		currwagon;
	ifstream    in;
	//rsize_t strmax;
	in.open("wagons.txt");

	if (!in)
	{
		exit(0);
	}

	while (in.getline(buffer, MAX_CHAR))
	{
		char temp[4][MAX_CHAR];
		counter = 0;
		//rsize_t strmax = sizeof buffer;
		pch = strtok_s(buffer, "|", &next_token);

		while (pch != nullptr)
		{
			strcpy_s(temp[counter], pch);
			pch = strtok_s(nullptr, "|", &next_token);
			counter++;
		}

		strcpy_s(Name,MAX_CHAR, temp[0]);
		strcpy_s(Team, MAX_CHAR, temp[2]);
		Weight = atoi(temp[1]);
		Animals = atoi(temp[3]);
		length = strlen(Name);

		currwagon.nameset(Name);
		currwagon.teamset(Team);
		currwagon.weightset(Weight);
		currwagon.animalsset(Animals);

		Node* newnode = new Node(currwagon);
		Node* curr = head;

		if (!curr)
		{
			head = newnode;
			tail = newnode;
		}
		else
		{
			while (curr->next)
			{
				curr = curr->next;
			}

			curr->next = newnode;
		}
		tail = newnode;
		size++;
	}
	in.close();
}

void Wagonlist::savewagons(const char file[]) const
{
	char		Name[MAX_CHAR];
	char		Team[MAX_CHAR];
	float		Weight;
	float		Animals;
	
	ofstream	out;
	Node* curr;

	out.open("wagons.txt");
	if (!out)
	{
		cout << "Something went wrong while opening the file." << endl;
		exit(1);
	}

	for (curr = head;curr;curr = curr->next)
	{
		curr->list.nameget(Name);
		curr->list.teamget(Team);
		Weight = curr->list.weightget();
		Animals = curr->list.animalsget();

		out << Name << '|' << Team << '|' << Weight << '|' << Animals << endl;
	}

	cout << "Your wagons have been documented." << endl;
	out.close();
}

void Wagonlist::removewagon(const Wagon& wagon)
{
	int     count;
	int		i;

	Node* curr = new Node(wagon);
	Node* prev = new Node(wagon);
	curr = head;
	prev = head;
	i = 0;
	count = 0;

	cout << "Please enter the index number of the wagon that you wish to remove." << endl;
	cin >> i;
	cin.ignore();
	cin.clear();

	while (curr)
	{
		prev = curr;
		curr = curr->next;
		if (i == 0)
		{
			head = curr;
			return;
		}
		else if (i == count)
		{
			curr = curr->next;
			prev->next = curr;
			return;
		}
		count++;
	}
	size--;
	delete prev;
	delete curr;
}

void displayMenu()
{
	cout << "Please select what you want to do.";
	cout << endl << "Welcome to Uwagons!" << endl
		<< "     a. Add a wagon " << endl
		<< "     l. Show all wagons " << endl
		<< "     r. Remove a wagon " << endl
		<< "     q. Quit " << endl << endl;
}

char commandget()
{
	char	cmd;

	cin.get(cmd);
	cin.ignore(100, '\n');
	return (cmd);
}

void execute(char cmd, Wagonlist& list)
{
	Wagon	wagon;

	switch (cmd)
	{
	case 'a':
		wagon.wagonget();
		list.addwagon(wagon);
		break;
	case 'l':
		list.print(wagon);
		break;
	case 'r':
		list.removewagon(wagon);
		break;
	case 'q':
		cout << "goodbye" << endl;
	default:
		cout << "You have entered an illegal command. Please try again. " << endl;
		break;
	}
}


Wagon::Wagon()
{
	create("No Family Name", "No Team", 0, 0);
}

Wagon::Wagon(const char Name[], const char Team[], float Weight, float Animals)
{
	create(Name, Team, Weight, Animals);
}

void Wagon::create(const char Name[], const char Team[], float Weight, float Animals)
{
	this->Name = new char[strlen(Name) + 1];
	this->Team = new char[strlen(Team) + 1];
	strcpy_s(this->Name, MAX_CHAR, Name);
	strcpy_s(this->Team, MAX_CHAR, Team);
	this->Weight = Weight;
	this->Animals = Animals;
}

Wagon::Wagon(const Wagon& wagon)
{
	this->Name = nullptr;
	this->Team = nullptr;
	*this = wagon;
}

Wagon::~Wagon()
{
	if (this->Name)
	{
		delete[] this->Name;
	}

	if (this->Team)
	{
		delete[] this->Team;
	}
}

void Wagon::nameget(char Name[]) const
{
	strcpy_s(Name, MAX_CHAR, this->Name);
}

void Wagon::teamget(char Team[]) const
{
	strcpy_s(Team, MAX_CHAR, this->Team);
}

void Wagon::nameset(const char newname[])
{
	if (Name)
	{
		delete[] Name;
	}

	Name = new char[strlen(newname) + 1];
	strcpy_s(Name, MAX_CHAR, newname);
}

void Wagon::teamset(const char newteam[])
{
	if (Team)
	{
		delete[] Team;
	}

	Team = new char[strlen(newteam) + 1];
	strcpy_s(Team, MAX_CHAR, newteam);
}

void Wagon::weightset(float Weight)
{
	this->Weight = Weight;
}

void Wagon::animalsset(float Animals)
{
	this->Animals = Animals;
}

float Wagon::weightget() const
{
	return Weight;
}

float Wagon::animalsget() const
{
	return Animals;
}

void Wagon::wagonget()
{
	char            Name[MAX_CHAR];
	char            Team[MAX_CHAR];
	float           Weight;
	float           Animals;

	cin.clear();
	cout << "Please enter your wagon's family name: ";
	cin.get(Name, MAX_CHAR, '\n');
	cin.ignore();

	cout << "Please enter your wagon's team: ";
	cin.get(Team, MAX_CHAR, '\n');
	cin.ignore();

	cout << "Please enter your wagon's weight: ";
	cin >> Weight;

	while (cin.fail())
	{
		cin.clear();
		cin.ignore(4, '\n');
		cout << "You have entered an invalid character, Please try again: ";
		cin >> Weight;
		cin.ignore(4, '\n');
	}

	cin.clear();
	cout << "Please enter the number of animals on your team: ";
	cin >> Animals;

	while (cin.fail())
	{
		cin.clear();
		cin.ignore(3, '\n');
		cout << "You have entered an invalid character, Please try again: ";
		cin >> Animals;
		cin.ignore(3, '\n');
	}

	cin.clear();
	nameset(Name);
	teamset(Team);
	weightset(Weight);
	animalsset(Animals);
}

void Wagon::operator=(const Wagon& wagon)
{
	if (this == &wagon)
	{
		return;
	}

	nameset(wagon.Name);
	teamset(wagon.Team);
	weightset(wagon.Weight);
	animalsset(wagon.Animals);
}

[theleonicking]

	Boyd|3300|Oxen|2
	Cary|7806|Oxen|4
	Barker|4707|Horse|4
	Boggus|4700|Oxen|2
	Bond|3600|Horse|4
	Applegate|5522|Oxen|4
	Burnett|3700|Horse|4
	Arthur|2219|Oxen|2
	Adams|4505|Oxen|4
	Aiken|6205|Oxen|4
	Beagle|6666|Oxen|4

[salem c]

char* Name;
char* Team;

Why are you not using std::string for these?

Most of your usage of char pointers inside your Wagon class are broken in one way or another.

this->Name = new char[strlen(Name) + 1];
	this->Team = new char[strlen(Team) + 1];
	strcpy_s(this->Name, MAX_CHAR, Name);
	strcpy_s(this->Team, MAX_CHAR, Team);

"safe" functions are only safe when you're honest about buffer sizes.

Wagon::Wagon(const Wagon& wagon)
{
	this->Name = nullptr;
	this->Team = nullptr;
	*this = wagon;
}

You've implemented a 'shallow' copy. That is, you now have two Wagons with identical pointers to the same Name. The problem is, when you delete one of them, the other winds up with a stale pointer.
You need to do the whole 'new char...' thing and make an actual copy of each char pointer.
https://stackoverflow.com/questions/184710/what-is-the-difference-between-a-deep-copy-and-a-shallow-copy

void Wagon::nameget(char Name[]) const
{
	strcpy_s(Name, MAX_CHAR, this->Name);
}

Pass the size of the buffer as well, and use that size in your strcpy_s

There are some things about your head/tail pointer list usage which seem off as well.
I would suggest you make specific functions just to manage the insertion of a Node into your list, rather than burying it in the flow of some other functionality