재생목록만들기, 최근추가목록 완성

+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 15
+VisualStudioVersion = 15.0.28010.2036
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Project", "Project\Project.vcxproj", "{488DFF6D-08D7-40A9-B10D-AE7374047D99}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Debug|x86 = Debug|x86
+		Release|x64 = Release|x64
+		Release|x86 = Release|x86
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{488DFF6D-08D7-40A9-B10D-AE7374047D99}.Debug|x64.ActiveCfg = Debug|x64
+		{488DFF6D-08D7-40A9-B10D-AE7374047D99}.Debug|x64.Build.0 = Debug|x64
+		{488DFF6D-08D7-40A9-B10D-AE7374047D99}.Debug|x86.ActiveCfg = Debug|Win32
+		{488DFF6D-08D7-40A9-B10D-AE7374047D99}.Debug|x86.Build.0 = Debug|Win32
+		{488DFF6D-08D7-40A9-B10D-AE7374047D99}.Release|x64.ActiveCfg = Release|x64
+		{488DFF6D-08D7-40A9-B10D-AE7374047D99}.Release|x64.Build.0 = Release|x64
+		{488DFF6D-08D7-40A9-B10D-AE7374047D99}.Release|x86.ActiveCfg = Release|Win32
+		{488DFF6D-08D7-40A9-B10D-AE7374047D99}.Release|x86.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {13F536C0-2A1C-46D1-AC75-9315EF6D367F}
+	EndGlobalSection
+EndGlobal

+#pragma once
+#include<string>
+using namespace std;
+#include"SimplifiedType.h"
+#include"SortedLinkedList.h"
+
+class AlbumType {
+public:
+
+	AlbumType()
+	{
+		AlbumName = "";
+		ArtistName = "";
+	}		//기본 생성자
+	~AlbumType()
+	{
+		
+	}		//기본 소멸자
+	/**
+*	@brief	AlbumType의 생성자이다.
+*	@pre	x
+*	@post	AlbumType이 생성된다.
+	@param albumname 앨범명
+	@param artistname 이 앨범을 낸 아티스트명
+*/
+	AlbumType(string albumname, string artistname)
+	{
+		AlbumName = albumname;
+		ArtistName = artistname;
+	}
+	AlbumType(const AlbumType& data)
+	{
+		AlbumName = data.AlbumName;
+		ArtistName = data.ArtistName;
+	}
+	/**
+*	@brief AlbumName 을 set한다.
+*	@pre	x
+*	@post	AlbumName is set
+*	@return	x
+*/
+	void SetAlbumName(string Name)
+	{
+		AlbumName = Name;
+	};
+	/**
+*	@brief	ArtistName을 set한다.
+*	@pre	x
+*	@post	ArtistName is set
+*	@return	x
+*/
+	void SetArtistName(string Name)
+	{
+		ArtistName = Name;
+	};
+	/**
+*	@brief get AlbumName
+*	@pre	AlbumName is set
+*	@post	x
+*	@return	AlbumName
+*/
+	string GetAlbumName()
+	{ 
+		return AlbumName;
+	};
+	/**
+*	@brief	getArtistName
+*	@pre	ArtistName is set
+*	@post	x	
+*	@return	ArtistName
+*/
+	string GetArtistName() 
+	{
+		return ArtistName; 
+	};
+	/**
+*	@brief	비교 연산자
+*	@pre	비교하려는 두 앨범타입이 초기화되어 있어야한다
+*	@post	x
+*	@param	data 비교하려는 앨범타입
+*	@return	좌변이크면 false, 우변이크면 true
+*/
+	bool operator<(AlbumType data)
+	{
+		if (AlbumName == data.GetAlbumName())
+			return (ArtistName < data.GetArtistName());
+		else
+			return (AlbumName < data.GetAlbumName());
+	};
+	/**
+*	@brief	비교 연산자
+*	@pre	비교하려는 두 앨범타입이 초기화되어 있어야한다
+*	@post	x
+*	@param	data 비교하려는 앨범타입
+*	@return	좌변이크면 true, 우변이크면 false
+*/
+	bool operator>(AlbumType data)
+	{
+		if (AlbumName == data.GetAlbumName())
+			return (ArtistName > data.GetArtistName());
+		else
+			return (AlbumName > data.GetAlbumName());
+	};
+	/**
+*	@brief	등위연산자 
+*	@pre	비교하려는 두 앨범타입이 초기화되어 있어야한다
+*	@post	x
+*	@param	data 비교하려는 앨범타입
+*	@return	두 항이 같으면 true 아니면 false
+*/
+	bool operator==(AlbumType data) {
+		if (AlbumName == data.GetAlbumName() && ArtistName == data.GetArtistName())
+			return true;
+		else
+			return false;
+	};
+private:
+	string AlbumName; //앨범 이름을 저장할 변수
+	string ArtistName; //앨범의 아티스트를 저장할 변수
+
+};

