Struktury zagnieżdzone w klasach. (?)

Witam, jest to mój pierwszy kontakt z programowaniem obiektowym.
Moim zadaniem jest stworzyć katalog płyt CD, tzn już stworzyłem (?), ale strukturalnie dawno, dawno temu.
Teraz chcę go przerobić na klasy. Czytałem dużo na temat klas, konstruktorów, destruktorów, widziałem trochę przykładów, ale nigdzie nie widziałem zagnieżdżeń. Nie wiem czy mam tworzyć zagnieżdżone klasy w klasach, czy w klasie zastosować strukturę.
Mam takie coś :

struct Tcena 
{
	int zl;
	int gr;
};

struct Tczas
{
	int min;
	int sec;
};

struct Tutwor
{
	char autor[30];
	char wykonawca[30];
	struct Tczas czas;
};

struct Tinfcd
{
	char tytul[50];
	char nazwisko[20];
	char nazwa[30];
	int rok;
	struct Tcena cena;
	struct Tutwor tab_tutwor[25];
};

Jak to ugryźć od strony obiektowości? Próbowałem pozostawić tak jak jest i coś tam nabazgrałem, ale stwierdziłem, że to i tak nie ma sensu.
Po prostu jak utworzyć zagnieżdżone rekordy, aby móc sprawnie posługiwać się klasami? (wypełniać je, wyświetlać, modyfikować, usuwać) ? (Z kodu wynika, że mam 10 elementową tablicę struktur Tinfcd (katalog płyt CD, w której każda płyta CD ma w sobie po 25 struktur - utworów ).

Gorąco jest, nudzi mi się ;). Chociaż pewnie prawda jest taka, że nie znając C++ i paradygmatów programowania obiektowego jedyne, co jesteś póki co w stanie zrobić to zamienić w swoim programie słówko struct na class i char x[] na std::string. Do nauki samej w sobie polecam zaopatrzenie się w podręcznik.
Ew. pytaj o konkretne rzeczy w kodzie poniżej. Starałem się pokazać jak najwięcej rzeczy różniących C i C++.

#include <iostream>
#include <vector>
#include <iterator>
#include <sstream>
#include <iomanip>
#include <numeric>

class Track
{
private:
	std::string _title;
	int _length;

public:
	Track(const std::string& title, int length) : _title(title), _length(length) { }
	Track(const std::string& title, const std::string& length) : _title(title)
	{
		std::istringstream sstream(length);

		int minutes, seconds;
		char separator;

		sstream >> minutes >> separator >> seconds;

		_length = minutes * 60 + seconds;
	}
	
	const std::string& GetTitle() const
	{
		return _title;
	}
	
	int GetLength() const
	{
		return _length;
	}

	friend std::ostream& operator<<(std::ostream& stream, const Track& track)
	{
		stream << std::setw(50) << std::left << track._title << track._length << "s";

		return stream;
	}
};

class Album
{
private:
	std::string _title;
	std::string _artist;
	int _releaseYear;
	std::vector<Track> _tracks;
public:
	typedef std::vector<Track>::iterator TrackIterator;

	Album(const std::string& title, const std::string& artist, int releaseYear) :
	  _title(title), _artist(artist), _releaseYear(releaseYear) { }
	
	// akcesory analogicznie do klasy Track + np. wystawienie iteratorów do wektora

	int GetLength() const
	{
		return std::accumulate(_tracks.begin(), _tracks.end(), 0, [] (int sum, const Track& track) {
			return sum + track.GetLength();
		});

		return 0;
	}

	void AddTrack(const Track& track)
	{
		_tracks.push_back(track);
	}

	template<typename T>
	void AddTracks(T first, T last)
	{
		std::copy(first, last, std::back_inserter(_tracks));
	}

	friend std::ostream& operator<<(std::ostream& stream, const Album& album)
	{
		stream << album._title << " (" << album._releaseYear << ") by " << album._artist << std::endl;
		
		stream << "Running time: " << album.GetLength() << "s" << std::endl;
		
		std::copy(album._tracks.begin(), album._tracks.end(), std::ostream_iterator<Track>(stream, "\n"));

		return stream;
	}
};

int main()
{
	Track tracks[] =
	{
		Track("Introduction", "0:43"),
		Track("Remember the Name (ft. Styles of Beyond)", "3:50"),
		Track("Right Now (ft. Black Thought & Styles of Beyond)", "4:14")
	};

	Album album("The Rising Tied", "Fort Minor", 2005);
	album.AddTracks(tracks, tracks + 3);

	std::cout << album;

	return 0;
}

Pierwszy krok już wykonałeś. W tym kodzie, który przytoczyłeś częściowo opisałeś klasy (podmioty) z dziedziny, którą jest biblioteka płyt CD albo coś tym guście. Skoro piszesz, że już to programowałeś tylko, że "strukturalnie" to jesteś w stanie opisać, jakie interakcje mogą zachodzić pomiędzy obiektami klas, które zacytowałeś powyżej. Np.:

1. dodaję nową płytę
2. do tej nowej płyty mogę dodać utwór taki a taki
3. mogę dodać kolejną płytę
4. mogę modyfikować utwory na danej płycie (usunąć, dodać, zmienić np. tytuł lub czas trwania)
5. mogę wyszukiwać na jakie płycie znajduje się taki a taki utwór
   itd.