How to Throw Errors to Functions in Dirrerent Classes in C++?

Question

I'm not sure if "throw errors to other classes" is correct to describe my question.

The example is as follows.There're two classes:

• A is a class that being used as a directory, just like a directory in the system. It has two private values call file and directory. It has a public function called mkdir, which will make a directory.It'll throw errors if dirname(what to mkdir) already exists.
• B is a class that being used as command, which also has a function called mkdir function. mkdir in B accepts two parameters: pointer to A and dirname.

How should I throw an error in A and then catch it in B ? I searched some websites but they only had instructions for throw in functions. Thanks!

Update 1:

At first I tried to write a bool function called isExist in A, and use it in B before mkdir. If isExist = true, throw errors(..);

What I'm trying to do here is to regard A as an object, and itself should throw an error if possible.

code:

class A{

private:
    file f;
    directory d;
public:
    void mkdir(const string& dirname);
}

class B {
private:
       shared_ptr<A> p;
public:
       void mkdir(shared_ptr<A>, const string&);
}

Update 2:

Ty guys for your answers, I'm much clearer right now. Here're a few useful comments provided @ molbdnilo by in case someone like me are also confused about exceptions.

I'll try to be clearer: If B::mkdir calls A::mkdir, it can catch exceptions that A::mkdir throws. If something else calls A::mkdir, B::mkdir can't notice anything at all. Exceptions have absolutely nothing to do with classes, they only concern the execution of functions. Exceptions work the same regardless of whether the function is a member of a class or not.

Besides, @el.pescado also lists a nice answer.

Answer 1

If I understand what you want to do, you can catch an exception in one class's member function, then pass it off to a member function of another class. My example below uses free functions instead of member functions, but the principle is the same:

#include <iostream>
#include <stdexcept>

using namespace std;

void HandleException(exception& exc) {
    cout << "Exception: \"" << exc.what() << "\" has been handled." << endl;
}

void DoSomethingRisky(double x) {
    if (x == 0)
        throw std::runtime_error("x must be non-zero");
    else
        cout << x << endl;
}

int main() {

    try {DoSomethingRisky(0);}
    catch (exception& exc) {
        HandleException(exc);
    }

    return 0;
}

Edit: below is an example using member functions in the style of the example from your original question:

#include <iostream>
#include <stdexcept>

using namespace std;

struct A {
    void HandleException(exception& exc) {
        cout << "Exception \"" << exc.what() << "\" has been handled." << endl;
    }
};

struct B {

    B(A* a): a_ptr(a) {}

    void DoSomethingRisky(double x) {
        try {
            if (x == 0)
                throw runtime_error("x must be non-zero");
            else
                cout << x << endl;
        }
        catch (exception& exc) {
            a_ptr->HandleException(exc);
        }
    }

    A* a_ptr;

};

int main() {

    A a;
    B b(&a);
    b.DoSomethingRisky(0);

    return 0;
}

Answer 2

If B inherits from A, and A is an abstract class never intended to be instantiated alone, you can define the implementation in the subclass, but call the "true" method in the superclass by obscuring the implementation and still handling errors in the superclass, like so (untested beyond compilation):

#include <exception>

using namespace std;

class A {
public:
  void myfunc();

protected:
  virtual void myfunc_impl() = 0;
};

class B : public A {

protected:
  void myfunc_impl() override {
    // do stuff
    throw std::exception();
  }
};

void A::myfunc() {
  try {
    myfunc_impl();
  } catch(std::exception &e) {
    // handle exception
  }
}

This is called the non virtual interface idiom (credit: @xtofl for clarifying the name!)

Answer 3

I searched some websites but they only had instructions for throw in functions.

That's because throwing exceptions from methods (a.k.a. member functions) is no different from throwing exceptions from regular functions:

// some system headers...
#include <sys/stat.h>
#include <sys/errno.h>
#include <stdio.h>

void A::mkdir(const string &dirname)
{
    int code = ::mkdir(dirname.c_str(), 0755); // calling system mkdir() function
    if (code != 0) {
        // creating directory failed

        char *message = strerror(errno); // get system errror message
        throw std::runtime_error(message); // throw exception as usual
    }
}

void B::mkdir(shared_ptr<A> a, const string &dirname)
{
    try { // call A::mkdir, any axecptions thrown there will propagate here
        a->mkdir(dirname);
    }
    catch (std::exception &e) { // catch exception as usual
        std::cout << "Creating directory failed: " << e.what() << std::endl;
    }
}