+#include"Application.h"
+
+
+
+// Program driver.
+void Application::Run()
+{
+	while (1)
+	{
+		m_Command = GetCommand();
+
+		switch (m_Command)
+		{
+		case 1:		// read a record and add to list.
+			AddMusic();
+			break;
+		case 2:		// display all the records in list on screen.
+			Delete();
+			break;
+		case 3:
+			Update();
+			break;
+		case 4:	//곡명으로 검색
+			RetreiveRecordByName();
+			break;
+		case 5:	//가수명으로 검색
+			RetreiveRecordBySinger();
+			break;
+		case 6:	//앨범명으로 검색
+			RetreiveRecordByAlbum();
+			break;
+		case 7:	//장르로 검색
+			RetreiveRecordByGenre();
+			break;
+		case 8:		// load list data from a file.
+			DisplayAllMusic();
+			break;
+		case 9:
+			DIsplayNewMusic();
+			break;
+		case 10:
+			DisplayMusicbyGenre();
+			break;
+		case 11:
+			RetreiveRecordByNameNGenre();
+			break;
+		case 12:
+			DisplayMusicByAlbum();
+			break;
+		case 13:
+			DisplayMusicByArtist();
+			break;
+		case 20:
+			makePlayList();
+			break;
+		case 21:
+			AddMusicInPL();
+			break;
+		case 22:
+			PrintPL();
+			break;
+		case 98:
+			ReadDataFromFile();
+			break;
+		case 99:
+			WriteDataToFile();
+		case 0:
+			return;
+		default:
+			cout << "\tIllegal selection...\n";
+			break;
+		}
+	}
+}
+
+
+// Display command on screen and get a input from keyboard.
+int Application::GetCommand()
+{
+	int command;
+	cout << endl << endl;
+	cout << "\t---ID -- Command ----- " << endl;
+	cout << "\t   1 : Add Music" << endl;
+	cout << "\t   2 : Delete Music" << endl;
+	cout << "\t   3 : Replace Music" << endl;
+	cout << "\t   4 : Search by Song Name" << endl;
+	cout << "\t   5 : Search by Artist(Singer)" << endl;
+	cout << "\t   6 : Search by Album" << endl;
+	cout << "\t   7 : Search by Genre" << endl;
+	cout << "\t   8 : Display all Music" << endl;
+	cout << "\t   9 : Display New Music" << endl;
+	cout << "\t   10 : Display Music by Genre" << endl;
+	cout << "\t   11 : search by Name and Genre" << endl;
+	cout << "\t   12 : Display Music by Album" << endl;
+	cout << "\t   13 : Display Music by Artist" << endl;
+	cout << "\t   20 : 재생목록 만들기" << endl;
+	cout << "\t   21 : 재생목록에 추가하기" << endl;
+	cout << "\t   22 : 재생목록 보기" << endl;
+	cout << "\t   30 : 재생하기" << endl;
+	cout << "\t   98 : Get from file" << endl;
+	cout << "\t   99 : Put to file " << endl;
+	cout << "\t   0 : Quit" << endl;
+
+	cout << endl << "\t Choose a Command--> ";
+	cin >> command;
+	cout << endl;
+
+	return command;
+}
+
+
+// Add new record into list.
+int Application::AddMusic()
+{
+	string genre;	//장르를 저장할 임시변수
+	string name;	//곡명을 저장할 임시변수
+	MusicType item;
+	SimplifiedType Simpletype;	//곡번호, 곡명만 저장할 타입
+	item.SetInfoFromKB();
+	m_List.Add(item);		//MusicList에 원소 추가
+	RemakeSubList();		//MusicList에 변화가 생겼으므로 하위 리스트들을 다시 만들어줘야 한다.
+	SetMusicIndex();		//MusicList에 변화가 생겼으므로 Index를 다시 부여한다.
+	DoublyIter<MusicType> Miter(m_List);
+	ManageType mgitem;
+	while (Miter.NotNull())
+	{
+		if (Miter.GetCurrentNode().data == item)
+		{
+			mgitem.setIndex(Miter.GetCurrentNode().data.GetNum());
+		}
+		Miter.Next();
+	}
+	mgitem.setName(item.GetName());
+	mgitem.setPkey(item.GetPkey());
+	mgitem.setArtist(item.GetSinger());
+	mg_List.Add(mgitem);
+
+	//최근 추가목록에 추가하기
+	/*
+
+
+
+	Simpletype.SetRecord(num, name);
+	if (!AddRecentlyMusicList.IsFull())		//최근 추가된목록이 가득차지 않았을경우
+		AddRecentlyMusicList.EnQueue(Simpletype);			//큐에 하나 추가
+	else									//최근 추가된목록이 30개 꽉 찼을경우
+	{
+		SimplifiedType S_temp;
+		AddRecentlyMusicList.DeQueue(S_temp);		//하나를 지우고
+		AddRecentlyMusicList.EnQueue(Simpletype);	//방금 추가된 레코드를 집어넣는다
+	}
+	*/
+	// 현재 list 출력
+	DisplayAllMusic();
+
+	return 1;
+}
+
+
+// Display all records in the list on screen.
+void Application::DisplayAllMusic()
+{
+	DoublyIter<MusicType> iter(m_List);
+	cout << "\n\tCurrent list" << endl;
+
+	// list의 모든 데이터를 화면에 출력
+	while (iter.NotNull())
+	{
+		iter.GetCurrentNode().data.DisplayRecordOnScreen();
+		iter.Next();
+
+	}
+
+}
+
+
+
+//찾을 ID를 사용자에게 입력받고 SortedList의 Delete함수를 호출한다.
+void Application::Delete()
+{
+	cout << "\t지울 : ";
+	MusicType data;	//Delete함수는 MusicType을 파라미터로 갖기 때문에 임의로 만들어준다.
+	data.SetNumFromKB();	//사용자에게서 곡 번호를 입력받는다.
+	SearchByIndex(data);
+
+	if (m_List.Delete(data))	//Delete함수에 data를 넘겨준다.
+	{
+		cout << "\t삭제를 완료했습니다." << endl;	//삭제에 성공했으면 메시지를 출력한다.
+		RemakeSubList();		//MusicList에 변화가 생겼으므로 하위 리스트들을 다시 만들어줘야 한다.
+		if (m_List.GetLength() != 0)		//길이가 0이면 인덱스를 부여할수 없다.
+		{
+			SetMusicIndex();//MusicList에 변화가 생겼으므로 Index를 다시 부여한다.
+		}
+	}
+	else
+		cout << "\t삭제하지 못했습니다. 일치하는 항목을 찾을 수 없습니다." << endl;	//삭제에 실패했으면 메시지를 출력한다.
+
+
+}
+
+
+//찾을 ID를 사용자에게 입력받고 SortedList의 Update함수를 호출한다.
+void Application::Update()
+{
+	cout << "\t변경을 원하는 항목의 ";
+	MusicType data;	//Replace함수는 MusicType을 파라미터로 갖기 때문에 임의로 만들어준다.
+	data.SetNumFromKB();	//사용자에게서 수정할 항목의 곡 번호를 입력받는다.
+	SearchByIndex(data);
+	if (!m_List.Get(data))	//사용자가 입력한 항목이 List에 있나 검색
+	{
+		cout << "\t항목을 찾을 수 없습니다." << endl;		//찾을 수 없을때 메시지를 출력한다.
+		return;
+	}
+	else	//찾을 수 있을때
+	{
+		data.SetNameFromKB(); //사용자에게서 곡명을 입력받는다.
+		data.SetSingerFromKB();	//사용자에게서 가수를 입력받는다.
+		data.SetAlbumFromKB();	//사용자에게서 앨범을 입력받는다.
+		data.SetGenreFromKB();  //사용자에게서 장르를 입력받는다.
+		data.SetLyricsFromKB(); // 사용자에게서 가사를 입력받는다.
+		if (m_List.Delete(data))//기존 항목을 삭제하고
+		{
+			data.SetPkey();	//데이터를 변경했으므로 Pkey를 다시 지정해준다.
+			m_List.Add(data);
+			cout << "\t수정을 완료했습니다." << endl;	//수정을 성공했을 때 메시지를 출력한다.
+			RemakeSubList();		//MusicList에 변화가 생겼으므로 하위 리스트들을 다시 만들어줘야 한다.
+			if (m_List.GetLength() != 0)		//길이가 0이면 인덱스를 부여할수 없다.
+			{
+				SetMusicIndex();//MusicList에 변화가 생겼으므로 Index를 다시 부여한다.
+			}
+		}
+		else
+			cout << "\t수정을 실패했습니다." << endl;	//수정에 실패했을 때 메시지를 출력한다.
+	}
+
+}
+//사용자에게 찾고자하는 Name을 입력받고 넘겨주는 역할을 한다.
+void Application::RetreiveRecordByName()
+{
+	MusicType temp;
+	cout << "\t찾을 ";
+	temp.SetNameFromKB();	//SearchByName함수에 넘겨줄 temp의 Name을 사용자에게 입력받는다.
+	SearchByName(temp);	//실질적으로 찾는 동작을 하는 SearchByName함수를 호출하고 temp값을 넘겨준다.
+}
+
+
+//사용자가 찾고자하는 Name을 포함하는 inData로 m_List의 항목들 중 일치하는 항목을 찾고 출력해준다. **프로그램에 전반적으로 Array에 index를 직접 접근하는 방법을 선호했으나 이 함수는 Application 클래스의 메소드이므로 GetNextItem함수를 이용해 iteration을 이용했습니다.
+void Application::SearchByName(MusicType &inData)
+{
+	MusicType temp;	//m_List의 값을 비교해주기 위한 임시 MusicType.
+	DoublyIter<MusicType> iter(m_List);
+	int count = 0;
+	while (iter.NotNull())
+	{
+		if (iter.GetCurrentNode().data.GetName().find(inData.GetName()) != -1)
+		{
+			iter.GetCurrentNode().data.DisplayRecordOnScreen();
+			count++;
+		}
+		iter.Next();
+	}
+
+
+
+
+	if (count == 0)
+		cout << "\t찾을 수 없습니다." << endl;	//찾은 개수가 0개이면 찾을 수 없다는 메시지를 출력한다.
+}
+
+//사용자에게 찾고자하는 Singer을 입력받고 넘겨주는 역할을 한다.
+void Application::RetreiveRecordBySinger()
+{
+	MusicType temp;
+	cout << "\t찾을 ";
+	temp.SetSingerFromKB();	//SearchBySinger함수에 넘겨줄 temp의 Name을 사용자에게 입력받는다.
+	SearchBySinger(temp);	//실질적으로 찾는 동작을 하는 SearchBySinger함수를 호출하고 temp값을 넘겨준다.
+}
+
+
+//사용자가 찾고자하는 Singer을 포함하는 inData로 m_List의 항목들 중 일치하는 항목을 찾고 출력해준다. **프로그램에 전반적으로 Array에 index를 직접 접근하는 방법을 선호했으나 이 함수는 Application 클래스의 메소드이므로 GetNextItem함수를 이용해 iteration을 이용했습니다.
+void Application::SearchBySinger(MusicType &inData)
+{
+	MusicType temp;	//m_List의 값을 비교해주기 위한 임시 MusicType.
+	DoublyIter<MusicType> iter(m_List);
+	int count = 0;
+	while (iter.NotNull())
+	{
+		if (iter.GetCurrentNode().data.GetSinger().find(inData.GetSinger()) != -1)
+		{
+			iter.GetCurrentNode().data.DisplayRecordOnScreen();
+			count++;
+		}
+		iter.Next();
+	}
+	if (count == 0)
+		cout << "\t찾을 수 없습니다." << endl;	//찾은 개수가 0개이면 찾을 수 없다는 메시지를 출력한다.
+}
+
+//사용자에게 찾고자하는 Album을 입력받고 넘겨주는 역할을 한다.
+void Application::RetreiveRecordByAlbum()
+{
+	MusicType temp;
+	cout << "\t찾을 ";
+	temp.SetAlbumFromKB();	//SearchByAlbum함수에 넘겨줄 temp의 Album을 사용자에게 입력받는다.
+	SearchByAlbum(temp);	//실질적으로 찾는 동작을 하는 SearchByAlbum함수를 호출하고 temp값을 넘겨준다.
+}
+
+
+//사용자가 찾고자하는 Album을 포함하는 inData로 m_List의 항목들 중 일치하는 항목을 찾고 출력해준다. **프로그램에 전반적으로 Array에 index를 직접 접근하는 방법을 선호했으나 이 함수는 Application 클래스의 메소드이므로 GetNextItem함수를 이용해 iteration을 이용했습니다.
+void Application::SearchByAlbum(MusicType &inData)
+{
+	if (m_List.IsEmpty() == true)
+	{
+		cout << "리스트에 아무것도 없습니다." << endl;
+		return;
+	}
+	MusicType temp;	//m_List의 값을 비교해주기 위한 임시 MusicType.
+	DoublyIter<MusicType> iter(m_List);
+	int count = 0;
+	while (iter.NotNull())
+	{
+		if (iter.GetCurrentNode().data.GetAlbum().find(inData.GetAlbum()) != -1)
+		{
+			iter.GetCurrentNode().data.DisplayRecordOnScreen();
+			count++;
+		}
+		iter.Next();
+	}
+	if (count == 0)
+		cout << "\t찾을 수 없습니다." << endl;	//찾은 개수가 0개이면 찾을 수 없다는 메시지를 출력한다.
+}
+//사용자에게 찾고자하는 Genre을 입력받고 넘겨주는 역할을 한다.
+void Application::RetreiveRecordByGenre()
+{
+	MusicType temp;
+	cout << "\t찾을 ";
+	temp.SetGenreFromKB();	//SearchByGenre함수에 넘겨줄 temp의 Genre을 사용자에게 입력받는다.
+	SearchByGenre(temp);	//실질적으로 찾는 동작을 하는 SearchByGenre함수를 호출하고 temp값을 넘겨준다.
+}
+
+
+//사용자가 찾고자하는 Genre을 포함하는 inData로 m_List의 항목들 중 일치하는 항목을 찾고 출력해준다. **프로그램에 전반적으로 Array에 index를 직접 접근하는 방법을 선호했으나 이 함수는 Application 클래스의 메소드이므로 GetNextItem함수를 이용해 iteration을 이용했습니다.
+void Application::SearchByGenre(MusicType &inData)
+{
+	if (m_List.IsEmpty() == true)
+	{
+		cout << "리스트에 아무것도 없습니다." << endl;
+		return;
+	}
+	MusicType temp;	//m_List의 값을 비교해주기 위한 임시 MusicType.
+	DoublyIter<MusicType> iter(m_List);
+	int count = 0;
+	while (iter.NotNull())
+	{
+		if (iter.GetCurrentNode().data.GetGenre().find(inData.GetGenre()) != -1)
+		{
+			iter.GetCurrentNode().data.DisplayRecordOnScreen();
+			count++;
+		}
+		iter.Next();
+	}
+	if (count == 0)
+		cout << "\t찾을 수 없습니다." << endl;	//찾은 개수가 0개이면 찾을 수 없다는 메시지를 출력한다.
+}
+
+// Open a file by file descriptor as an input file.
+int Application::OpenInFile(char *fileName)
+{
+	m_InFile.open(fileName);	// file open for reading.
+
+	// 파일 오픈에 성공하면 1, 그렇지 않다면 0을 리턴.
+	if (!m_InFile)	return 0;
+	else	return 1;
+}
+
+
+// Open a file by file descriptor as an output file.
+int Application::OpenOutFile(char *fileName)
+{
+	m_OutFile.open(fileName);	// file open for writing.
+
+	// 파일 오픈에 성공하면 1, 그렇지 않다면 0을 리턴.
+	if (!m_OutFile)	return 0;
+	else	return 1;
+}
+
+
+// Open a file as a read mode, read all data on the file, and set list by the data.
+int Application::ReadDataFromFile()
+{
+
+	MusicType data;	// 읽기용 임시 변수
+	ifstream ReadData;
+	ReadData.open("text.txt");
+	string OneLine;
+	while (getline(ReadData, OneLine))
+	{
+		istringstream L(OneLine);
+		string name, singer, Album, Genre, Lyrics;
+		L >> name;
+		L >> singer;
+		L >> Album;
+		L >> Genre;
+		L >> Lyrics;
+		data.SetRecord(name, singer, Album, Genre, Lyrics);
+		m_List.Add(data);
+	}
+	/*
+	char fileName[FILENameSIZE];
+	cout << "\n\tEnter Input file Name : ";
+	cin >> fileName;
+
+	// file open, open error가 발생하면 0을 리턴
+	if (!OpenInFile(fileName))
+		return 0;
+
+	// 파일의 모든 내용을 읽어 list에 추가
+	while (!m_InFile.eof())
+	{
+		// array에 학생들의 정보가 들어있는 structure 저장
+		data.ReadDataFromFile(m_InFile);
+		m_List.Add(data);
+	}
+
+	m_InFile.close();	// file close
+	*/
+	SetMusicIndex();
+	// 현재 list 출력
+	DisplayAllMusic();
+
+	return 1;
+}
+
+
+// Open a file as a write mode, and write all data into the file,
+int Application::WriteDataToFile()
+{
+
+	m_OutFile.close();	// file close
+
+	return 1;
+}
+
+//최근 추가된 30곡 출력
+void Application::DIsplayNewMusic()
+{
+
+	if (m_List.IsEmpty() == true)
+	{
+		cout << "리스트에 아무것도 없습니다." << endl;
+		return;
+	}
+	int cnt = 0;
+	DoublyIter2<ManageType> Mgiter(mg_List);
+	Mgiter.Last();
+	while (Mgiter.NotNull() && cnt < 30)
+	{
+		Mgiter.GetCurrentNode().data.PrintNameNIndex();
+		Mgiter.Prev();
+		cnt++;
+	}
+
+
+
+
+
+}
+
+bool Application::Search(int key, MusicType& inData)
+{
+	inData.SetNum(key);
+	if (m_List.Get(inData))
+		return true;
+
+	else
+		return false;
+}
+//Display Music by genre through genre list
+void Application::DisplayMusicbyGenre()
+{
+	if (m_List.GetLength() == 0)
+		return;
+	if (RemakeGenreList == true)
+	{
+		GenreList.MakeEmpty();	//기존의 리스트를 비운다
+		DoublyIter<MusicType> Miter(m_List);
+		while (Miter.NotNull())
+		{
+			string thisGenre;
+			thisGenre = Miter.GetCurrentNode().data.GetGenre();
+			GenreList.Add(thisGenre);
+			Miter.Next();
+		}		//이 반복문이 끝나면 장르리스트에 장르가 정렬되어 들어감
+	}
+	RemakeGenreList = false;			//리스트를 다시 만들었으므로 변경이 없으면 다시 만들필요가 없다
+
+	//아래는 출력하는 코드
+	DoublyIter<string> Giter(GenreList);
+	string thisGenre;
+	while (Giter.NotNull())
+	{
+		thisGenre = Giter.GetCurrentNode().data;
+		DoublyIter<MusicType> Miter2(m_List);
+		cout << "\t장르 : " << Miter2.GetCurrentNode().data.GetGenre() << endl;
+		while (Miter2.NotNull())
+		{
+
+			if (thisGenre == Miter2.GetCurrentNode().data.GetGenre())
+			{
+				cout << "트랙넘버 : " << Miter2.GetCurrentNode().data.GetName() << endl;
+				cout << "곡명 : " << Miter2.GetCurrentNode().data.GetName() << endl;
+			}
+			Miter2.Next();
+		}
+		cout << "\t -------------------------" << endl;
+		Giter.Next();
+	}
+
+
+
+}
+
+
+
+//name 과 genre 정보를 받아 Search함수에 넘긴다.
+void Application::RetreiveRecordByNameNGenre()
+{
+	MusicType temp;
+	cout << "\t찾을 ";
+	temp.SetNameFromKB();
+	temp.SetGenreFromKB();	//SearchByGenre함수에 넘겨줄 temp의 Genre을 사용자에게 입력받는다.
+	SearchByNameNGenre(temp);	//실질적으로 찾는 동작을 하는 SearchByGenre함수를 호출하고 temp값을 넘겨준다.
+
+
+}
+
+void Application::SearchByNameNGenre(MusicType& inData)
+{
+	if (m_List.IsEmpty() == true)
+	{
+		cout << "리스트에 아무것도 없습니다." << endl;
+		return;
+	}
+	MusicType temp;	//m_List의 값을 비교해주기 위한 임시 MusicType.
+	DoublyIter<MusicType> iter(m_List);
+	int count = 0;
+	while (iter.NotNull())
+	{
+		if (iter.GetCurrentNode().data.GetName().find(inData.GetName()) != -1 && iter.GetCurrentNode().data.GetGenre().find(inData.GetGenre()) != -1)
+		{
+			iter.GetCurrentNode().data.DisplayRecordOnScreen();
+			count++;
+		}
+		iter.Next();
+	}
+	if (count == 0)
+		cout << "\t찾을 수 없습니다." << endl;	//찾은 개수가 0개이면 찾을 수 없다는 메시지를 출력한다.
+
+
+}
+
+void Application::DisplayMusicByAlbum()
+{
+
+	if (m_List.GetLength() == 0)
+		return;
+	//쉽게 구현하기
+	if (RemakeAlbumList == true)		//앨범 리스트를 다시만들어야 하는가
+	{
+		AlbumList.MakeEmpty();
+		DoublyIter<MusicType> Miter(m_List);
+		while (Miter.NotNull())
+		{
+			AlbumType thisAlbum(Miter.GetCurrentNode().data.GetAlbum(), Miter.GetCurrentNode().data.GetSinger());
+			AlbumList.Add(thisAlbum);
+			Miter.Next();
+		}
+	}
+	RemakeAlbumList = false;		//리스트를 갱신했으므로 다시만들 필요가 없다.
+	//여기서부터는 출력코드
+
+
+	DoublyIter<AlbumType> Abiter(AlbumList);
+	while (Abiter.NotNull())
+	{
+		DoublyIter<MusicType> Miter2(m_List);
+		cout << "\t앨범명 : " << Abiter.GetCurrentNode().data.GetAlbumName() << endl;
+		cout << "\t아티스트명 : " << Abiter.GetCurrentNode().data.GetArtistName() << endl;
+		while (Miter2.NotNull())
+		{
+
+			if (Miter2.GetCurrentNode().data.GetAlbum() == Abiter.GetCurrentNode().data.GetAlbumName() && Miter2.GetCurrentNode().data.GetSinger() == Abiter.GetCurrentNode().data.GetArtistName())
+			{
+				cout << "\t트랙넘버 : " << Miter2.GetCurrentNode().data.GetName() << endl;
+				cout << "\t곡명 : " << Miter2.GetCurrentNode().data.GetName() << endl;
+
+			}
+			Miter2.Next();
+		}
+		cout << "\t-------------------------" << endl;
+		Abiter.Next();
+	}
+
+
+
+
+
+
+}
+
+void Application::DisplayMusicByArtist()
+{
+	if (m_List.GetLength() == 0)
+		return;
+	if (RemakeArtistList == true)		//아티스트 리스트를 다시 만들어야 하는가
+	{
+		ArtistList.MakeEmpty();
+		AlbumList.MakeEmpty();		//아티스트 리스트와 앨범리스트를 비운다
+		DoublyIter<MusicType> Miter(m_List);
+		while (Miter.NotNull())
+		{
+			ArtistType thisArtist;
+			thisArtist.SetArtistName(Miter.GetCurrentNode().data.GetSinger());
+			ArtistList.Add(thisArtist);
+			Miter.Next();
+		}//아티스트리스트에 아티스트가 정렬되어 삽입된다.	
+
+
+		DoublyIter<MusicType> Miter2(m_List);
+		while (Miter2.NotNull())
+		{
+			AlbumType thisAlbum(Miter2.GetCurrentNode().data.GetAlbum(), Miter2.GetCurrentNode().data.GetSinger());
+			AlbumList.Add(thisAlbum);
+			Miter2.Next();
+		}
+		//AlbumList에 앨범추가됨
+
+		DoublyIter<AlbumType> Abiter(AlbumList);			//앨범을 해당 앨범과 같은 아티스트를 가진 아티스트 타입의 리스트에 추가한다.
+		while (Abiter.NotNull())
+		{
+			DoublyIter<ArtistType> Atiter(ArtistList);
+			while (Atiter.NotNull())
+			{
+				if (Atiter.GetCurrentNode().data.GetArtistName() == Abiter.GetCurrentNode().data.GetArtistName())
+				{
+					ArtistType* temp;
+					temp = Atiter.GetCurrentPtr();
+					AlbumType thisAlbum = Abiter.GetCurrentNode().data;
+					temp->AddListinList(thisAlbum);
+				}
+				Atiter.Next();
+			}
+			Abiter.Next();
+		}
+
+
+	}
+	RemakeArtistList = false;	//리스트를 갱신했으므로 다시만들 필요가 없다.
+	//여기서부턴 출력코드
+	DoublyIter<ArtistType> Atiter2(ArtistList);
+	while (Atiter2.NotNull())
+	{
+		ArtistType *Atptr;
+		Atptr = Atiter2.GetCurrentPtr();
+		Atptr->PrintListinList();
+		Atiter2.Next();
+	}
+
+
+
+}
+void Application::SetMusicIndex()
+{
+	int Index = 1;
+	DoublyIter<MusicType> Miter(m_List);
+
+	while (Miter.NotNull())
+	{
+		MusicType* Mptr;
+		Mptr = Miter.GetCurrentPtr();
+		Mptr->SetNum(Index);
+		Index++;
+		Miter.Next();
+	}
+	//List의 끝까지 인덱스를 부여한다. 인덱스의 최대값은 MusicList의 길이이다.
+
+
+
+}
+void Application::SearchByIndex(MusicType &indata)
+{
+	DoublyIter<MusicType> Miter(m_List);
+	int Index = indata.GetNum();
+	while (Miter.NotNull())
+	{
+		if (Index == Miter.GetCurrentNode().data.GetNum())
+			Miter.GetCurrentNode().data.DisplayRecordOnScreen();
+		Miter.Next();
+	}
+
+
+}
+
+void Application::makePlayList()
+{
+	string N;
+	PLType PL;
+	cout << "재생목록 이름 :";
+	cin >> N;
+	PL.setPLname(N);
+	PlayLists.Add(PL);
+}
+
+
+void Application::AddMusicInPL()
+{
+	DoublyIter2<PLType> PLiter(PlayLists);
+	while (PLiter.NotNull())
+	{
+		cout << "재생목록명 : " << PLiter.GetCurrentNode().data.getPLname();
+		cout << endl;
+		PLiter.Next();
+	}
+	string N;
+	cout << "추가하고자 하는 재생목록 선택 : " << endl;
+	cin >> N;
+	DoublyIter2<PLType> PLiter2(PlayLists);
+	PLType* ptr;
+	while (PLiter2.NotNull())
+	{
+		if (PLiter2.GetCurrentNode().data.getPLname() == N)
+		{
+			ptr = PLiter2.GetCurrentPtr();
+			DisplayAllMusic();
+			int num = 1;
+			while (1)
+			{
+				cout << "추가하고자 하는 곡의 Index를 입력해주세요 0을 입력하면 그만 추가합니다" << endl;
+				cin >> num;
+				if (num > m_List.GetLength() || num == 0)
+					break;
+				DoublyIter2<ManageType> Mgiter(mg_List);
+				ManageType* mgPtr;
+				while (Mgiter.NotNull())
+				{
+					if (Mgiter.GetCurrentNode().data.getIndex() == num)
+					{
+						mgPtr = Mgiter.GetCurrentPtr();
+						ptr->AddListinList(mgPtr);
+					}
+					Mgiter.Next();
+				}
+
+			}
+		}
+		PLiter2.Next();
+	}
+
+}
+void Application::PrintPL()
+{
+	DoublyIter2<PLType> PLiter(PlayLists);
+	while (PLiter.NotNull())
+	{
+		cout << "재생목록명 : " << PLiter.GetCurrentNode().data.getPLname();
+		cout << endl;
+		PLiter.Next();
+	}
+	string N;
+	cout << "재생목록 선택 : " << endl;
+	cin >> N;
+	DoublyIter2<PLType> PLiter2(PlayLists);
+	PLType* ptr;
+	while (PLiter2.NotNull())
+	{
+		if (PLiter2.GetCurrentNode().data.getPLname() == N)
+		{
+			ptr = PLiter2.GetCurrentPtr();
+			ptr->Printall();
+			while (1)
+			{
+				int temp;
+				cout << "재생할 곡을 선택해주세요 0을 입력하면 재생목록에서 나갑니다" << endl;
+				cin >> temp;
+				if (temp == 0)
+					break;
+			}
+		}
+		PLiter2.Next();
+	}
+
+
+
+}
\ No newline at end of file

