#include <iostream>
#include <Windows.h>

int main() {
	int temp;
	std::cin>>temp;
	system("pause");
}

enum Result {
	IsSmaller= 0,
	IsBigger= 1,
	IsEqual= 2
};

class Data {
public:
	Data() { pData = rand(); }
	Data Compare(Data const &);
	int getData() { return pData; }
private:
	int pData;
}

Data::Compare(Data const & other) {
	if(other.pData > pData)
		return IsBigger;
	if(other.pData < pData)
		return IsSmaller;

	if(other.pData == pData)
		return IsEqual;
}
class Node :public Data {
	virtual void Show();
private:
	Data * MyData;
};

class LinkedList {
	LinkedList();
	~LinkedList() {}
};

class TailNode :public Node {
	TailNode();
};

TailNode::TailNode() {

}


class HeadNode :public Node {
public:
	HeadNode();
private:
	Node * MyNext;
};

HeadNode::HeadNode() {
	MyNext = TailNode * MyTail = new TailNode();
}

LinkedList::LinkedList() {
	HeadNode * MyHead = new HeadNode();
}



class Internal :public Node {
	Internal(Data const &, Node * next);
	void Insert(Data const *);

private:
	Data * MyData;
	Node * MyNext;
};

//What is the overloaders!!?!
//Compare.  Result = Functions.
Internal::Insert(Data & other) {	
	//WRONG HAS TO BE!
	switch(MyData->Compare(other.pData))
		case(IsSmaller):

		case(IsBigger):

		case(IsEqual):
}

Internal::Internal(Data const & other, Node * next) {
	MyData = other.getData;
	MyNext = next;
}

[source=c++] #include <iostream>#include <Windows.h>class TailNode;class HeadNode;int main() {	int temp;	std::cin>>temp;	system("pause");}enum {	IsSmaller= 0,	IsBigger= 1,	IsEqual= 2};class Data {public:	Data() { pData = rand(); }	int Compare(Data const &);	int getData() { return pData; }	int pData;};int Data::Compare(Data const & other) {	if(other.pData > pData)		return IsBigger;	if(other.pData < pData)		return IsSmaller;	else		return IsEqual;}class Node  {public:	virtual void Show();	virtual Node * Insert(Data * theData)=0;private:	Data * MyData;};class LinkedList {public:	LinkedList();	~LinkedList() {;}private:	HeadNode * MyHead;};class TailNode :public Node {public:	TailNode();};TailNode::TailNode() { ;}class HeadNode :public Node {public:	HeadNode();private:	Node * MyNext;};HeadNode::HeadNode() {  MyNext = new TailNode(); }LinkedList::LinkedList() { MyHead = new HeadNode(); }class Internal :public Node {public:	Internal(Data const &, Node * next);	virtual void Insert(Data const *);private:	Data * MyData;	Node * MyNext;};//What is the overloaders!!?!//Compare.  Result = Functions.void Internal::Insert(Data const * other) {	//WRONG HAS TO BE!	int x = MyData->Compare(*other);	switch(x)  {  		case(IsSmaller):			//Pass not MY cup of tea			MyNext->Insert(*other);		case(IsBigger):			Internal * dataNode = new Internal(*other,this);		case(IsEqual):			; //break	}}Internal::Internal(Data const & other, Node * next) {	MyData->pData = other.getData();	MyNext = next;}

//In other words...int x = 2;switch(x) {    case 1: cout<<"1st Case ";    case 2: cout<<"2nd Case ";    case 3: cout<<"3rd Case ";    default: cout<<"NOT FOUND";}//Outputs this...//2nd Case 3rd Case NOT FOUND////What you want is this....int x = 2;switch(x) {    case 1: cout<<"1st Case ";            break;    case 2: cout<<"2nd Case ";            break;    case 3: cout<<"3rd Case ";            break;    default: cout<<"NOT FOUND";}//Which outputs this...//2nd Case

class A: public B {};