throwing exception for a generic reason c++

Question

I have the following chunk of code in my constructor (This is just an example, the question isn't about split, rather about throwing a generic exception. Also, Boost library can't be used.

Transfer::Transfer(const string &dest){
  try{
    struct stat st;
    char * token;
    std::string path(PATH_SEPARATOR) // if it is \ or / this macro will solve it
    token = strtok((char*)dest.c_str(), PATH_SEPARATOR) // 
    while(token != NULL){
        path += token;
        if(stat(path.c_str(), &st) != 0){
            if(mkdir(path.c_str()) != 0){
                 std:string msg("Error creating the directory\n");
                 throw exception // here is where this question lies
            }
        }

        token = strtok(NULL, PATH_SEPARATOR);
        path += PATH_SEPARATOR;

    }
  }catch(std::exception &e){
       //catch an exception which kills the program
       // the program shall not continue working.
  }

}

What I want is to throw an exception if the directory does not exist and it can't be created. I want to throw a generic exception, how could I do it in C++? PS: dest has the following format:

dest = /usr/var/temp/current/tree

`token = strtok((char*)dest.c_str(), PATH_SEPARATOR) // ` ouch — chris, Jul 24 '12 at 16:30
Boost fileystem has a `create_directories` which does all of that for you for free and has nice error semantics. — Flexo, Jul 24 '12 at 16:33
@philippe, Just concerning splitting, http://stackoverflow.com/questions/236129/splitting-a-string-in-c. The problem with that line starts with the fact that `strtok` takes a `char*`, not a `const char*` for a reason. — chris, Jul 24 '12 at 16:34
@chris The question is about throwing a generic exception in `C++` — cybertextron, Jul 24 '12 at 16:35
token = strtok((char*)dest.c_str(), PATH_SEPARATOR) Another immediate stackoverflow question from you on some undefined behaviour — PermanentGuest, Jul 24 '12 at 16:35
@philippe, That's why it isn't a standalone answer. It's going to come back and bite you if you keep it. — chris, Jul 24 '12 at 16:36
If you had a question about throwing an exception, you should have omitted that big chunk of string handling code and focused on the "throw an exception" part instead. That only wastes your (because you get answers you don't want) and everyone else's time (because they have to read irrelevant code and waste effort in answers that don't help). — R. Martinho Fernandes, Jul 24 '12 at 17:05

score 16 · Accepted Answer · edited May 23 '17 at 12:31

16

Please check this answer. This explains how to use your own exception class

class myException: public std::runtime_error
{
    public:
        myException(std::string const& msg):
            std::runtime_error(msg)
        {}
};

void Transfer(){
  try{
          throw myException("Error creating the directory\n");
  }catch(std::exception &e){
      cout << "Exception " << e.what() << endl;
       //catch an exception which kills the program
       // the program shall not continue working.
  }

}

Also, if you don't want your own class, you can do this simply by

 throw std::runtime_error("Error creating the directory\n");

edited May 23 '17 at 12:31

Community

1
1

answered Jul 24 '12 at 16:44

PermanentGuest

5,213
2
27
36

7

It is a good rule of thumb to catch exceptions by constant reference. – Jul 24 '12 at 16:45
1

I would add that it's not very scalable to exit the program in various places. This certainly shouldn't be done in code that will become part of a library. It's better to just throw and have the catch in as few places as possible (e.g. main). – Anon Mail Jul 24 '12 at 16:55

score 6 · Answer 2 · edited May 23 '17 at 12:00

Your usage of strtok is incorrect - it needs a char* because it modifies the string, but it is not permitted to modify the results of a .c_str() on a std::string. The need to use a C style cast (which here is performing like a const_cast) is a big warning.

You can neatly sidestep this and the path separator portability stuff by using boost filesystem, which is likely to appear in TR2 whenever that's release. For example:

#include <iostream>
#include <boost/filesystem.hpp>

int main() {
  boost::filesystem::path path ("/tmp/foo/bar/test");
  try {
    boost::filesystem::create_directories(path);
  }
  catch (const boost::filesystem::filesystem_error& ex) {
    std::cout << "Ooops\n";
  }
}

Splits the path on the platform's separator, makes the directories if needed or throws an exception if it fails.

throwing exception for a generic reason c++

2 Answers2