+
+#ifndef _APPLICATION_H
+#define _APPLICATION_H
+
+#include <iostream>
+#include <fstream>
+#include <string>
+#include<sstream>
+using namespace std;
+
+
+#include "MusicType.h"
+#include"SortedLinkedList.h"
+#include"GenreType.h"
+#include"AlbumType.h"
+#include"ArtistType.h"
+#include"ManageType.h"
+#include"UnSortedLinkedList.h"
+#include"PLType.h"
+#define FILENameSIZE 1024
+
+/**
+*	application class for item management simply.
+*/
+class Application
+{
+public:
+	/**
+	*	default constructor.
+	*/
+	Application()
+	{
+		m_Command = 0;
+		RemakeAlbumList = true;
+		RemakeArtistList = true;
+		RemakeGenreList = true;
+		NumofPL = 0;
+
+	}
+
+	/**
+	*	destructor.
+	*/
+	~Application()
+	{
+		DoublyIter<ArtistType> Atiter(ArtistList);
+		while (Atiter.NotNull())
+		{
+			ArtistType* Atptr = Atiter.GetCurrentPtr();
+			Atptr->MakeEmptyListinList();
+			Atiter.Next();
+		}
+		m_List.MakeEmpty();
+		GenreList.MakeEmpty();
+		AlbumList.MakeEmpty();
+	};
+
+	/**
+	*	@brief	Program driver.
+	*	@pre	program is started.
+	*	@post	program is finished.
+	*/
+	void Run();
+
+	/**
+	*	@brief	Display command on screen and get a input from keyboard.
+	*	@pre	none.
+	*	@post	none.
+	*	@return	user's command.
+	*/
+	int GetCommand();
+
+	/**
+	*	@brief	Add new record into list.
+	*	@pre	list should be initialized.
+	*	@post	new record is added into the list.
+	*	@return	return 1 if this function works well, otherwise 0.
+	*/
+	int AddMusic();
+
+	/**
+	*	@brief	Display all records in the list on screen.
+	*	@pre	none.
+	*	@post	none.
+	*/
+	void DisplayAllMusic();
+
+	/**
+	*	@brief	Open a file by file descriptor as an input file.
+	*	@pre	a file for reading is exist.
+	*	@post	open the file for reading.
+	*	@param	fileName	a fileName to open for reading.
+	*	@return	return 1 if this function works well, otherwise 0.
+	*/
+	int OpenInFile(char *fileName);
+
+	/**
+	*	@brief	Open a file by file descriptor as an output file.
+	*	@pre	list should be initialized.
+	*	@post	open the file for writing.
+	*	@param	fileName	a fileName to open for writing.
+	*	@return	return 1 if this function works well, otherwise 0.
+	*/
+	int OpenOutFile(char *fileName);
+
+	/**
+	*	@brief	Open a file as a read mode, read all data on the file, and set list by the data.
+	*	@pre	The file is not opened.
+	*	@post	list holds all records from the file.
+	*	@return	return 1 if this function works well, otherwise 0.
+	*/
+	int ReadDataFromFile();
+
+	/**
+	*	@brief	Open a file as a write mode, and write all data into the file,
+	*	@pre	The file is not opened.
+	*	@post	the list is stored in the output file.
+	*	@return	return 1 if this function works well, otherwise 0.
+	*/
+	int WriteDataToFile();
+
+	/**
+*	@brief	객체를 생성 후, 문자열을 입력받는다.
+*	@pre	없다.
+*	@post	SearchByName함수에 문자열이 설정된 객체를 전달한다.
+*	@return	없다.
+*/
+	void RetreiveRecordByName();
+
+	/**
+	*	@brief	inData의 이름 부분을 포함하는 문자열을 찾아 출력한다.
+	*	@pre	inData의 이름 부분이 초기화되어있어야 한다.
+	*	@post	inData에 알맞은 항목이 복사된다.
+	*	@param	inData	이름이 설정되어있고 나머지는 비어있는 Musictype
+	*	@return	없다.
+	*/
+	void SearchByName(MusicType &inData);
+
+	/**
+*	@brief	객체를 생성 후, 문자열을 입력받는다.
+*	@pre	없다.
+*	@post	SearchBySinger함수에 문자열이 설정된 객체를 전달한다.
+*	@return	없다.
+*/
+	void RetreiveRecordBySinger();
+
+	/**
+	*	@brief	inData의 이름 부분을 포함하는 문자열을 찾아 출력한다.
+	*	@pre	inData의 이름 부분이 초기화되어있어야 한다.
+	*	@post	inData에 알맞은 항목이 복사된다.
+	*	@param	inData	이름이 설정되어있고 나머지는 비어있는 Musictype
+	*	@return	없다.
+	*/
+	void SearchBySinger(MusicType &inData);
+
+
+	/**
+*	@brief	객체를 생성 후, 문자열을 입력받는다.
+*	@pre	없다.
+*	@post	SearchByAlbum함수에 문자열이 설정된 객체를 전달한다.
+*	@return	없다.
+*/
+	void RetreiveRecordByAlbum();
+
+	/**
+	*	@brief	inData의 이름 부분을 포함하는 문자열을 찾아 출력한다.
+	*	@pre	inData의 이름 부분이 초기화되어있어야 한다.
+	*	@post	inData에 알맞은 항목이 복사된다.
+	*	@param	inData	이름이 설정되어있고 나머지는 비어있는 Musictype
+	*	@return	없다.
+	*/
+	void SearchByAlbum(MusicType &inData);
+	/**
+*	@brief	객체를 생성 후, 문자열을 입력받는다.
+*	@pre	없다.
+*	@post	SearchByGenre함수에 문자열이 설정된 객체를 전달한다.
+*	@return	없다.
+*/
+	void RetreiveRecordByGenre();
+
+	/**
+	*	@brief	inData의 이름 부분을 포함하는 문자열을 찾아 출력한다.
+	*	@pre	inData의 이름 부분이 초기화되어있어야 한다.
+	*	@post	inData에 알맞은 항목이 복사된다.
+	*	@param	inData	이름이 설정되어있고 나머지는 비어있는 Musictype
+	*	@return	없다.
+	*/
+	void SearchByGenre(MusicType &inData);
+	/**
+	*	@brief	inData의 Index와 같은 Index를 가진 MusicList의 정보를 찾아온다
+	*	@pre	inData의 Index가 초기화 되어 있어야 한다.
+	*	@post	inData에 알맞은 항목이 복사된다.
+	*	@param	inData	Index가 설정되어있고 나머지는 비어있는 Musictype
+	*	@return	없다.
+	*/
+	
+	void SearchByIndex(MusicType &indata);
+	/**
+	*	@brief	사용자에게 Name을 입력받아 SortedList의 Delete함수에 넘겨주는 역할을 한다.
+	*	@pre	없다.
+	*	@post	사용자가 입력한 Name을 가지고 있는 Musictype이 m_List에서 사라진다.
+	*	@return	없다.
+	*/
+	
+	void Delete();
+
+	/**
+	*	@brief	사용자에게 Name을 입력받아 SortedList의 Replace함수에 넘겨주는 역할을 한다.
+	*	@pre	없다.
+	*	@post	사용자가 입력한 Name을 가지고 있는 MusicType을 다시 입력받아 갱신한다.
+	*	@return	없다.
+	*/
+	void Update();
+	/**
+	*	@brief	최근에 추가된 30곡의 자세한 정보를 화면에 출력
+	*	@pre	없다.
+	*	@post	없다.
+	*	@return	없다.
+	*/
+	void DIsplayNewMusic();
+	/**
+	*	@brief	Primary key를 이용해 원하는 음악정보가져온다.
+	*	@pre	리스트가 초기화되어야함.
+	*	@post	inData에 원하는 곡정보가 담김
+	*	@return	찾으면 1, 아니면 0
+	*	@param key 곡번호를 찾기위한 int형 변수
+	*	@inData 원하는 곡의 정보를 받아오기 위한 변수
+	*/
+	bool Search(int key, MusicType& inData);
+	/**
+	*	@brief	장르 리스트에 있는 곡들을 장르에 맞춰 출력
+	*	@pre	없다.
+	*	@post	없다.
+	*	@return	없다.
+	*/
+	void DisplayMusicbyGenre();
+
+	/**
+*	@brief	객체를 생성 후, 문자열을 입력받는다.
+*	@pre	없다.
+*	@post	SearchByNameNGenre함수에 문자열이 설정된 객체를 전달한다.
+*	@return	없다.
+*/
+	void RetreiveRecordByNameNGenre();
+
+	/**
+	*	@brief	inData의 이름 부분을 포함하는 문자열을 찾아 출력한다.
+	*	@pre	inData의 이름 부분이 초기화되어있어야 한다.
+	*	@post	inData에 알맞은 항목이 복사된다.
+	*	@param	inData	이름이 설정되어있고 나머지는 비어있는 Musictype
+	*	@return	없다.
+	*/
+	void SearchByNameNGenre(MusicType &inData);
+	/**
+*	@brief	MusicList에 있는 곡을 앨범별로 출력한다.
+*	@pre	없다.
+*	@post	없다.
+*	@return	없다.
+*/
+	void DisplayMusicByAlbum();
+	/**
+*	@brief	MusicList에 있는 곡을 아티스트별로 나누고, 각 아티스트별 로 앨범을 분류하여 출력한다.
+*	@pre	없다.
+*	@post	없다.
+*	@return	없다.
+*/
+	void DisplayMusicByArtist();
+	/**
+*	@brief	MusicList에 있는 곡을 Primary Key에 따라 정렬된 순서에 따라 Index를 부여한다
+*	@pre	MusicList에 최소한 하나이상의 곡이 있어야한다.
+*	@post	MusicList의 각 MusicType에 Index가 부여된다
+*	@return	없다.
+*/
+	void SetMusicIndex();
+	/**
+*	@brief	MusicList의 Music을 분류하는 하위리스트들을 다시 만들기 위한 조건을 충족시킨다.
+*	@pre	곡이 추가되거나, 삭제되거나, 변경되어야 한다.
+*	@post	Remake~~List 형의 변수의 값이 모두 true가 된다.
+*	@return	없다.
+*/
+	void RemakeSubList()
+	{
+		RemakeAlbumList = true;
+		RemakeArtistList = true;
+		RemakeGenreList = true;
+	};
+
+	void makePlayList();
+
+	void AddMusicInPL();
+
+	void PrintPL();
+	
+private:
+	ifstream m_InFile;		///< input file descriptor.
+	ofstream m_OutFile;		///< output file descriptor.
+	SortedLinkedList<MusicType> m_List;		/// 노래 리스트
+	UnSortedLinkedList<ManageType> mg_List;
+	int m_Command;			///< current command number.
+	SortedLinkedList<AlbumType> AlbumList;			//앨범을 분류하기 위한 앨범리스트
+	SortedLinkedList<ArtistType> ArtistList;		//아티스트를 분류하기 위한 아티스트리스트
+	SortedLinkedList <string> GenreList;		//장르를 분류하기 위한 장르 리스트
+	UnSortedLinkedList<PLType> PlayLists;
+	//아래의 변수들은 각 하위 리스트를 다시만들어야 할지 판별하는 변수이다.
+	bool RemakeAlbumList;			
+	bool RemakeArtistList;
+	bool RemakeGenreList;
+	int NumofPL;
+};
+
+
+
+#endif	// _APPLICATION_H
+
+

