Help me with Exceptions and improvement of class

[Calcushtag]

Here is my class. Where should I use exceptions or try catch. I am really weak at exceptions
Any design suggestion will make me happy too.

#include <iostream>
#include <string>
#include <fstream>
#include <vector>
#include <algorithm> //copy
#include <iterator> //back_inserter

/******************************************************************
 * File Handler class
 * By: //////////////////
 * Version 1.0 (c++11)
 * ***************************************************************/
class FileHandler
{
private:
    std::ofstream m_output; //output
    std::ifstream m_input;  //input
    unsigned m_iNext;   //Keep Track of returned lines
                        //container for input strings
    std::vector<std::string> m_vInputContainer;
    std::vector<std::string> m_vOutputContainer;
public:
    FileHandler():m_iNext(0){}
    ~FileHandler(){
        if(m_output.is_open()) m_output.close();
        if(m_input.is_open()) m_input.close();
    }
    
    /***************************************************************
     * INPUT File Section 
     * Functions list:
     * 1- Make a connection to file(open) and load content to container
     * 2- Empty container
     * 3- return next line in container as string
     * 4- Check if cursof reached eof
     ***************************************************************/
    
    //1- Make a connection to file(open) and load content to container
    bool Input(const std::string file_name)
    {
        //1-1- OpenFile
        m_input.open(file_name, std::ios_base::in);
        //Fast Error checking
        bool fileConnectionState = m_input.good();
        //1-2-IF connection is OK get file's contect line by line to container
        if(fileConnectionState)
        {
            std::string line;
            while(std::getline(m_input, line))
            {
                m_vInputContainer.push_back(line);
            }
            //After loading file content close the file
            m_input.close();
        }
        //1-3- return file state. True means file is Opend and Content loaded at
        //container
        return fileConnectionState;
    }
    
    //2- empty container
    void clearContainer()
    {
        m_vInputContainer.erase(m_vInputContainer.begin(), m_vInputContainer.end());
        //set line tracker for next use
        m_iNext = 0;
    }
    
    //3- return next line in container as string
    std::string Next()
    {
        return m_vInputContainer.at(m_iNext++);
    }
    
    //4- Check if cursof reached eof
    bool reachedEnd()
    {
        // Return true if reached eof
        return m_iNext >= m_vInputContainer.size();
    }
    
    /*****************************************************
     * OutPut File Section
     * Fuinction list:
     * 1- Opent out put file :@priavate
     * 2- Add to output container
     * 3- Copy input container to output container
     * 4- write  output container to file
     *****************************************************/
     //1- Opent output file: @private
private:
     bool output(const std::string filename)
     {
         m_output.open(filename, std::ios_base::out);
         return m_output.is_open();
     }
     //In case appending to output
     bool appendOutput(const std::string filename)
     {
         m_output.open(filename, std::ios_base::out|std::ios_base::app);
         return m_output.is_open();
     }

public:
     //2-Add to output container
     void addToOutputContainer(std::string str)
     {
         m_vOutputContainer.push_back(str);
     }
     
     //3- Copy input container to output container
     void copyInputToOutput()
     {
         std::copy(m_vInputContainer.begin(), m_vInputContainer.end(), std::back_inserter(m_vOutputContainer));
     }
     
     //4- write output container to file
     void writeToOutput(std::string filename)
     {
         output(filename);
         for(auto& x: m_vOutputContainer)
         {
             m_output << x << std::endl;
         }
         m_output.close();
     }
     
     //In case appending
     void appendToOutput(std::string filename)
     {
         appendOutput(filename);
         for(auto& x: m_vOutputContainer)
         {
             m_output << x << std::endl;
         }
         m_output.close();
     }
    
};

[cire]

Any design suggestion will make me happy too.

What is the motivation for this class?

[Cubbi]

Where should I use exceptions

You are already using them. FileHandler::input, FileHandler::addToOutputContainer, FileHandler::copyInputToOutput can throw std::bad_alloc, and FileHandler::next can throw std::out_of_range.

Since your constructor doesn't do anything meaningful and there is no invariant I can see, there is no reason to throw your own. Well, since you're calling fstream::close directly (why?), you could pretend your invariant is that both member streams are closed (why are they members?) and throw if close fails.

In general, see http://en.cppreference.com/w/cpp/language/exceptions#Usage for exception usage.

or try catch

not in this class

[Calcushtag]

What is the motivation for this class?

Just a fun class for practice And personal usage

You are already using them. FileHandler::input, FileHandler::addToOutputContainer, FileHandler::copyInputToOutput can throw std::bad_alloc, and FileHandler::next can throw std::out_of_range.

Wow thats really helped. I thought I should do it for every single line of code my self. Thanks stl and thanks cubbi

[ajith mk]

You are confused about this because you are the person designing the class and you are the person using it. Exceptions doesn't make sense here. Use error codes. Exceptions are more useful when your are using someone else's code and you want at least well defined exit if his/her code encounters something nasty (exceptions).

If you are using that for the sake of learning, think how you might help convey the problem if anything happens, to your code user. And then design your exceptions around that concept.

[dhayden]

When designing a class, I find it helpful to think that the methods should not "do the work." Instead they should "make doing the work easy." If you think this way, you'll end up with a much more flexible class. Consider for example:

What if I want to write some stuff to a file, then write your class to the file, then write some more stuff myself? Right now I'd have to write my data, close the file, tell your class to append, then open the file again in append mode, then continue writing. Yuck.

What if I have already read the file into a string and want to use your class to process the contents of the string? I have to write the string to a file and then use your class.

To avoid these problems, the class should be a StreamHandler instead of a FileHandler. Anywhere you have a file stream, it should just be a stream instead. Don't open/close the streams in the class - let the caller do that.

[Calcushtag]

dhayden:......
ajith mk:......

I am coding just for fun for myself. Never been in actual programming projects. I need more study