Долмашняя фонотека

 

#include "RingListNode.h"

 

// Кольцевой  список

class RingList

{

public:

 

    // Конструктор

    RingList();

 

    // Деструктор

    ~RingList();

 

    // Добавить  в список

    void Insert(Song* s);

 

    // Проверить  что пустой

    BOOL Empty() { return m_head == NULL; }

 

    // Установить указатель на первый узел

    void Reset() { m_current = m_head; }

 

    // Перевести указатель на следующий узел

    BOOL Next();

 

    // Данные текущего узла

    Song* Current() { return m_current->GetData(); }

 

    // Сортировка простым включением

    void InclusionSort(int byField);

 

    // Последовательный  поиск

    Song* Search(CString s, int byField);

 

    // Вывести  список в поток

    void OutToStream(fstream& f);

 

private:

 

    RingListNode* m_head;       // Начальный  узел

    RingListNode* m_current;    // Текущий узел

 

    // Поменять два узла местами

    void Swap(RingListNode* n1, RingListNode* n2);

};

 

Ringlist.cpp

 

#include "stdafx.h"

#include "RingList.h"

 

// Конструктор

RingList::RingList()

{

    m_head = NULL;

    m_current = NULL;

}

 

// Деструктор

RingList::~RingList()

{

    if (m_head)

        delete m_head;

}

 

// Добавить в список

void RingList::Insert(Song* s)

{

    if (m_head == NULL)

    {

        m_head = new RingListNode(s);

        m_head->SetPrev(m_head);

        m_head->SetNext(m_head);

    }

    else

    {

        RingListNode* node = new RingListNode(s);

        node->SetPrev(m_head->GetPrev());

        node->SetNext(m_head);

        m_head->GetPrev()->SetNext(node);

        m_head->SetPrev(node);

    }

 

}

 

// Перевести  указатель на следующий узел

BOOL RingList::Next()

{

    m_current = m_current->GetNext();

    return m_current != m_head;

}

 

// Сортировка  простым включением

void RingList::InclusionSort(int byField)

{

    if (Empty())

        return;

 

    Reset();

    while (Next())

    {

        RingListNode* n2 = m_current;

        RingListNode* n1 = n2->GetPrev();

        while (n2 != m_head && n2->GetData()->Compare(n1->GetData(), byField) < 0)

        {

            Swap(n1, n2);

            n1 = n2->GetPrev();

        }

    }

}

 

// Последовательный  поиск

Song* RingList::Search(CString s, int byField)

{

    if (Empty())

        return NULL;

 

    Reset();

    do

    {

        if (Current()->Compare(s, byField) == 0)

            return Current();

    }

    while (Next());

 

    return NULL;

}

 

// Вывести список  в поток

void RingList::OutToStream(fstream& f)

{

    if (!Empty())

    {

        Reset();

        do

        {

            Current()->OutToStream(f);

        }

        while (Next());

    }

}

 

// Поменять два  узла местами

void RingList::Swap(RingListNode* n1, RingListNode* n2)

{

    if (n1->GetNext() == n2 && n2->GetNext() == n1)

    {

 

    }

    else if (n1->GetNext() == n2)

    {

        n1->GetPrev()->SetNext(n2);

        n2->GetNext()->SetPrev(n1);

 

        n1->SetNext(n2->GetNext());

        n2->SetPrev(n1->GetPrev());

 

        n1->SetPrev(n2);

        n2->SetNext(n1);

    }

    else if (n2->GetNext() == n1)

    {

        n2->GetPrev()->SetNext(n1);

        n1->GetNext()->SetPrev(n2);

 

        n2->SetNext(n1->GetNext());

        n1->SetPrev(n2->GetPrev());

 

        n2->SetPrev(n1);

        n1->SetNext(n2);

    }

    else

    {

        n1->GetPrev()->SetNext(n2);

        n1->GetNext()->SetPrev(n2);

 

        n2->GetPrev()->SetNext(n1);

        n2->GetNext()->SetPrev(n1);

 

        RingListNode* n = n1->GetNext();

        n1->SetNext(n2->GetNext());

        n2->SetNext(n);

 

        n = n1->GetPrev();

        n1->SetPrev(n2->GetPrev());

        n2->SetPrev(n);

    }

 

    if (m_head == n1)

        m_head = n2;

    else if (m_head == n2)

        m_head = n1;

 

    if (m_current == n1)

        m_current = n2;

    else if (m_current == n2)

        m_current = n1;

}

 

RingListNode.h

 

#pragma once

 

#include "Song.h"

 