+
+#include"ArtistType.h"
+
+void ArtistType::PrintListinList()
+{
+	DoublyIter<AlbumType> Abiter(AlbumList);
+	cout << "\t ----------------" << endl;
+	cout << "\t ƼƮ : " << ArtistName << endl;
+	while (Abiter.NotNull())
+	{
+		cout << "\tٹ" << Abiter.GetCurrentNode().data.GetAlbumName() << endl;
+		Abiter.Next();
+	}
+}
+
+ArtistType::ArtistType(const ArtistType& data)
+{
+	ArtistName = data.ArtistName;
+	AlbumList = data.AlbumList;
+
+}
\ No newline at end of file

+#pragma once
+#include"AlbumType.h"
+using namespace std;
+
+class ArtistType {
+public:
+	ArtistType()
+	{
+		ArtistName = "";
+	}
+		;	//기본 생성자
+	~ArtistType()
+	{
+		AlbumList.MakeEmpty();
+	}
+	;	//기본 소멸자
+	ArtistType(const ArtistType& data);
+	/**
+*	@brief	Get ArtistName
+*	@pre	ArtistName is set
+*	@post	x
+*	@return	ArtistName
+*/
+	string GetArtistName() 
+	{
+		return ArtistName;
+	};
+	/**
+*	@brief	set ArtistName
+*	@pre	x
+*	@post	ArtistName is set
+*/
+	void SetArtistName(string Name)
+	{
+		ArtistName = Name;
+	};
+	/**
+*	@brief	비교 연산자
+*	@pre	비교하려는 두 아티스트타입이 초기화되어 있어야한다
+*	@post	x
+*	@param	data 비교하려는 아티스트타입
+*	@return	좌변이크면 false, 우변이크면 true
+*/
+	bool operator<(ArtistType data)
+	{
+		return (ArtistName < data.GetArtistName());
+	};
+	/**
+*	@brief	비교 연산자
+*	@pre	비교하려는 두 아티스트타입이 초기화되어 있어야한다
+*	@post	x
+*	@param	data 비교하려는 아티스트타입
+*	@return	좌변이크면 true, 우변이크면 false
+*/
+	bool operator>(ArtistType data)
+	{
+		return (ArtistName > data.GetArtistName());
+	};
+	/**
+*	@brief	등위 연산자
+*	@pre	비교하려는 두 아티스트타입이 초기화되어 있어야한다
+*	@post	x
+*	@param	data 비교하려는 아티스트타입
+*	@return	두 항이 같으면 true 아니면 false
+*/
+	bool operator==(ArtistType data)
+	{
+		if (ArtistName == data.GetArtistName())
+			return true;
+		else
+			return false;
+	};
+	/**
+*	@brief	대입 연산자
+*	@pre	패러미터로 넘어오는 Artisttype이 초기화되어있어야한다.
+*	@post	this가 data와 같아진다
+*	@param	data 대입하려는 아티스트타입
+*	@return	*this
+*/
+	ArtistType operator=(const ArtistType& data)
+	{
+		ArtistName = data.ArtistName;
+		AlbumList = data.AlbumList;
+		return *this;
+	};
+	/**
+*	@brief	리스트안의 리스트에 원소를 추가한다
+*	@pre	x
+*	@post	AlbumList에 앨범이 추가된다.
+*	@param	A 추가하려는 앨범타입
+*/
+	void AddListinList(AlbumType &A)
+	{
+		AlbumList.Add(A);
+	};
+	/**
+*	@brief	리스트 안의 리스트의 내용을 출력한다.
+*	@pre	앨범리스트가 초기화되어 있어야 한다.
+*	@post	x
+*/
+	void PrintListinList() ;
+
+	void MakeEmptyListinList()
+	{
+		AlbumList.MakeEmpty();
+	}
+private:
+	SortedLinkedList<AlbumType> AlbumList;		//한 아티스트가 가지는 앨범 리스트
+	string ArtistName;
+
+};

