clase_administradora.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# <center>Clase Administradora</center>"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "En este cuaderno realizaremos un ejemplo de una *clase administradora*. \n",
        "\n",
        "Antes de empezar con el código definamos qué es la clase administradora. Pues bien, se trata de una clase que se encarga de administrar instancias de otra que a su vez puede no tener comportamientos propios. Generalmente los objetos administrados estarán en una colección de datos."
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "El ejemplo que realizaremos en este cuaderno es una clase MediaPlayer que se encargará de administrar objetos del tipo Song definido en el cuaderno anterior.\n",
        "\n",
        "La clase MediaPlayer tendrá un vector de objetos tipo Song como su principal atributo y nos permitirá agregar canciones, mostrar canciones, buscar canciones y eliminar canciones todo a través de un menú.\n",
        "\n",
        "Comencemos agregando la definición de la clase Song del cuaderno anterior."
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#include <iostream>\n",
        "using namespace std;"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "trusted": true
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Song\n",
        "{\n",
        "public:\n",
        "    /*Constructor. Se ejecuta al momento de crear el objeto. Tiene el mismo nombre de la clase y no tiene valor de retorno*/\n",
        "    Song();\n",
        "\n",
        "    /*const del lado derecho indica que el objeto no debe cambiar durante toda la ejecución del método*/\n",
        "    string getName() const;\n",
        "    /*Recibe referencia constante a una cadena. Las cadenas pueden ser datos muy grandes por eso lo recibimos como referencia*/\n",
        "    void setName(const string& value);\n",
        "\n",
        "    string getArtist() const;\n",
        "    void setArtist(const string& value);\n",
        "\n",
        "    int getYear() const;\n",
        "    void setYear(int value);\n",
        "\n",
        "    int getLength() const;\n",
        "    void setLength(int value);\n",
        "\n",
        "private: //Los atributos deben ser privados\n",
        "    string name;\n",
        "    string artist;\n",
        "    int year;\n",
        "    int length;\n",
        "};"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "Song::Song()\n",
        "{\n",
        "    //Constructor. Podemos dar valor inicial a los atributos\n",
        "    name = \"\";\n",
        "    artist = \"\";\n",
        "    year = 0;\n",
        "    length = 0;\n",
        "}\n"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "trusted": true
      }
    },
    {
      "cell_type": "code",
      "source": [
        "string Song::getName() const\n",
        "{\n",
        "    return name;\n",
        "}"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "void Song::setName(const string& value)\n",
        "{\n",
        "    name = value;\n",
        "}"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "trusted": true
      }
    },
    {
      "cell_type": "code",
      "source": [
        "string Song::getArtist() const\n",
        "{\n",
        "    return artist;\n",
        "}"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "void Song::setArtist(const string& value)\n",
        "{\n",
        "    artist = value;\n",
        "}"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "int Song::getYear() const\n",
        "{\n",
        "    return year;\n",
        "}"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "void Song::setYear(int value)\n",
        "{\n",
        "    year = value;\n",
        "}"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "int Song::getLength() const\n",
        "{\n",
        "    return length;\n",
        "}"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "void Song::setLength(int value)\n",
        "{\n",
        "    length = value;\n",
        "}"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "trusted": true
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Revisando la clase Song, nos podemos dar cuenta que no tiene comportamientos propios y de ahí la necesidad de otra clase que se encargue de administrar lo que sucede con sus instancias.\n",
        "\n",
        "Ahora agreguemos la declaración de la clase MediaPlayer"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#include <iostream>\n",
        "#include <vector>\n",
        "#include <algorithm>\n",
        "\n",
        "class MediaPlayer\n",
        "{\n",
        "public:\n",
        "    MediaPlayer();\n",
        "\n",
        "    void addSong();\n",
        "    void showSongs() const;\n",
        "    void searchSong() const;\n",
        "    void deleteSong();\n",
        "    void menu();\n",
        "private:\n",
        "    //Vector de canciones\n",
        "    vector<Song> songs;\n",
        "\n",
        "    enum options\n",
        "    {\n",
        "        OPT_EXIT,\n",
        "        OPT_ADD_SONG,\n",
        "        OPT_SHOW_SONGS,\n",
        "        OPT_SEARCH_SONG,\n",
        "        OPT_DELETE_SONG\n",
        "    };\n",
        "};"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "A continuación definiremos uno a uno los métodos de la clase MediaPlayer que nos permitirán controlar lo qué sucede con las canciones en nuestro programa."
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "MediaPlayer::MediaPlayer()\n",
        "{\n",
        "  //Constructor\n",
        "}"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "void MediaPlayer::addSong()\n",
        "{\n",
        "    //Canción que será agregada\n",
        "    Song s;\n",
        "    //Variables para cada atributo de la canción\n",
        "    string name;\n",
        "    string artist;\n",
        "    int year;\n",
        "    int length;\n",
        "\n",
        "    //Solicitud de datos\n",
        "    cout <<\"Nombre: \";\n",
        "    getline(cin, name);\n",
        "    cout <<\"Artista: \";\n",
        "    getline(cin, artist);\n",
        "    cout <<\"Año: \";\n",
        "    cin >>year;\n",
        "    cout <<\"Duración: \";\n",
        "    cin >>length;\n",
        "\n",
        "    //Construimos la canción con los datos ingresados\n",
        "    s.setName(name);\n",
        "    s.setArtist(artist);\n",
        "    s.setYear(year);\n",
        "    s.setLength(length);\n",
        "\n",
        "    //Se agrega la canción al final del vector\n",
        "    songs.push_back(s);\n",
        "    cout <<\"Canción agregada con éxito.\" <<endl <<endl;\n",
        "}"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "void MediaPlayer::showSongs() const\n",
        "{\n",
        "    //Recorremos el vector de canciones con un ciclo\n",
        "    for (size_t i(0); i < songs.size(); ++i)\n",
        "    {\n",
        "        //Para cada canción usamos los métodos get de cada atributo.\n",
        "        cout <<songs.at(i).getName() <<\" - \" <<songs.at(i).getArtist() <<\" (\"\n",
        "            <<songs.at(i).getYear() <<\") : \" <<songs.at(i).getLength()\n",
        "           <<\" segundos\" <<endl\n",
        "          <<\"~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 \" <<endl;\n",
        "    }\n",
        "}"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "void MediaPlayer::searchSong() const\n",
        "{\n",
        "    /*\n",
        "     * Realizamos la búsqueda por coincidencias de patrones. Utilizaremos la \n",
        "     * función find_if de la biblioteca <algorithm> que nos permitirá identificar\n",
        "     * cuando encontremos la canción busqueda.\n",
        "     */\n",
        "    string pattern;\n",
        "    int coincidences = 0;\n",
        "    //iterador constante para el vector de canciones.\n",
        "    vector<Song>::const_iterator it = songs.begin();\n",
        "\n",
        "    cout <<\"Nombre: \";\n",
        "    getline(cin, pattern);\n",
        "\n",
        "    //Mientras el iterador no llegue a la última posición\n",
        "    while(it != songs.end())\n",
        "    {\n",
        "        /*\n",
        "         * find_if recibe desde donde queremos realizar la búsqueda, seguido de\n",
        "         * hasta donde se realizará la búsqueda y como siguiente argumento \n",
        "         * una función de evaluación. En nuestro caso esa función será una\n",
        "         * función lambda que permitirá realizar la búsqueda por coincidencia\n",
        "         * de patrones en el nombre de cada canción.\n",
        "         * La función lambda que utilizamos recibe entre corchetes y como referencia\n",
        "         * el patrón buscado, posteriormente aparecen unos paréntesis en los cuales\n",
        "         * indicamos con que tipo de dato trabaja la función que en nuestro caso\n",
        "         * será una Song que llaremos s, después el tipo de retorno y entre llaves\n",
        "         * el cuerpo de la función.\n",
        "         * find_if se detiene en cuanto encuentre algún elemento que cumpla con\n",
        "         * el criterio que indicamos en la función lambda.\n",
        "         */\n",
        "        it = find_if(it, songs.end(), [&pattern](Song s) -> bool\n",
        "        {\n",
        "                return s.getName().find(pattern, 0) < s.getName().length();\n",
        "        });\n",
        "        //Si find_if se detuvo en algo distinto al fin del vector.\n",
        "        if (it != songs.end())\n",
        "        {\n",
        "            //Mostramos la canción\n",
        "            cout <<(*it).getName() <<\" - \" <<(*it).getArtist() <<\" (\"\n",
        "                <<(*it).getYear() <<\") : \" <<(*it).getLength()\n",
        "               <<\" segundos\" <<endl\n",
        "              <<\"~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 \" <<endl;\n",
        "            //Aumentamos el iterador para reanudar la búsqueda en la siguiente posición\n",
        "            ++it;\n",
        "            //Aumentamos el contador de canciones encontradas.\n",
        "            ++coincidences;\n",
        "        }\n",
        "    }\n",
        "\n",
        "    //Si no se encontró ninguna canción\n",
        "    if (coincidences == 0)\n",
        "    {\n",
        "        cout <<\"No se encontró la canción.\" <<endl;\n",
        "    }\n",
        "    cout <<endl;\n",
        "}"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "void MediaPlayer::deleteSong()\n",
        "{\n",
        "    /*\n",
        "     *Para borrar una canción mostraremos un menú con todas las canciones\n",
        "     *y pediremos al usuario que selecciona una para borrar o bien 0 para\n",
        "     *cancelar.\n",
        "     */\n",
        "    size_t position;\n",
        "\n",
        "    for (size_t i(0); i < songs.size(); ++i)\n",
        "    {\n",
        "        cout <<i+1 <<\") \" <<songs.at(i).getName() <<\" - \" <<songs.at(i).getArtist()\n",
        "            <<\" (\" <<songs.at(i).getYear() <<\") : \" <<songs.at(i).getLength()\n",
        "           <<\" segundos\" <<endl\n",
        "          <<\"~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 ~𝅘𝅥𝅮 \" <<endl;\n",
        "    }\n",
        "    cout <<\"Selecciona una canción (0 cancelar): \";\n",
        "    cin >>position;\n",
        "\n",
        "    if (0 < position && position <= songs.size())\n",
        "    {\n",
        "        //Utilizamos el método erase y nos desplazamos position - 1 posiciones\n",
        "        //a partir del inicio del vector\n",
        "        songs.erase(songs.begin() + position - 1);\n",
        "        cout <<\"Canción eliminada con éxito.\" <<endl <<endl;\n",
        "    }\n",
        "    else if (position == 0)\n",
        "    {\n",
        "        cout <<\"No se eliminará ninguna canción.\" <<endl <<endl;\n",
        "    }\n",
        "    else\n",
        "    {\n",
        "        cout <<\"No existe la canción\" <<endl <<endl;\n",
        "    }\n",
        "}"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "void MediaPlayer::menu()\n",
        "{\n",
        "    //El menú cíclico para todas las opciones\n",
        "    int opt;\n",
        "\n",
        "    do\n",
        "    {\n",
        "        cout <<\"                        Reproductor\" <<endl <<endl\n",
        "            <<OPT_ADD_SONG <<\") Agregar canción\" <<endl\n",
        "           <<OPT_SHOW_SONGS <<\") Mostrar canciones\" <<endl\n",
        "          <<OPT_SEARCH_SONG <<\") Buscar canción\" <<endl\n",
        "         <<OPT_DELETE_SONG <<\") Borrar canción\" <<endl\n",
        "        <<OPT_EXIT <<\") Salir\" <<endl\n",
        "        <<\"Selecciona una opción: \";\n",
        "        cin >>opt;\n",
        "        cin.ignore();\n",
        "\n",
        "        switch (opt)\n",
        "        {\n",
        "        case OPT_ADD_SONG:\n",
        "            cout <<\"                        Agregar Canción\" <<endl;\n",
        "            addSong();\n",
        "            break;\n",
        "        case OPT_SHOW_SONGS:\n",
        "            cout <<\"                        Mostrar Canciones\" <<endl;\n",
        "            if (songs.size() > 0)\n",
        "            {\n",
        "                showSongs();\n",
        "            }\n",
        "            else\n",
        "            {\n",
        "                cout <<\"No hay canciones registradas.\" <<endl <<endl;\n",
        "            }\n",
        "            break;\n",
        "        case OPT_SEARCH_SONG:\n",
        "            cout <<\"                        Buscar Canción\" <<endl;\n",
        "            if (songs.size() > 0)\n",
        "            {\n",
        "                searchSong();\n",
        "            }\n",
        "            else\n",
        "            {\n",
        "                cout <<\"No hay canciones registradas.\" <<endl <<endl;\n",
        "            }\n",
        "            break;\n",
        "        case OPT_DELETE_SONG:\n",
        "            cout <<\"                        Eliminar Canción\" <<endl;\n",
        "            if (songs.size() > 0)\n",
        "            {\n",
        "                deleteSong();\n",
        "            }\n",
        "            else\n",
        "            {\n",
        "                cout <<\"No hay canciones registradas.\" <<endl;\n",
        "            }\n",
        "            break;\n",
        "        case OPT_EXIT:\n",
        "            cout <<\"Nos vemos...\" <<endl <<endl;\n",
        "            break;\n",
        "        default:\n",
        "            cout <<\"Opció no válida.\" <<endl <<endl;\n",
        "            break;\n",
        "        }\n",
        "    }\n",
        "    while(opt != OPT_EXIT);\n",
        "}"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "En la función principal solamente crearemos una instancia de la clase MediaPlayer y llamaremos a su método menu()"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "int main()\n",
        "{\n",
        "    MediaPlayer player;\n",
        "\n",
        "    player.menu();\n",
        "\n",
        "    return 0;\n",
        "}"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Finalmente utilizamos la función main y estamos listos para registrar canciones 𝅘𝅥𝅮 . "
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "main();"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "<a href=\"https://drive.google.com/file/d/1gCKwmemIuIGRmVx6Bjqv5SnXV1vW-2hK/view?usp=sharing\">Aquí</a> Puedes encontrar el código correspondiente a este notebook."
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    }
  ],
  "metadata": {
    "kernelspec": {
      "name": "xcpp11",
      "display_name": "C++11",
      "language": "C++11"
    },
    "language_info": {
      "codemirror_mode": "text/x-c++src",
      "file_extension": ".cpp",
      "mimetype": "text/x-c++src",
      "name": "c++",
      "version": "11"
    },
    "nteract": {
      "version": "0.25.1"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 4
}