// Узел кольцевого  списка

class RingListNode

{

public:

 

    // Конструктор

    RingListNode(Song* s);

 

    // Деструктор

    ~RingListNode();

 

    // Данные

    Song* GetData() { return m_data; }

 

    // Предыдущий  узел

    RingListNode* GetPrev() { return m_prev; }

 

    // Изменить  предыдущий узел

    void SetPrev(RingListNode* node) { m_prev = node; }

 

    // Следующий  узел

    RingListNode* GetNext() { return m_next; }

 

    // Изменить  следующий узел

    void SetNext(RingListNode* node) { m_next = node; }

 

private:

   

    Song* m_data;           // Данные

    RingListNode* m_next;   // Предыдущий узел

    RingListNode* m_prev;   // Следующий узел

};

 

RingListNode.cpp

 

#include "stdafx.h"

#include "RingListNode.h"

 

// Конструктор

RingListNode::RingListNode(Song* s)

{

    m_data = s;

    m_prev = NULL;

    m_next = NULL;

}

 

// Деструктор

RingListNode::~RingListNode()

{

    if (m_data)

        delete m_data;

    if (m_prev)

        m_prev->SetNext(NULL);

    if (m_next)

        delete m_next;

}

 

Song.h

 

#pragma once

 

// Класс песни

class Song

{

public:

 

    // Конструктор

    Song(CString s);

 

    // Жанр

    CString GetGenre() { return m_genre; }

 

    // Исполнитель

    CString GetArtist() { return m_artist; }

 

    // Название

    CString GetName() { return m_name; }

 

    // Альбом

    CString GetAlbum() { return m_album; }

 

    // Год

    int GetYear() { return m_year; }

 

    // Вывести описание песни в поток

    void OutToStream(fstream& f);

 

    // Сравнить  два описания песни

    int Compare(Song* s, int byField);

 

    // Сравнить со строкой

    int Compare(CString s, int byField);

 

private:

 

    CString m_genre;    // Жанр

    CString m_artist;   // Исполнитель

    CString m_name;     // Название

    CString m_album;    // Альбом

    int m_year;         // Год

};

 

Song.cpp

 

#include "stdafx.h"

#include "Song.h"

 

// Прочитать  из строки

CString Read(CString s, int& pos)

{

    int n = s.Find(';', pos);

    if (n != -1)

    {

        CString str = s.Mid(pos, n - pos);

        pos = n + 1;

        return str;

    }

    else

    {

        CString str = s.Right(s.GetLength() - pos);

        return str;

    }

}

 

// Конструктор

Song::Song(CString s)

{

    int pos = 0;

    m_genre = Read(s, pos);

    m_artist = Read(s, pos);

    m_name = Read(s, pos);

    m_album = Read(s, pos);

    m_year = atoi(Read(s, pos));

}

 

// Вывести описание  песни в поток

void Song::OutToStream(fstream& f)

{

    f << m_genre << ';' << m_artist << ';' << m_name << ';' << m_album << ';' << m_year << endl;

}

 

// Сравнить два  описания песни

int Song::Compare(Song* s, int byField)

{

    switch (byField)

    {

    case 0: return m_genre.Compare(s->m_genre);

    case 1: return m_artist.Compare(s->m_artist);

    case 2: return m_name.Compare(s->m_name);

    case 3: return m_album.Compare(s->m_album);

    case 4: return m_year < s->m_year ? -1 : (m_year > s->m_year ? 1 : 0);

    }

 

    return 0;

}

 

// Сравнить со строкой

int Song::Compare(CString s, int byField)

{

    switch (byField)

    {

    case 0: return m_genre.Compare(s);

    case 1: return m_artist.Compare(s);

    case 2: return m_name.Compare(s);

    case 3: return m_album.Compare(s);

    case 4:

        {

            int year = atoi(s);

            return m_year < year ? -1 : (m_year > year ? 1 : 0);

        }

    }

 

    return 0;

}

 

StdAfx.h

 

#pragma once

 

#define VC_EXTRALEAN  // Exclude rarely-used stuff from Windows headers

 

#include <afxwin.h>         // MFC core and standard components

#include <afxext.h>         // MFC extensions

#include <afxdtctl.h>  // MFC support for Internet Explorer 4 Common Controls

#ifndef _AFX_NO_AFXCMN_SUPPORT

#include <afxcmn.h>   // MFC support for Windows Common Controls

#endif // _AFX_NO_AFXCMN_SUPPORT

 

#include <fstream.h>

#include <exception>

 

StdAfx.cpp

 

#include "stdafx.h"