+#pragma once
+#ifndef _SORTED_LINKED_LIST_H
+#define _SORTED_LINKED_LIST_H
+#include"SortedLinkedList.h"
+
+
+template<typename T>
+class SortedLinkedList;
+
+template<typename T>
+struct NodeType;
+
+
+
+template<typename T>
+class DoublyIter {
+	friend class SortedLinkedList<T>;
+
+private:
+	const SortedLinkedList<T>& m_List;
+	NodeType<T>* CurPointer;
+public:
+	DoublyIter(const SortedLinkedList<T>& list) : m_List(list), CurPointer(list.m_pList)
+	{}
+	/**
+	*	@brief	현재 노드를 가리키는 포인터가 null인지 아닌지 판단하는 메서드.
+	*	@pre	Iterator has been initialized.
+	*	@post	None.
+	*	@return	nullptr true, otherwise false.
+	*/
+	bool NotNull();
+
+	/**
+	*	@brief	현재 노드 포인터의 다음 노드가 null인지 아닌지 판단하는 메서드.
+	*	@pre	Iterator has been initialized.
+	*	@post	None.
+	*	@return	nullptr true, otherwise false.
+	*/
+	bool NextNotNull();
+	/**
+	*	@brief	현재 노드 포인터의 이전 노드가 null인지 아닌지 판단하는 메서드.
+	*	@pre	Iterator has been initialized.
+	*	@post	None.
+	*	@return	nullptr true, otherwise false.
+	*/
+	bool PrevNotNull();
+	/**
+	*	@brief	Get first data of the list.
+	*	@pre	Iterator has been initialized.
+	*	@post	Current pointer is moved to the first node.
+	*	@return	Return first data of the list.
+	*/
+	T First();
+
+	/**
+	*	@brief	Get next data of the current pointer.
+	*	@pre	Iterator has been initialized.
+	*	@post	Current pointer is moved to the next node.
+	*	@return	Return next data of the list.
+	*/
+	T Next();
+
+	/**
+	*	@brief	Get current data of the list and go to the next node. 현재 노드. 객체반환은 return by value
+	*	@pre	Iterator has been initialized.
+	*	@post	Current pointer is moved to next node.
+	*	@return	Return current data of the list.
+	*/
+	NodeType<T> GetCurrentNode();
+	/**
+	*	@brief	현재 노드의 data의 주소값을 반환하는 함수
+	*	@pre	Iterator has been initialized.
+	*	@post	x
+	*	@return	Return current data's address
+	*/
+	T* GetCurrentPtr();
+	/**
+	*	@brief	마지막 데이터의 포인터를 받는다.
+	*	@pre	Iterator has been initialized.
+	*	@post	x
+	*	@return	Return last data of the list.
+	*/
+	T Last();
+	/**
+	*	@brief	Curpointer의 이전 노드로 간다
+	*	@pre	Iterator has been initialized.
+	*	@post	이전 노드로 포인터가 이동한다
+	*	@return	Return Prev data of the list.
+	*/
+	T Prev();
+
+
+
+};
+
+
+
+// 현재 원소가 null인지 검사
+template <typename T>
+bool DoublyIter<T>::NotNull() {
+	if (CurPointer == NULL) {
+		return false;
+	}
+	else return true;
+}
+
+// 다음 원소가 null인지 검사
+template <typename T>
+bool DoublyIter<T>::NextNotNull() {
+	if (CurPointer->next == NULL) {
+
+		return false;
+	}
+	else 
+		return true;
+}
+
+template<typename T>
+bool DoublyIter<T>::PrevNotNull()
+{
+	if (CurPointer->Prev == NULL)
+		return false;
+	else
+		return true;
+
+}
+// 첫 번째 node
+template <typename T>
+T DoublyIter<T>::First() {
+	if (!m_List.IsEmpty()) {
+		CurPointer = m_List.m_pFirst;
+		return CurPointer->data;
+	}
+}
+
+// 다음 node로 이동 후 item을 return.
+template <typename T>
+T DoublyIter<T>::Next() {
+	T output = CurPointer->data;
+	if (NotNull()) {
+		CurPointer = CurPointer->next;
+	}
+	return output;
+}
+template<typename T>
+T DoublyIter<T>::Last()
+{
+	if (!m_List.IsEmpty()) {
+		CurPointer = m_List.m_pLast;
+		return CurPointer -> data;
+	}
+
+
+}
+template<typename T>
+T DoublyIter<T>::Prev()
+{
+	T output = CurPointer->data;
+	if (NotNull()) {
+		CurPointer = CurPointer->prev;
+	}
+	return output;
+
+
+}
+// 현재 node를 return
+template <typename T>
+NodeType<T> DoublyIter<T>::GetCurrentNode() {
+	if (CurPointer != NULL) {
+		return *CurPointer;
+	}
+}
+template<typename T>
+T* DoublyIter<T>::GetCurrentPtr()
+{
+	if (CurPointer != NULL)
+	{
+		return &(CurPointer->data);
+	}
+
+}
+
+#endif // !_DOUBLY_ITER_H
\ No newline at end of file

+#pragma once
+#ifndef _UN_SORTED_LINKED_LIST_H
+#define _UN_SORTED_LINKED_LIST_H
+#include"UnSortedLinkedList.h"
+
+
+template<typename T>
+class UnSortedLinkedList;
+
+template<typename T>
+struct NodeType2;
+
+
+
+template<typename T>
+class DoublyIter2 {
+	friend class UnSortedLinkedList<T>;
+
+private:
+	const UnSortedLinkedList<T>& m_List;
+	NodeType2<T>* CurPointer;
+public:
+	DoublyIter2(const UnSortedLinkedList<T>& list) : m_List(list), CurPointer(list.m_pList)
+	{}
+	/**
+	*	@brief	현재 노드를 가리키는 포인터가 null인지 아닌지 판단하는 메서드.
+	*	@pre	Iterator has been initialized.
+	*	@post	None.
+	*	@return	nullptr true, otherwise false.
+	*/
+	bool NotNull();
+
+	/**
+	*	@brief	현재 노드 포인터의 다음 노드가 null인지 아닌지 판단하는 메서드.
+	*	@pre	Iterator has been initialized.
+	*	@post	None.
+	*	@return	nullptr true, otherwise false.
+	*/
+	bool NextNotNull();
+	/**
+	*	@brief	현재 노드 포인터의 이전 노드가 null인지 아닌지 판단하는 메서드.
+	*	@pre	Iterator has been initialized.
+	*	@post	None.
+	*	@return	nullptr true, otherwise false.
+	*/
+	bool PrevNotNull();
+	/**
+	*	@brief	Get first data of the list.
+	*	@pre	Iterator has been initialized.
+	*	@post	Current pointer is moved to the first node.
+	*	@return	Return first data of the list.
+	*/
+	T First();
+
+	/**
+	*	@brief	Get next data of the current pointer.
+	*	@pre	Iterator has been initialized.
+	*	@post	Current pointer is moved to the next node.
+	*	@return	Return next data of the list.
+	*/
+	T Next();
+
+	/**
+	*	@brief	Get current data of the list and go to the next node. 현재 노드. 객체반환은 return by value
+	*	@pre	Iterator has been initialized.
+	*	@post	Current pointer is moved to next node.
+	*	@return	Return current data of the list.
+	*/
+	NodeType2<T> GetCurrentNode();
+	/**
+	*	@brief	현재 노드의 data의 주소값을 반환하는 함수
+	*	@pre	Iterator has been initialized.
+	*	@post	x
+	*	@return	Return current data's address
+	*/
+	T* GetCurrentPtr();
+	/**
+	*	@brief	마지막 데이터의 포인터를 받는다.
+	*	@pre	Iterator has been initialized.
+	*	@post	x
+	*	@return	Return last data of the list.
+	*/
+	T Last();
+	/**
+	*	@brief	Curpointer의 이전 노드로 간다
+	*	@pre	Iterator has been initialized.
+	*	@post	이전 노드로 포인터가 이동한다
+	*	@return	Return Prev data of the list.
+	*/
+	T Prev();
+
+
+
+};
+
+
+
+// 현재 원소가 null인지 검사
+template <typename T>
+bool DoublyIter2<T>::NotNull() {
+	if (CurPointer == NULL) {
+		return false;
+	}
+	else return true;
+}
+
+// 다음 원소가 null인지 검사
+template <typename T>
+bool DoublyIter2<T>::NextNotNull() {
+	if (CurPointer->next == NULL) {
+
+		return false;
+	}
+	else
+		return true;
+}
+
+template<typename T>
+bool DoublyIter2<T>::PrevNotNull()
+{
+	if (CurPointer->Prev == NULL)
+		return false;
+	else
+		return true;
+
+}
+// 첫 번째 node
+template <typename T>
+T DoublyIter2<T>::First() {
+	if (!m_List.IsEmpty()) {
+		CurPointer = m_List.m_pFirst;
+		return CurPointer->data;
+	}
+}
+
+// 다음 node로 이동 후 item을 return.
+template <typename T>
+T DoublyIter2<T>::Next() {
+	T output = CurPointer->data;
+	if (NotNull()) {
+		CurPointer = CurPointer->next;
+	}
+	return output;
+}
+template<typename T>
+T DoublyIter2<T>::Last()
+{
+	if (!m_List.IsEmpty()) {
+		CurPointer = m_List.m_pLast;
+		return CurPointer->data;
+	}
+
+
+}
+template<typename T>
+T DoublyIter2<T>::Prev()
+{
+	T output = CurPointer->data;
+	if (NotNull()) {
+		CurPointer = CurPointer->pre;
+	}
+	return output;
+
+
+}
+// 현재 node를 return
+template <typename T>
+NodeType2<T> DoublyIter2<T>::GetCurrentNode() {
+	if (CurPointer != NULL) {
+		return *CurPointer;
+	}
+}
+template<typename T>
+T* DoublyIter2<T>::GetCurrentPtr()
+{
+	if (CurPointer != NULL)
+	{
+		return &(CurPointer->data);
+	}
+
+}
+
+#endif // !_DOUBLY_ITER2_H
\ No newline at end of file

+#pragma once
+#include<iostream>
+#include<string>
+#include"SortedLinkedList.h"
+#include"SimplifiedType.h"
+using namespace std;
+/**
+*	@brief	과제 1에서 이 클래스는 쓰이지 않는다.
+
+*/
+class GenreType			//현재 이 장르타입은 쓰지 않는다.
+{
+public:
+	GenreType()
+	{
+		G_num = -1;
+		G_name = "";
+	}	//기본 생성자
+
+	~GenreType()
+	{
+	
+	} //기본 소멸자
+
+	/**
+	*	@brief	Get Genre
+	*	@pre	Genre is set.
+	*	@post	none.
+	*	@return	Genre;
+*/
+	string GetGenre()
+	{
+		return G_name;
+	}
+	/**
+	*	@brief	Get song Number
+	*	@pre	song Name is set.
+	*	@post	none.
+	*	@return	song number
+*/
+	int GetNum()
+	{
+		return G_num;
+	}
+	/**
+	*	@brief	set song number
+	*	@pre	x
+	*	@post	song number is set
+	*	@param num song number
+*/
+	void SetNum(int num)
+	{
+		G_num = num;
+	}
+	/**
+	*	@brief	set genre
+	*	@pre	x
+	*	@post	genre is set
+	*	@param Genre Genre
+*/
+	void SetGenre(string Genre)
+	{
+		G_name = Genre;
+	}
+	/**
+*	@brief	두 SimplifiedType의 Primary key가 같은지 비교함
+*	@pre	비교하고자 하는 SimplifiedType이 초기화 되어있어야함
+*	@post	x
+*	@param	data 비교하고자 하는 데이터
+*	@return	같을경우 true, 다를경우 false
+*/
+	bool operator==(GenreType data)
+	{
+
+		if (this->GetNum() == data.GetNum())
+			return true;
+		else
+			return false;
+	}
+	/**
+*	@brief	두 SimplifiedType의 Primary key의 크기를 비교함
+*	@pre	비교하고자 하는 SimplifiedType이 초기화 되어있어야함
+*	@post	x
+*	@param	data 비교하고자 하는 데이터
+*	@return	좌변이 클경우 true 작을경우 false
+
+*/
+	bool operator>(GenreType data)
+	{
+		if (this->GetNum() > data.GetNum())
+			return true;
+		else
+			return false;
+	}
+	/**
+*	@brief	두 SimplifiedType의 Primary key의 크기를 비교함
+*	@pre	비교하고자 하는 SimplifiedType이 초기화 되어있어야함
+*	@post	x
+*	@param	data 비교하고자 하는 데이터
+*	@return	우변이 클경우 true 작을경우 false
+*/
+	bool operator<(GenreType data)
+	{
+		if (this->GetNum() < data.GetNum())
+			return true;
+		else
+			return false;
+
+	}
+	/**
+*	@brief	GenreList안에 Simplified 타입을 넣는 함수
+*	@pre	x
+*	@post	현재 GenreList에 Simplified 타입이 추가된다
+*	@param	추가하고자 하는 데이터
+*/
+	void addListinGenre(SimplifiedType in)
+	{
+		G_List.Add(in);
+	}
+	/**
+*	@brief	현 GenreList안의 모든 데이터를 출력하는함수
+*	@pre	GenreList안의 원소가 초기화 되어있어야함
+*	@post	x
+*/
+	void PrintAll()
+	{
+		
+
+		
+		
+	}
+
+
+
+
+private:
+	int G_num;	//장르 넘버 = Primary Key
+	string G_name; //장르 명
+	SortedLinkedList<SimplifiedType> G_List;	//각 장르별 장르리스트
+};
\ No newline at end of file

+#pragma once
+#include"MusicType.h"
+
+
+class ManageType {
+private:
+	string Pkey;
+	int played;
+	int Index;
+	string name;
+	string artist;
+public:
+	ManageType() {
+		Pkey = "";
+		played = 0;
+		Index = 0;
+	};
+	~ManageType() {};
+	void setPkey(string key)
+	{
+		Pkey = key;
+	}
+	void setIndex(int I)
+	{
+		Index = I;
+	}
+	void IncreasePlayed()
+	{
+		played++;
+	}
+	void setName(string N)
+	{
+		name = N;
+	}
+	void setArtist(string A)
+	{
+		artist = A;
+	}
+	string getArtist()
+	{
+		return artist;
+	}
+	string getPkey()
+	{
+		return Pkey;
+	}
+	int getPlayed()
+	{
+		return played;
+	}
+	int getIndex()
+	{
+		return Index;
+	}
+	string getName()
+	{
+		return name;
+	}
+
+	void PrintNameNArtist()
+	{
+		cout << "\t°î¸í : " << name << endl;
+		cout << "\t¾ÆƼ½ºÆ® : " << artist << endl << endl;
+	}
+	void PrintNameNIndex()
+	{
+		cout << "\t°î¸í : " << name << endl;
+		cout << "\tIndex : " << Index << endl << endl;
+	}
+
+};
+

