C++ C++；如何处理对象构图中出现的深层错误？

在这里，每个新方法调用都必须针对错误进行检查，这真的。。。至少慢一点。 我在考虑异常，但我读到它们不适合处理错误。 例如，若我将抛出异常，我必须使用堆栈上的前一个方法来处理它，因为否则可能会有局部变量指向该方法中分配的空间，所以我不能跳过它。 那么有什么好办法吗

class A {
  int method() {
     ...; 
     return 1;
  }
};

class B {
  A a;
  int method() {
    int err = a.method();
     if (err == 1) {
       ...;
       return ret;
     }
  }
};

class C {
  B b;
  int method() {
     int err = b.method();
     if (err == 1) {
       ...;
       return ret;
     }
   }
};

int main() {
  C c;
  int err = c.method();
  if (err == 1) {}
  return 0;  
}

A类
{void方法（）
{
}
};
B类
{A A；
void方法（）
{a.方法（）；
}
};
C类
{B；
void方法（）
{b.方法（）；
}
};
int main（）
{试试看
{C；
c、 方法（）；
返回0；
}捕获（const std:：exception&e）
{std:：cerr我可以想到以下方法来处理函数中的深层错误——不管它们是由对象组合还是函数层引起的，都是无关的

方法1：在低级函数中深入抛出异常。

struct my_error_A {};

class A {
  void method() {
      if ( ... )
      {
         throw my_error_A();
      }
     ...; 
  }
};

struct my_error_B {};

class B {
  A a;
  void method() {
    a.method();
       ...;
      if ( ... )
      {
         throw my_error_B();
      }
  }
};

struct my_error_C {};

class C {
  B b;
  void method() {
     b.method();
       ...;
      if ( ... )
      {
         throw my_error_C();
      }
   }
};

int main() {
  C c;
  try
  {
     c.method();
  }
  catch (my_error_A err)
  {
     // Deal with errors from A.
  }

  catch (my_error_B err)
  {
     // Deal with errors from B.
  }

  catch (my_error_C err)
  {
     // Deal with errors from C.
  }

  catch (...)
  {
     // Deal with all othe exceptions.
  }

  return 0;  
}

int globalErrorCode = 0;

class A {
    void method() {
        a.method();
        ...;
        if ( ... )
        {
           globalErrorCode = A::errorCode;
        }
    }
  static int errorCode;
};

class B {
  A a;
  void method() {
      a.method();
      if ( globalErrorCode != 0 )
      {
         return;
      }
      ...;
      if ( ... )
      {
         globalErrorCode = B::error_code;
         return;
      }
      ...;
  }
  static int errorCode;
};

class C {
  B b;
  void method() {
      b.method();
      if ( globalErrorCode != 0 )
      {
         return;
      }
      ...;
      if ( ... )
      {
         globalErrorCode = C::error_code;
         return;
      }
      ...;
  }
  static int errorCode;
};

int main() {
  C c;
  c.method();
  if ( globalErrorCode != 0 )
  {
     // Deal with error code.
  }
  return 0;  
}

class A {
  int method() {
      if ( ... )
      {
         return A::errorCode;
      }
     ...; 
  }
  static int errorCode;
};

class B {
  A a;
  int method() {
      int err = a.method();
      if ( err != 0 )
      {
         return err;
      }
      ...;
      if ( ... )
      {
         return B::errorCode;
      }
  }

  static int errorCode;
};

class C {
    B b;
    int method() {
        int err = b.method();
        if ( err != 0 )
        {
           return err;
        }
        ...;
        if ( ... )
        {
           return C::errorCode;
        }
    }
    static int errorCode;
};

int main() {
  C c;
  int err = c.method();
  if ( err != 0 )
  {
     // Deal with errors
  }

  return 0;  
}

方法2：使用全局错误代码保持器跟踪错误。

struct my_error_A {};

class A {
  void method() {
      if ( ... )
      {
         throw my_error_A();
      }
     ...; 
  }
};

struct my_error_B {};

class B {
  A a;
  void method() {
    a.method();
       ...;
      if ( ... )
      {
         throw my_error_B();
      }
  }
};

struct my_error_C {};

class C {
  B b;
  void method() {
     b.method();
       ...;
      if ( ... )
      {
         throw my_error_C();
      }
   }
};

int main() {
  C c;
  try
  {
     c.method();
  }
  catch (my_error_A err)
  {
     // Deal with errors from A.
  }

  catch (my_error_B err)
  {
     // Deal with errors from B.
  }

  catch (my_error_C err)
  {
     // Deal with errors from C.
  }

  catch (...)
  {
     // Deal with all othe exceptions.
  }

  return 0;  
}

int globalErrorCode = 0;

class A {
    void method() {
        a.method();
        ...;
        if ( ... )
        {
           globalErrorCode = A::errorCode;
        }
    }
  static int errorCode;
};

class B {
  A a;
  void method() {
      a.method();
      if ( globalErrorCode != 0 )
      {
         return;
      }
      ...;
      if ( ... )
      {
         globalErrorCode = B::error_code;
         return;
      }
      ...;
  }
  static int errorCode;
};

class C {
  B b;
  void method() {
      b.method();
      if ( globalErrorCode != 0 )
      {
         return;
      }
      ...;
      if ( ... )
      {
         globalErrorCode = C::error_code;
         return;
      }
      ...;
  }
  static int errorCode;
};

int main() {
  C c;
  c.method();
  if ( globalErrorCode != 0 )
  {
     // Deal with error code.
  }
  return 0;  
}

class A {
  int method() {
      if ( ... )
      {
         return A::errorCode;
      }
     ...; 
  }
  static int errorCode;
};

class B {
  A a;
  int method() {
      int err = a.method();
      if ( err != 0 )
      {
         return err;
      }
      ...;
      if ( ... )
      {
         return B::errorCode;
      }
  }

  static int errorCode;
};

class C {
    B b;
    int method() {
        int err = b.method();
        if ( err != 0 )
        {
           return err;
        }
        ...;
        if ( ... )
        {
           return C::errorCode;
        }
    }
    static int errorCode;
};

int main() {
  C c;
  int err = c.method();
  if ( err != 0 )
  {
     // Deal with errors
  }

  return 0;  
}

方法3：在每个级别返回错误代码，并在每个级别进行处理。

struct my_error_A {};

class A {
  void method() {
      if ( ... )
      {
         throw my_error_A();
      }
     ...; 
  }
};

struct my_error_B {};

class B {
  A a;
  void method() {
    a.method();
       ...;
      if ( ... )
      {
         throw my_error_B();
      }
  }
};

struct my_error_C {};

class C {
  B b;
  void method() {
     b.method();
       ...;
      if ( ... )
      {
         throw my_error_C();
      }
   }
};

int main() {
  C c;
  try
  {
     c.method();
  }
  catch (my_error_A err)
  {
     // Deal with errors from A.
  }

  catch (my_error_B err)
  {
     // Deal with errors from B.
  }

  catch (my_error_C err)
  {
     // Deal with errors from C.
  }

  catch (...)
  {
     // Deal with all othe exceptions.
  }

  return 0;  
}

int globalErrorCode = 0;

class A {
    void method() {
        a.method();
        ...;
        if ( ... )
        {
           globalErrorCode = A::errorCode;
        }
    }
  static int errorCode;
};

class B {
  A a;
  void method() {
      a.method();
      if ( globalErrorCode != 0 )
      {
         return;
      }
      ...;
      if ( ... )
      {
         globalErrorCode = B::error_code;
         return;
      }
      ...;
  }
  static int errorCode;
};

class C {
  B b;
  void method() {
      b.method();
      if ( globalErrorCode != 0 )
      {
         return;
      }
      ...;
      if ( ... )
      {
         globalErrorCode = C::error_code;
         return;
      }
      ...;
  }
  static int errorCode;
};

int main() {
  C c;
  c.method();
  if ( globalErrorCode != 0 )
  {
     // Deal with error code.
  }
  return 0;  
}

class A {
  int method() {
      if ( ... )
      {
         return A::errorCode;
      }
     ...; 
  }
  static int errorCode;
};

class B {
  A a;
  int method() {
      int err = a.method();
      if ( err != 0 )
      {
         return err;
      }
      ...;
      if ( ... )
      {
         return B::errorCode;
      }
  }

  static int errorCode;
};

class C {
    B b;
    int method() {
        int err = b.method();
        if ( err != 0 )
        {
           return err;
        }
        ...;
        if ( ... )
        {
           return C::errorCode;
        }
    }
    static int errorCode;
};

int main() {
  C c;
  int err = c.method();
  if ( err != 0 )
  {
     // Deal with errors
  }

  return 0;  
}

异常是C++处理特殊情况的通用方法。处理错误是他们设计的。我不太清楚你的缺点是什么（他们确实有缺点）。@ Krab:半初始化，半终结——我的代码在20年前看起来类似于我知道C++异常处理。当使用异常时，由于“原始”资源管理C++允许其用户，所以可以很容易地泄漏。你可以让异常使用更安全。尽管如此，有几个C++项目，其中错误处理不例外驱动，C++的低级性质（有时在C代码中混合）。由于异常会增加程序错误时资源泄漏的脆弱性。因为我认为您所建议的代码太抽象了。至少应该提到，对象应该代表什么，以及方法应该做什么。除此之外，C++异常显然是优越的。r返回代码，特别是当堆栈深处的方法可能导致整个层次结构失败时。@krab虽然我并不反对这里提出的所有观点，但不使用异常和依赖错误代码只会使正确的错误处理变得复杂“其他人的问题”是的--将错误变量设置为静态或全局变量对于宣传初学者的设计是很有帮助的。@GrapschKnutsch，我喜欢听你设计如何处理OP的问题。@Sahu：对不起--但是避免使用全局或静态变量是我最喜欢的指导原则之一，因为我已经做了将近30年的软件设计。@GrapschKnutsch，我理解你的担忧。你的担忧在某些时间和地点是有效的——任何比家庭作业或课堂项目稍微复杂一点的事情。但是，对于小项目，使用全局变量或静态变量不会有什么坏处。值得一提的是，我已经设计软件20多年了。