CB100

 #include <iostream>
 #include <sstream>
 #include <cctype>
 
 #define    CHANNELS_MAX    140
 
 class Channel {
 private:
     Channel* next;
     Channel* prev;
     unsigned int index;
     unsigned int volume;
     unsigned int maxVolume;
     bool mute;
 
 public:
     /**
      * post: initializes the Channel
      */
     Channel() {
         next = prev = NULL;
         index = 0;
         maxVolume = volume = 50; // initialize channel volume at 50%
         mute = false;
     }
 
     /**
      * post: clears memory calling next destructor
      */
     virtual ~Channel() {
         delete this->next;
     }
 
     /**
      * pre: the Channel must be initialized
      * post: sets the Channel index to `index`
      */
     void setChannelIndex(unsigned int index) {
         this->index = index;
     }
 
     /**
      * pre: the Channel must be initialized
      * post: toggles the mute bool variable
      */
     void toggleMute() {
         this->mute = !this->mute;
     }
 
     /**
      * pre: the Channel must be initialized
      * post: sets the Channel mute to `true`
      */
     void setMute() {
         this->mute = true;
     }
 
     /**
      * pre: the Channel must be initialized
      * post: sets the Channel mute to `false`
      */
     void unsetMute() {
         this->mute = false;
     }
 
     /**
      * pre: the Channel must be initialized
      * post: returns the `mute` variable status
      */
     bool getMute() {
         return this->mute;
     }
 
     /**
      * pre: the Channel must be initialized
      * post: returns the `index` variable status
      */
     unsigned int getIndex() {
         return this->index;
     }
 
     /**
      * pre: the Channel must be initialized
      * post: returns the `volume` variable status
      */
     unsigned int getVolume() {
         return this->volume;
     }
 
     /**
      * pre: the Channel must be initialized
      * post: sets the Channel volume to `volume`
      */
     void setVolume(int volume) {
         if(volume > 100) {
             this->volume = 100;
             maxVolume = 100;
         }
         else if(volume < 0) {
             this->volume = 0;
         } else {
             this->volume = volume;
             if(volume > (int)this->maxVolume) {
                 maxVolume = volume;
             }
         }
     }
 
     /**
      * pre: the Channel must be initialized
      * post: returns the Channel `maxVolume`
      */
     unsigned int getMaxVolume() {
         return this->maxVolume;
     }
 
     /**
      * pre: the Channel must be initialized
      * post: sets the Channel `next` to `next`
      */
     void setNextChannel(Channel *next) {
         this->next = next;
     }
 
     /**
      * pre: the Channel must be initialized
      * post: sets the Channel `prev` to `prev`
      */
     void setPrevChannel(Channel *prev) {
         this->prev = prev;
     }
 
     /**
      * pre: the Channel must be initialized
      * post: retuns a pointer to the previous Channel
      */
     Channel *getPrev() {
         return this->prev;
     }
 
     /**
      * pre: the Channel must be initialized
      * post: retuns a pointer to the next Channel
      */
     Channel *getNext() {
         return this->next;
     }
 };
 
 class Television {
 private:
     Channel *channelList;
     Channel *currentChannel;
 
 public:
     /**
      * post: initializes `Television` and all the Channels in `channelList`
      */
     Television() {
         channelList = new Channel;
         currentChannel = channelList;
         channelList->setChannelIndex(0);
 
         Channel *prev = NULL;
         Channel *next = new Channel;
         next->setPrevChannel(channelList);
         next->setNextChannel(NULL);
         next->setChannelIndex(1);
 
         channelList->setPrevChannel(prev);
         channelList->setNextChannel(next);
 
         for(unsigned int i = 2; i < CHANNELS_MAX; ++i) {
             prev = next;
             next = new Channel;
             prev->setNextChannel(next);
             next->setPrevChannel(prev);
             next->setNextChannel(NULL);
             next->setChannelIndex(i);
         }
     }
 
     /**
      * pre: `Television` must be initialized
      * post: calls the first `channelList` destructor
      */
     virtual ~Television() {
         delete this->channelList;
     }
 
     /**
      * pre: `Television` must be initialized
      * post: returns the `currentChannel`
      */
     Channel *getCurrentChannel() {
         return this->currentChannel;
     }
 
     /**
      * pre: `Television` must be initialized
      * post: sets the `currentChannel` to the next channel if is not the last
      */
     void nextChannel() {
         if(currentChannel->getNext() != NULL) {
             currentChannel = currentChannel->getNext();
         }
     }
 
     /**
      * pre: `Television` must be initialized
      * post: sets the `currentChannel` to the previous channel if is not the first
      */
     void prevChannel() {
         if(currentChannel->getPrev() != NULL) {
             currentChannel = currentChannel->getPrev();
         }
     }
 
     /**
      * pre: `Television` must be initialized
      * post: sets the `currentChannel` to the channel with index `channelIndex`
      */
     void setChannel(int channelIndex) {
         if(channelIndex > CHANNELS_MAX) {
             channelIndex = CHANNELS_MAX;
         } else if(channelIndex < 0) {
             channelIndex = 0;
         }
 
         if(channelIndex < (int)currentChannel->getIndex()) {
             while(currentChannel->getPrev() != NULL) {
                 if((int)currentChannel->getIndex() == channelIndex) {
                     break;
                 }
                 currentChannel = currentChannel->getPrev();
             }
         } else if(channelIndex >= (int)currentChannel->getIndex()) {
             while(currentChannel->getNext() != NULL) {
                 if((int)currentChannel->getIndex() == channelIndex) {
                     break;
                 }
                 currentChannel = currentChannel->getNext();
             }
         }
     }
 
 
     /**
      * pre: `Television` must be initialized
      * post: mutes the `currentChannel`
      */
     void muteChannel() {
         currentChannel->setMute();
     }
 
     /**
      * pre: `Television` must be initialized
      * post: unmutes the `currentChannel`
      */
     void unmuteChannel() {
         currentChannel->unsetMute();
     }
 
     /**
      * pre: `Television` must be initialized
      * post: toggles the mute for the `currentChannel`
      */
     void toggleMuteChannel() {
         currentChannel->toggleMute();
     }
 
     /**
      * pre: `Television` must be initialized
      * post: raises the volume of the `currentChannel`
      */
     void raiseVolume() {
         currentChannel->setVolume(currentChannel->getVolume() + 10);
     }
 
     /**
      * pre: `Television` must be initialized
      * post: lowers the volume of the `currentChannel`
      */
     void lowerVolume() {
         currentChannel->setVolume(currentChannel->getVolume() - 10);
     }
 
     /**
      * pre: `Television` must be initialized
      * post: sets the volume of the `currentChannel` to `volume`
      */
     void setVolume(unsigned int volume) {
         currentChannel->setVolume(volume);
     }
 
     /**
      * pre: `Television` must be initialized
      * post: prints the main atributes of `Television` to `stdout`
      */
     void printStatus() {
         std::cout << "channel:    " << this->currentChannel->getIndex()+1<< std::endl;
         std::cout << "volume:   " << this->currentChannel->getVolume() << "%\n";
         std::cout << "mute:   "
             << (this->currentChannel->getMute() ? "true" : "false") << std::endl;
     }
 };
 
 void printHelp() {
     std::cout
         << "television simulator\n"
         << "list of valid keys:\n"
         << "  `+`: raise volume\n"
         << "  `-`: lower volume\n"
         << "  `m`: toggle mute\n"
         << "  `n`: next channel\n"
         << "  `c`: change to channel by index\n"
         << "  `p`: previous channel\n"
         << "  `q`: close\n\n";
 }
 
 int main () {
     Television *tv = new Television;
     bool shouldClose = false;
     char key;
 
     tv->printStatus();
     std::cout << "press `h` for a list of valid keys\n";
     while(!shouldClose) {
         std::cout << "tv> ";
         std::cin.get(key);
 
         if(std::cin.eof()) {
             shouldClose = true;
         }
 
         if(key == '\n') {
             continue;
         }
 
         switch(key) {
         case '+':
             std::cin.ignore(1);
             tv->raiseVolume();
             tv->printStatus();
             break;
         case '-':
             std::cin.ignore(1);
             tv->lowerVolume();
             tv->printStatus();
             break;
         case 'm':
             std::cin.ignore(1);
             tv->toggleMuteChannel();
             tv->printStatus();
             break;
         case 'n':
             std::cin.ignore(1);
             tv->nextChannel();
             tv->printStatus();
             break;
         case 'p':
             std::cin.ignore(1);
             tv->prevChannel();
             tv->printStatus();
             break;
         case 'c': {
             std::cin.ignore(1);
             std::string channelIndexStr;
             int newIndex;
             std::cout << "go to channel> ";
             do {
                 std::cin.get(key);
                 if(isdigit(key)) {
                     channelIndexStr += key;
                 }
             } while(key != '\n');
             std::istringstream(channelIndexStr) >> newIndex;
             try {
                 tv->setChannel(newIndex-1);
             } catch (const char *error) {
                 std::cout << error << std::endl;
             }
             tv->printStatus();
             break;
             }
         case 'v': {
             std::cin.ignore(1);
             std::string newVolumeStr;
             int newVolume;
             std::cout << "volume> ";
             do {
                 std::cin.get(key);
                 if(isdigit(key)) {
                     newVolumeStr += key;
                 }
             } while(key != '\n');
             std::istringstream(newVolumeStr) >> newVolume;
             try {
                 tv->setVolume(newVolume);
             } catch (const char *error) {
                 std::cout << error << std::endl;
             }
             tv->printStatus();
             break;
             }
         case 'q':
             shouldClose = true;
             break;
         case 'h':
             std::cin.ignore(1);
             printHelp();
             tv->printStatus();
             break;
         case 10:
         default:
             std::cin.ignore(1);
             break;
         }
     }
 
     delete tv;
     return 0;
 }