+
+#include "MusicType.h"
+
+
+
+
+// Ǻ
+// Set student song Name from keyboard.
+void MusicType::SetNameFromKB()
+{
+
+	cout << "\tsong Name : ";
+	cin >> Name;
+
+}
+
+
+// Set Singer Name from keyboard.
+void MusicType::SetSingerFromKB()
+{
+
+	cout << "\tSinger : ";
+	cin >> Singer;
+
+}
+
+
+// Set Album Name from keyboard.
+void MusicType::SetAlbumFromKB()
+{
+
+	cout << "\tAlbum : ";
+	cin >> Album;
+
+}
+// Set Genre from keyboard
+void MusicType::SetGenreFromKB()
+{
+
+	cout << "\tGenre : ";
+	cin >> Genre;
+
+
+}
+
+// Set Lyrics from keyboard
+void MusicType::SetLyricsFromKB()
+{
+	cin.ignore();
+	cout << "\tLyrics : ";
+	getline(cin, Lyrics);
+}
+void MusicType::SetNumFromKB()
+{
+	cout << "\tNumber : ";
+	cin >> Num;
+}
+
+
+// Set student record from keyboard.
+void MusicType::SetInfoFromKB()
+{
+	//SetNumFromKB();
+	SetNameFromKB();
+	SetSingerFromKB();
+	SetAlbumFromKB();
+	SetGenreFromKB();
+	SetLyricsFromKB();
+	SetPkey();
+}
+
+
+// Read a record from file.
+int MusicType::ReadDataFromFile(ifstream& fin)
+{
+	fin >> Name;
+	fin >> Singer;
+	fin >> Album;
+	fin >> Genre;
+	getline(fin, Lyrics);
+	return 1;
+};
+
+
+// Write a record into file.
+int MusicType::WriteDataToFile(ofstream& fout)
+{
+	fout << endl;
+	fout << Name << " ";
+	fout << Singer << " ";
+	fout << Album << " ";
+	fout << Lyrics << " ";
+
+	return 1;
+}
\ No newline at end of file

+
+#ifndef _MusicType_H
+#define _MusicType_H
+
+#include <iostream>
+#include <fstream>
+#include <string>
+
+using namespace std;
+
+
+
+
+/**
+*	item information class.
+*/
+class MusicType
+{
+public:
+	/**
+	*	default constructor.
+	*/
+	MusicType()
+	{
+		Num = -1;
+		Name = "";
+		Singer = "";
+		Album = "";
+		Genre = "";
+		Lyrics = "";
+	}
+
+	/**
+	*	destructor.
+	*/
+	~MusicType() {}
+	/**
+	*	@brief	Get song Name
+	*	@pre	song Name is set.
+	*	@post	none.
+	*	@return	song Name;
+*/
+	int GetNum()
+	{
+		return Num;
+	}
+	/**
+	*	@brief	Get song Name
+	*	@pre	song Name is set.
+	*	@post	none.
+	*	@return	song Name;
+	*/
+	string GetName()
+	{
+		return Name;
+	}
+
+	/**
+	*	@brief	Get Singer Name.
+	*	@pre	Singer Name is set.
+	*	@post	none.
+	*	@return	Singer Name.
+	*/
+	string GetSinger()
+	{
+		return Singer;
+	}
+
+	/**
+	*	@brief	Get Album Name
+	*	@pre	Album Name is set.
+	*	@post	none.
+	*	@return	Album Name.
+	*/
+	string GetAlbum()
+	{
+		return Album;
+	}
+	/**
+	*	@brief	Get Genre
+	*	@pre	Genre is set.
+	*	@post	none.
+	*	@return	Genre.
+	*/
+	string GetGenre()
+	{
+		return Genre;
+	}
+	/**
+	*	@brief	Get Lyrics
+	*	@pre	Lyrics is set.
+	*	@post	none.
+	*	@return	Lyrics.
+	*/
+	string GetLyrics()
+	{
+		return Lyrics;
+	}
+	/**
+	*	@brief	Get Pkey
+	*	@pre	Pkey is set.
+	*	@post	none.
+	*	@return	Pkey
+	*/
+	string GetPkey()
+	{
+		return Pkey;
+	}
+	/**
+	*	@brief	Set song Name
+	*	@pre	none.
+	*	@post	song Name is set.
+	*	@param	s_Name song Name
+	*/
+	void SetName(string s_Name)
+	{
+		Name = s_Name;
+	}
+	/**
+*	@brief	Set song Name
+*	@pre	none.
+*	@post	song Name is set.
+*	@param	s_Name song Name
+*/
+	void SetNum(int s_Num)
+	{
+		Num = s_Num;
+	}
+	/**
+	*	@brief	Set Singer Name
+	*	@pre	none.
+	*	@post	Singer Name is set.
+	*	@param	s_Singer	Singer Name.
+	*/
+	void SetSinger(string s_Singer)
+	{
+		Singer = s_Singer;
+	}
+
+	/**
+	*	@brief	Set Album Name
+	*	@pre	none.
+	*	@post	Album Name is set.
+	*	@param	s_Album	Album Name.
+	*/
+	void SetAlbum(string s_Album)
+	{
+		Album = s_Album;
+	}
+	/**
+	*	@brief	Set Genre
+	*	@pre	none.
+	*	@post	Genre is set.
+	*	@param	s_Genre	Genre.
+	*/
+	void SetGenre(string s_Genre)
+	{
+		Genre = s_Genre;
+	}
+	/**
+	*	@brief	Set Lyrics
+	*	@pre	none.
+	*	@post Lyrics is set.
+	*	@param	s_Lyrics Lyrics
+	*/
+	void SetLyrics(string s_Lyrics)
+	{
+		Lyrics = s_Lyrics;
+	}
+	/**
+	*	@brief	Set Pkey
+	*	@pre	none.
+	*	@post Pkey is set.
+	*/
+	void SetPkey()
+	{
+		Pkey = Name + Singer;
+	}
+	/**
+	*	@brief	Set song information
+	*	@pre	none.
+	*	@post	song information is set
+	*	@param	s_Name song Name
+	*	@param	s_Singer Singer Name
+	*	@param	s_Album Album Name.
+	*	@param  s_Genre Genre
+	*	@param	s_Lyrics Lyrics;
+	*/
+	void SetRecord(string s_Name, string s_Singer, string s_Album, string s_Genre, string s_Lyrics)
+	{
+		SetName(s_Name);
+		SetSinger(s_Singer);
+		SetAlbum(s_Album);
+		SetGenre(s_Genre);
+		SetLyrics(s_Lyrics);
+		SetPkey();
+	}
+	/**
+	*	@brief	Display song Name on screen.
+	*	@pre	song Name is set.
+	*	@post	song Name is on screen.
+	*/
+	void DisplayNumOnScreen()
+	{
+		cout << "\tSong Number(Track Number)	: " << Num << endl;
+	};
+	/**
+	*	@brief	Display song Name on screen.
+	*	@pre	song Name is set.
+	*	@post	song Name is on screen.
+	*/
+	void DisplayNameOnScreen()
+	{
+		cout << "\tSong Name   : " << Name << endl;
+	};
+
+	/**
+	*	@brief	Display Singer Name on screen.
+	*	@pre	Singer Name is set.
+	*	@post	Singer Name is on screen.
+	*/
+	void DisplaySingerOnScreen()
+	{
+		cout << "\tSinger : " << Singer << endl;
+	};
+
+	/**
+	*	@brief	Display Album Name on screen.
+	*	@pre	Album Name is set.
+	*	@post	Album Name is on screen.
+	*/
+	void DisplayAlbumOnScreen()
+	{
+		cout << "\tAlbum : " << Album << endl;
+	};
+
+	/**
+	*	@brief	Display Genre on screen.
+	*	@pre	Genre is set.
+	*	@post	Genre is on screen.
+	*/
+	void DisplayGenreOnScreen()
+	{
+		cout << "\tGenre : " << Genre << endl;
+	};
+	/**
+*	@brief	Display Lyrics on screen.
+*	@pre	Lyrics is set.
+*	@post	Lyrics is on screen.
+*/
+	void DisplayLyricsOnScreen()
+	{
+		cout << "\tLyrics : " << Lyrics << endl;
+	};
+	/**
+	*	@brief	Display an song information on screen.
+	*	@pre	song information is set.
+	*	@post	song information is on screen.
+	*/
+	void DisplayRecordOnScreen()
+	{
+		DisplayNumOnScreen();
+		DisplayNameOnScreen();
+		DisplaySingerOnScreen();
+		DisplayAlbumOnScreen();
+		DisplayGenreOnScreen();
+		DisplayLyricsOnScreen();
+	};
+	/**
+	*	@brief	Set song Number from keyboard.
+	*	@pre	none.
+	*	@post	song Number is set.
+	*/
+	void SetNumFromKB();
+	/**
+	*	@brief	Set song Name from keyboard.
+	*	@pre	none.
+	*	@post	song Name is set.
+	*/
+	void SetNameFromKB();
+
+	/**
+	*	@brief	Set Singer Name from keyboard.
+	*	@pre	none.
+	*	@post	Singer Name is set.
+	*/
+	void SetSingerFromKB();
+
+	/**
+	*	@brief	Set Album Name from keyboard.
+	*	@pre	none.
+	*	@post	Album Name is set.
+	*/
+	void SetAlbumFromKB();
+	/**
+	*	@brief	Set Genre from keyboard.
+	*	@pre	none.
+	*	@post	Genre is set.
+	*/
+	void SetGenreFromKB();
+	/**
+	*	@brief	Set Lyrics from keyboard.
+	*	@pre	none.
+	*	@post	Lyrics is set.
+	*/
+	void SetLyricsFromKB();
+	/**
+	*	@brief	Set song information from keyboard.
+	*	@pre	none.
+	*	@post	song information is set.
+	*/
+	void SetInfoFromKB();
+
+	/**
+	*	@brief	Read a record from file.
+	*	@pre	the target file is opened.
+	*	@post	student record is set.
+	*	@param	fin	file descriptor.
+	*	@return	return 1 if this function works well, otherwise 0.
+	*/
+	int ReadDataFromFile(ifstream& fin);
+
+	/**
+	*	@brief	Write a record into file.
+	*	@pre	the target file is opened. And the list should be initialized.
+	*	@post	the target file is included the new student record.
+	*	@param	fout	file descriptor.
+	*	@return	return 1 if this function works well, otherwise 0.
+	*/
+	int WriteDataToFile(ofstream& fout);
+
+	/**
+*	@brief	두 MusicType의 Primary key가 같은지 비교함
+*	@pre	비교하고자 하는 MusicType이 초기화 되어있어야함
+*	@post	x
+*	@param	data 비교하고자 하는 데이터
+*	@return	같을경우 true, 다를경우 false
+*/
+	bool operator==(MusicType data)
+	{
+		
+		if (this->GetPkey() == data.GetPkey())
+			return true;
+		else
+			return false;
+	}
+	/**
+*	@brief	두 MusicType의 Primary key의 크기를 비교함
+*	@pre	비교하고자 하는 MusicType이 초기화 되어있어야함
+*	@post	x
+*	@param	data 비교하고자 하는 데이터
+*	@return	좌변이 클경우 true 작을경우 false
+
+*/
+	bool operator>(MusicType data)
+	{
+		return (this->GetPkey() > data.GetPkey());
+	}
+	/**
+*	@brief	두 MusicType의 Primary key의 크기를 비교함
+*	@pre	비교하고자 하는 MusicType이 초기화 되어있어야함
+*	@post	x
+*	@param	data 비교하고자 하는 데이터
+*	@return	우변이 클경우 true 작을경우 false
+*/
+	bool operator<(MusicType data)
+	{
+		return (this->GetPkey() < data.GetPkey());
+
+	}
+
+	
+protected:
+	int Num;		//곡의 인덱스
+	string Name; //곡명
+	string Singer; //가수
+	string Album; //앨범
+	string Genre; //장르
+	string Lyrics; //가사
+	string Pkey; //Primary Key
+};
+
+
+
+
+#endif	// _MusicType_H

+
+#include "PLType.h"
+
+PLType::PLType(const PLType& data)
+{
+	PlayList = data.PlayList;
+	PLname = data.PLname;
+	length = data.length;
+	
+}
+void PLType::Printall()
+{
+	DoublyIter2<ManageType*> Mgiter(PlayList);
+	while (Mgiter.NotNull())
+	{
+		cout << " : " << Mgiter.GetCurrentNode().data->getName() << endl;
+		cout << "Index : " << Mgiter.GetCurrentNode().data->getIndex() << endl;
+		Mgiter.Next();
+	}
+
+}
\ No newline at end of file

+#pragma once
+#include"ManageType.h"
+#include"UnSortedLinkedList.h"
+class PLType {
+private:
+
+	UnSortedLinkedList<ManageType*> PlayList;
+	string PLname;
+	int length;
+public:
+	PLType() { length = 0; PLname = ""; }
+	~PLType() {}
+	PLType(const PLType& data);
+	void setPLname(string N)
+	{
+		PLname = N;
+	}
+	string getPLname()
+	{
+		return PLname;
+	}
+	void AddListinList(ManageType* data)
+	{
+		PlayList.Add(data);
+		length++;
+	}
+	void Printall();
+};

+#pragma once
+#ifndef _DOUBLY_ITER_H
+#define _DOUBLY_ITER_H
+#include"DoublyIter.h"
+
+template <typename T>
+struct NodeType {
+	T data; //각 노드의 데이터
+	NodeType* next;// 노드의 다음을 가리킬 포인터
+	NodeType* pre;
+};
+template<typename T>
+class DoublyIter;
+/*
+*	@bried 이 클래스는 더블소티드링크드리스트
+*/
+template<typename T>
+class SortedLinkedList
+{
+	friend class DoublyIter<T>;
+public:
+	/**
+*	default constructor.
+*/
+	SortedLinkedList();
+
+	/**
+	*	destructor.
+	*/
+	~SortedLinkedList();
+	/**
+	*	@brief	깊은 복사를 위한 SortedLinkedList의 복사 연산자
+	*	@pre	anotherList가 초기화되어 있어야한다.
+	*	@post	anotherList와 같은 정보를 가진 리스트가 생성된다
+	*	@param	anotherList 복사하고자 하는 SortedLinkedList
+	*/
+	SortedLinkedList(const SortedLinkedList<T>& anotherList);
+	/**
+	*	@brief	링크드 리스트의 모든 노드를 제거한다.
+	*	@pre	None.
+	*	@post	리스트가 비워진다.
+
+	*/
+	void MakeEmpty();
+
+	/**
+	*	@brief	리스트의 길이 = 원소의 개수 를 리턴함
+	*	@pre	x
+	*	@post	리턴값이 리스트의 길이가 된다
+	*	@return	리스트의 길이 = 원소의 개수
+	*/
+	int GetLength()
+	{
+		return m_nLength;
+	}
+	/**
+	*	@brief	새로운 노드의 값을 비교하여 맞는 위치에 추가한다
+	*	@pre	List is not Full(메모리에 빈 공간이 있어야 한다)
+	*	@post	리스트에 아이템이 추가된다.
+	*	@return	추가되면 1 아니면 0
+	*	@param 추가하고자 하는 데이터값
+	*/
+	int Add(T& data);
+	/**
+	*	@brief	입력한 정보와 같은 정보를 가진 리스트의 원소를 리스트에서 삭제한다
+	*	@pre	리스트가 비어있지 않아야한다.
+	*	@post	리스트의 원소가 삭제되고 길이가 짧아진다.
+	*	@return	삭제됬으면 1 아니면 0
+	*	@param data 삭제하고자 하는 데이터값
+	*/
+	int Delete(T& data);
+	/**
+	*	@brief	리스트내의 정보를 바꾼다
+	*	@pre	리스트에 하나이상의 원소가 있어야한다.
+	*	@post	리스트내의 원소의 정보가 바뀐다
+	*	@return	작동했으면 1 아니면 0
+	*/
+	int Replace(T& data);
+	/**
+	*	@brief	리스트에서 Primarykey를 기준으로 일치하는 원소를 받아온다
+	*	@pre	리스트내의 정보가 초기화되있어야 한다
+	*	@post	키와 맞는 정보가 있으면 그것을 받아온다..
+	*	@return	찾아왔으면 1, 못찾았으면 0
+	*/
+	int Get(T& item);
+	/**
+	*	@brief	리스트가 비어있는지를 확인한다.
+	*	@pre	x
+	*	@post	x
+	*	@return 비었으면 1, 아니면 0
+	*/
+	bool IsEmpty()
+	{
+		if (m_nLength == 0)
+			return true;
+		else
+			return false;
+	}
+	
+	/**
+	*	@brief	복사 생성자를 이용한 대입 연산자
+	*	@pre	anotherList가 정의되어 있어야한다.
+	*	@post	깊은 복사된 리스트가 대입된다.
+	*	@return 복사된 리스트
+	*/
+	SortedLinkedList<T> operator=(const SortedLinkedList<T> &anotherList);
+
+private:
+	NodeType<T> *m_pList;
+	NodeType<T> *m_pLast;
+	int m_nLength;
+};
+
+
+
+//함수 정의부
+template<typename T>
+SortedLinkedList<T>::SortedLinkedList()
+{
+	m_nLength = 0;
+	m_pList = NULL;
+
+
+}
+template<typename T>
+SortedLinkedList<T>::~SortedLinkedList()
+{
+	MakeEmpty();//메모리누수를 막기위해 노드의 데이터를 모두 제거한다
+
+}
+template<typename T>
+void SortedLinkedList<T>::MakeEmpty()
+{
+	NodeType<T> *tempptr;
+	DoublyIter<T> iter(*this);
+	while (iter.NotNull())
+	{
+		tempptr = iter.CurPointer;
+		iter.Next();
+		delete tempptr;
+	}	//리스트내의 모든 노드를 제거
+
+	m_pList = NULL;
+	m_pLast = NULL;
+	m_nLength = 0;
+
+}
+
+template<typename T>
+int SortedLinkedList<T>::Add(T &data)
+{	
+	
+
+
+	NodeType<T> *Node = new NodeType<T>;
+	NodeType<T> *Pre;
+	DoublyIter<T> iter(*this);
+	bool Found = false;
+	T dummy;
+
+
+	Node->data = data;
+	Node->next = NULL;
+	Node->pre = NULL;
+	if (IsEmpty())	//비어있을 경우
+	{			
+		m_pList = Node;
+		m_pLast = m_pList;
+		m_nLength++;	//성공적으로 추가했으므로 길이를 늘려준다
+	}
+	//list에 노드가 있을경우
+	else
+	{
+		while (1)
+		{
+
+			//Pre = m_pCurPointer;	//이전 노드를 가리키는 포인터 갱신, 첫 시작은 m_pList로 리스트의 첫부분이다
+
+		
+			if (iter.CurPointer->data == Node->data)
+				break;			//같은 데이터가 있을경우 추가하지 않고 반복문을 탈출한다..
+
+			if (iter.CurPointer->data > Node->data)		//Node의 데이터가 현재 포인터의 값보다 작아질때까지 node가 들어갈 위치를 뒤로 민다.
+			{
+				if (iter.CurPointer->pre == NULL) //리스트 맨 앞 장소에 넣어야 할때 첫번째 원소로 삽입한다
+				{
+					
+					Node->next = iter.CurPointer;
+					iter.CurPointer->pre = Node;
+					m_pList = Node;
+					m_nLength++;	//성공적으로 추가했으므로 break 하기전에 길이를 늘려준다
+					
+					break;
+				}
+				Node->next = iter.CurPointer;
+				Node->pre = iter.CurPointer->pre;
+				iter.CurPointer->pre->next = Node;
+				iter.CurPointer->pre = Node;
+				m_nLength++;		//성공적으로 추가했으므로 break 하기전 길이를 늘려준다.
+				break;
+
+
+			}
+
+			//Node 포인터가 마지막 노드를 가리키면 그 뒤에 Node를 삽입한다.
+			if (iter.CurPointer->next == NULL)
+			{
+				Node->pre = iter.CurPointer;
+				iter.CurPointer->next = Node;
+				
+				m_pLast = Node;
+				m_nLength++;
+				break;
+
+			}
+			iter.Next();
+
+
+		}
+
+
+
+
+	}
+
+
+	return 1;
+}
+
+template<typename T>
+int SortedLinkedList<T>::Delete(T& data)
+{
+	bool MoreToSearch, found;
+	NodeType<T> *Pre = NULL;
+	DoublyIter<T> iter(*this);
+	
+	found = false;
+	MoreToSearch = iter.NotNull();
+
+	while (MoreToSearch && !found)
+	{
+		if (data == iter.CurPointer->data) //현재 가리키는 원소가 패러미터로 넣은 값과 같은가?
+		{
+			found = true;	//찾았으므로 found = true
+			if (Pre == NULL)	//찾은 항목이 첫번째 원소일경우
+			{
+				NodeType<T>* temp = iter.CurPointer;		//첫번째 원소의 다음원소를 저장할 임시 포인터선언
+				delete m_pList;	//첫원소를 삭제한다.
+				temp->pre = NULL;
+				m_pList = temp; //찾은 항목이 첫 항목일경우 다음 원소를 첫번째 원소로 한다.
+				
+			}
+			else
+			{
+				
+				Pre->next = iter.CurPointer->next;
+				iter.CurPointer->next->pre = Pre;
+				delete iter.CurPointer;
+			}
+
+
+
+		}
+		else
+		{
+			Pre = iter.CurPointer;
+			iter.Next();
+			MoreToSearch = (iter.NotNull());
+
+		}	//못 찾을경우 m_CurPointer은 다음 원소를 가리킨다. 단 Pre는 현재원소를 가리킨다.	
+	}
+
+	if (found) //찾았을 경우
+	{
+		m_nLength--;
+		return 1;
+
+	}
+	else    //못 찾으면	
+		return 0;
+
+
+
+}
+
+template<typename T>
+int SortedLinkedList<T>::Replace(T& data)
+{
+	bool MoreToSearch, found;
+	NodeType<T> *location;
+
+	location = m_pList;
+	found = false;
+	MoreToSearch = (location != NULL);
+
+	while (MoreToSearch && !found) //리스트의 끝이 아니면서 아직 몾찾을경우 반복한다
+	{
+		if (data == location->data) //일치하는 경우를 찾으면
+		{
+			found = true;
+			location->data = data;
+		}		//찾았으므로 found 는 true가되고 해당위치에 data값을 넣는다
+		else
+		{
+			location = location->next;
+			MoreToSearch = (location != NULL);	//리스트의 끝이 아닐경우 계속찾는다.
+
+		}	//찾지 못했을 때 다음 location으로 옮긴다.
+
+	}
+
+	if (found) //찾았을 경우
+	{
+		return 1;
+
+	}
+	else
+		return 0;		//못 찾음
+
+}
+
+template<typename T>
+int SortedLinkedList<T>::Get(T& data)
+{
+	bool MoreToSearch, found;
+	NodeType<T>* location;
+
+	location = m_pList;
+	found = false;
+	MoreToSearch = (location != NULL);
+
+	while (MoreToSearch && !found)
+	{
+		if (data == location->data)		//일치하는 항목을 찾으면
+		{
+			found = true;
+			data = location->data;
+		}
+		else
+		{
+
+			location = location->next;	//못찾으면 다음위치로 민다
+			MoreToSearch = (location != NULL); //다음위치가 마지막이 아닐경우 계속 찾는다.
+		}
+
+	}
+	if (found) //찾았으면
+		return 1;
+	else //못 찾았으면
+	{
+		return 0;
+	}
+
+
+
+}
+
+
+
+
+
+
+
+
+
+
+template<typename T>
+SortedLinkedList<T>::SortedLinkedList(const SortedLinkedList<T>& anotherList)
+{
+	NodeType<T> *m_pCurPointer;
+	m_pList = NULL;
+	m_pCurPointer = NULL;
+	if (anotherList.m_pList == NULL)
+		return;
+	else {
+		this->m_nLength = anotherList.m_nLength;
+
+		NodeType<T> *Node1 = new NodeType<T>;
+		NodeType<T> *preNode;
+		NodeType<T> *Node2;
+		m_pList = Node1;
+		Node1->data = anotherList.m_pList->data;
+		Node1->pre = NULL;
+		Node2 = anotherList.m_pList->next;
+
+		while (Node2 != NULL)
+		{
+			Node1->next = new NodeType<T>;
+			preNode = Node1;
+			Node1 = Node1->next;
+			Node1->data = Node2->data;
+			Node1->pre = preNode;
+			Node2 = Node2->next;
+
+
+		}
+		Node1->next = NULL;
+
+	}
+
+
+}
+
+template<typename T>
+SortedLinkedList<T> SortedLinkedList<T>::operator=(const SortedLinkedList<T> &anotherList)
+{
+	MakeEmpty();
+	SortedLinkedList<T> temp(anotherList);
+	
+	return temp;
+
+}
+
+
+#endif // !_SORTED_LINKED_LIST_H
\ No newline at end of file

+#pragma once
+#ifndef _DOUBLY_ITER2_H
+#define _DOUBLY_ITER2_H
+#include"DoublyIter2.h"
+
+template <typename T>
+struct NodeType2 {
+	T data; //각 노드의 데이터
+	NodeType2* next;// 노드의 다음을 가리킬 포인터
+	NodeType2* pre;
+};
+template<typename T>
+class DoublyIter2;
+/*
+*	@bried 이 클래스는 더블소티드링크드리스트
+*/
+template<typename T>
+class UnSortedLinkedList
+{
+	friend class DoublyIter2<T>;
+public:
+	/**
+*	default constructor.
+*/
+	UnSortedLinkedList();
+
+	/**
+	*	destructor.
+	*/
+	~UnSortedLinkedList();
+	/**
+	*	@brief	깊은 복사를 위한 UnSortedLinkedList의 복사 연산자
+	*	@pre	anotherList가 초기화되어 있어야한다.
+	*	@post	anotherList와 같은 정보를 가진 리스트가 생성된다
+	*	@param	anotherList 복사하고자 하는 UnSortedLinkedList
+	*/
+	UnSortedLinkedList(const UnSortedLinkedList<T>& anotherList);
+	/**
+	*	@brief	링크드 리스트의 모든 노드를 제거한다.
+	*	@pre	None.
+	*	@post	리스트가 비워진다.
+
+	*/
+	void MakeEmpty();
+
+	/**
+	*	@brief	리스트의 길이 = 원소의 개수 를 리턴함
+	*	@pre	x
+	*	@post	리턴값이 리스트의 길이가 된다
+	*	@return	리스트의 길이 = 원소의 개수
+	*/
+	int GetLength()
+	{
+		return m_nLength;
+	}
+	/**
+	*	@brief	새로운 노드의 값을 비교하여 맞는 위치에 추가한다
+	*	@pre	List is not Full(메모리에 빈 공간이 있어야 한다)
+	*	@post	리스트에 아이템이 추가된다.
+	*	@return	추가되면 1 아니면 0
+	*	@param 추가하고자 하는 데이터값
+	*/
+	int Add(T& data);
+	/**
+	*	@brief	입력한 정보와 같은 정보를 가진 리스트의 원소를 리스트에서 삭제한다
+	*	@pre	리스트가 비어있지 않아야한다.
+	*	@post	리스트의 원소가 삭제되고 길이가 짧아진다.
+	*	@return	삭제瑛만 1 아니면 0
+	*	@param data 삭제하고자 하는 데이터값
+	*/
+	int Delete(T& data);
+	/**
+	*	@brief	리스트내의 정보를 바꾼다
+	*	@pre	리스트에 하나이상의 원소가 있어야한다.
+	*	@post	리스트내의 원소의 정보가 바뀐다
+	*	@return	작동했으면 1 아니면 0
+	*/
+	int Replace(T& data);
+	/**
+	*	@brief	리스트에서 Primarykey를 기준으로 일치하는 원소를 받아온다
+	*	@pre	리스트내의 정보가 초기화되있어야 한다
+	*	@post	키와 맞는 정보가 있으면 그것을 받아온다..
+	*	@return	찾아왔으면 1, 못찾았으면 0
+	*/
+	int Get(T& item);
+	/**
+	*	@brief	리스트가 비어있는지를 확인한다.
+	*	@pre	x
+	*	@post	x
+	*	@return 비었으면 1, 아니면 0
+	*/
+	bool IsEmpty() const
+	{
+		if (m_nLength == 0)
+			return true;
+		else
+			return false;
+	}
+
+	/**
+	*	@brief	복사 생성자를 이용한 대입 연산자
+	*	@pre	anotherList가 정의되어 있어야한다.
+	*	@post	깊은 복사된 리스트가 대입된다.
+	*	@return 복사된 리스트
+	*/
+	UnSortedLinkedList<T> operator=(const UnSortedLinkedList<T> &anotherList);
+
+private:
+	NodeType2<T> *m_pList;
+	NodeType2<T> *m_pLast;
+	int m_nLength;
+};
+
+
+
+//함수 정의부
+template<typename T>
+UnSortedLinkedList<T>::UnSortedLinkedList()
+{
+	m_nLength = 0;
+	m_pList = NULL;
+
+
+}
+template<typename T>
+UnSortedLinkedList<T>::~UnSortedLinkedList()
+{
+	MakeEmpty();//메모리누수를 막기위해 노드의 데이터를 모두 제거한다
+
+}
+template<typename T>
+void UnSortedLinkedList<T>::MakeEmpty()
+{
+	NodeType2<T> *tempptr;
+	DoublyIter2<T> iter(*this);
+	while (iter.NotNull())
+	{
+		tempptr = iter.CurPointer;
+		iter.Next();
+		delete tempptr;
+	}	//리스트내의 모든 노드를 제거
+	m_pList = NULL;
+	m_pLast = NULL;
+	m_nLength = 0;
+}
+
+template<typename T>
+int UnSortedLinkedList<T>::Add(T &data)
+{
+
+
+
+	NodeType2<T> *Node = new NodeType2<T>;
+	NodeType2<T> *Pre;
+	DoublyIter2<T> iter(*this);
+	bool Found = false;
+	T dummy;
+
+
+	Node->data = data;
+	Node->next = NULL;
+	Node->pre = NULL;
+	if (IsEmpty())	//비어있을 경우
+	{
+		m_pList = Node;
+		m_pLast = m_pList;
+		m_nLength++;	//성공적으로 추가했으므로 길이를 늘려준다
+	}
+	//list에 노드가 있을경우
+	else
+	{
+		while (1)
+		{
+
+			//Pre = m_pCurPointer;	//이전 노드를 가리키는 포인터 갱신, 첫 시작은 m_pList로 리스트의 첫부분이다
+			Pre = iter.CurPointer;
+
+			
+
+			//Node 포인터가 마지막 노드를 가리키면 그 뒤에 Node를 삽입한다.
+			if (iter.CurPointer->next == NULL)
+			{
+				iter.CurPointer->next = Node;
+				Node->pre = iter.CurPointer;
+				m_pLast = Node;
+				m_nLength++;
+				break;
+
+			}
+			iter.Next();
+
+
+		}
+
+
+
+
+	}
+
+
+	return 1;
+}
+
+template<typename T>
+int UnSortedLinkedList<T>::Delete(T& data)
+{
+	bool MoreToSearch, found;
+	NodeType2<T> *Pre = NULL;
+	DoublyIter2<T> iter(*this);
+
+	found = false;
+	MoreToSearch = iter.NotNull();
+
+	while (MoreToSearch && !found)
+	{
+		if (data == iter.CurPointer->data) //현재 가리키는 원소가 패러미터로 넣은 값과 같은가?
+		{
+			found = true;	//찾았으므로 found = true
+			if (Pre == NULL)	//찾은 항목이 첫번째 원소일경우
+			{
+				NodeType2<T>* temp = iter.CurPointer;		//첫번째 원소의 다음원소를 저장할 임시 포인터선언
+				delete m_pList;	//첫원소를 삭제한다.
+				temp->pre = NULL;
+				m_pList = temp; //찾은 항목이 첫 항목일경우 다음 원소를 첫번째 원소로 한다.
+
+			}
+			else
+			{
+
+				Pre->next = iter.CurPointer->next;
+				iter.CurPointer->next->pre = Pre;
+				delete iter.CurPointer;
+			}
+
+
+
+		}
+		else
+		{
+			Pre = iter.CurPointer;
+			iter.Next();
+			MoreToSearch = (iter.NotNull());
+
+		}	//못 찾을경우 m_CurPointer은 다음 원소를 가리킨다. 단 Pre는 현재원소를 가리킨다.	
+	}
+
+	if (found) //찾았을 경우
+	{
+		m_nLength--;
+		return 1;
+
+	}
+	else    //못 찾으면	
+		return 0;
+
+
+
+}
+
+template<typename T>
+int UnSortedLinkedList<T>::Replace(T& data)
+{
+	bool MoreToSearch, found;
+	NodeType2<T> *location;
+
+	location = m_pList;
+	found = false;
+	MoreToSearch = (location != NULL);
+
+	while (MoreToSearch && !found) //리스트의 끝이 아니면서 아직 ▣＠뺐嚥 반복한다
+	{
+		if (data == location->data) //일치하는 경우를 찾으면
+		{
+			found = true;
+			location->data = data;
+		}		//찾았으므로 found 는 true가되고 해당위치에 data값을 넣는다
+		else
+		{
+			location = location->next;
+			MoreToSearch = (location != NULL);	//리스트의 끝이 아닐경우 계속찾는다.
+
+		}	//찾지 못했을 때 다음 location으로 옮긴다.
+
+	}
+
+	if (found) //찾았을 경우
+	{
+		return 1;
+
+	}
+	else
+		return 0;		//못 찾음
+
+}
+
+template<typename T>
+int UnSortedLinkedList<T>::Get(T& data)
+{
+	bool MoreToSearch, found;
+	NodeType2<T>* location;
+
+	location = m_pList;
+	found = false;
+	MoreToSearch = (location != NULL);
+
+	while (MoreToSearch && !found)
+	{
+		if (data == location->data)		//일치하는 항목을 찾으면
+		{
+			found = true;
+			data = location->data;
+		}
+		else
+		{
+
+			location = location->next;	//못찾으면 다음위치로 민다
+			MoreToSearch = (location != NULL); //다음위치가 마지막이 아닐경우 계속 찾는다.
+		}
+
+	}
+	if (found) //찾았으면
+		return 1;
+	else //못 찾았으면
+	{
+		return 0;
+	}
+
+
+
+}
+
+
+
+
+
+
+
+
+
+
+template<typename T>
+UnSortedLinkedList<T>::UnSortedLinkedList(const UnSortedLinkedList<T>& anotherList)
+{
+	NodeType2<T> *m_pCurPointer;
+	m_pList = NULL;
+	m_pCurPointer = NULL;
+	if (anotherList.m_pList == NULL)
+		return;
+	else {
+		this->m_nLength = anotherList.m_nLength;
+
+		NodeType2<T> *Node1 = new NodeType2<T>;
+		NodeType2<T> *preNode;
+		NodeType2<T> *Node2;
+		m_pList = Node1;
+		Node1->data = anotherList.m_pList->data;
+		Node1->pre = NULL;
+		Node2 = anotherList.m_pList->next;
+
+		while (Node2 != NULL)
+		{
+			Node1->next = new NodeType2<T>;
+			preNode = Node1;
+			Node1 = Node1->next;
+			Node1->data = Node2->data;
+			Node1->pre = preNode;
+			Node2 = Node2->next;
+
+
+		}
+		Node1->next = NULL;
+
+	}
+
+
+}
+
+template<typename T>
+UnSortedLinkedList<T> UnSortedLinkedList<T>::operator=(const UnSortedLinkedList<T> &anotherList)
+{
+	MakeEmpty();
+	UnSortedLinkedList<T> temp(anotherList);
+
+	return temp;
+
+}
+
+
+#endif // !_SORTED_LINKED_LIST_H
\ No newline at end of file

+/**
+*	@mainpage	Array list.
+*				This is a simple example of Lab01 on data structures course.<br>
+*
+*				- Doxygen GUI 설정법<br>
+*				Step 1: Doxygen 으로 문서화 할 프로젝트 경로 삽입.<br>
+*				Step 2: Wizard 탭에서 Project Name 설정.<br>
+*				Step 3: Wizard 탭에서 Source code directory 에 문서화 할 소스 경로 지정 후 Scan recursively 를 체크.
+*						[Step 1] 의 경로와 같은 경로를 삽입해도 됨.<br>
+*				Step 4: Destination directory 에 문서화한 데이터가 저장될 경로 지정.<br>
+*				Step 5: Wizard 탭의 Output 에서 LaTeX 체크 해제.<br>
+*				Step 6: Run 탭의 Run doxygen 수행 후, "Doxygen has finished" 확인.<br>
+*				
+*				- 한글사용을 위해서는 Doxywizard에서 아래와 같이 설정할 것.<br>
+*				Expert 탭 -> Input (Topics 에서 선택) -> INPUT_ENCODING 을 "EUC-KR" 로 설정.
+*
+*	@date	2018-10-11
+*	@author	2016104132 안형준
+*/
+
+#include "Application.h"
+
+/**
+*	program main function for data structures course.
+*/
+int main()
+{
+	Application app;	// Program application
+	app.Run();			// run program
+	
+	return 0;
+}
\ No newline at end of file