The second scheme, and the one implemented in many production-quality C++ compilers, is a table-driven approach. This creates static tables at compile time and link time that relate ranges of the program counter to the program state with respect to exception handling.[18] Then, if an exception is thrown, the runtime system looks up the current instruction location in the tables and determines what handlers are in play and what needs to be done. This approach minimizes executive overhead for the case where an exception is not thrown. This happens at the cost of some space, but this space can be allocated into read-only, special-purpose data sections that are not loaded or relocated until an exception is actually thrown.

interface Closeable {
    void close();
}

try {
  auto f1 = open_file(get_profile_dir(username)+"file1");
  s1_ = open_socket(f1); // читаем из конфига
  auto f2 = open_file(get_profile_dir(username)+"file2");
  s2_ = open_socket(f2); // читаем из конфига
  auto f3 = open_file(get_profile_dir(username)+"file3");
  s3_ = open_socket(f3); // читаем из конфига
  auto f4 = open_file(get_profile_dir(username)+"file4");
  s4_ = open_socket(f4); // читаем из конфига
}
catch(...) {
  std::throw_with_nested( EEnvSetup(username) );
}

#include <iostream>

int func(int a){
int b=0;
if(a) b=-1;
return b;
};

int main(){

 int a=10;

if( func(a)!=0) std::cout<<"BAD \n";
else std::cout<<" Ok \n";
};

00000000004007a0 <_Z4funci>:
  4007a0:       55                      push   %rbp
  4007a1:       48 89 e5                mov    %rsp,%rbp
  4007a4:       89 7d ec                mov    %edi,-0x14(%rbp)
  4007a7:       c7 45 fc 00 00 00 00    movl   $0x0,-0x4(%rbp)
  4007ae:       83 7d ec 00             cmpl   $0x0,-0x14(%rbp)
  4007b2:       74 07                   je     4007bb <_Z4funci+0x1b>
  4007b4:       c7 45 fc ff ff ff ff    movl   $0xffffffff,-0x4(%rbp)
  4007bb:       8b 45 fc                mov    -0x4(%rbp),%eax
  4007be:       5d                      pop    %rbp
  4007bf:       c3                      retq   

00000000004007c0 <main>:
  4007c0:       55                      push   %rbp
  4007c1:       48 89 e5                mov    %rsp,%rbp
  4007c4:       48 83 ec 10             sub    $0x10,%rsp
  4007c8:       c7 45 fc 0a 00 00 00    movl   $0xa,-0x4(%rbp)
  4007cf:       8b 45 fc                mov    -0x4(%rbp),%eax
  4007d2:       89 c7                   mov    %eax,%edi
  4007d4:       e8 c7 ff ff ff          callq  4007a0 <_Z4funci>
  4007d9:       85 c0                   test   %eax,%eax
  4007db:       0f 95 c0                setne  %al
  4007de:       84 c0                   test   %al,%al
  4007e0:       74 11                   je     4007f3 <main+0x33>
  4007e2:       be f0 08 40 00          mov    $0x4008f0,%esi
  4007e7:       bf 60 10 60 00          mov    $0x601060,%edi
  4007ec:       e8 af fe ff ff          callq  4006a0 <_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc@plt>
  4007f1:       eb 0f                   jmp    400802 <main+0x42>
  4007f3:       be f6 08 40 00          mov    $0x4008f6,%esi
  4007f8:       bf 60 10 60 00          mov    $0x601060,%edi
  4007fd:       e8 9e fe ff ff          callq  4006a0 <_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc@plt>
  400802:       b8 00 00 00 00          mov    $0x0,%eax
  400807:       c9                      leaveq 
  400808:       c3                      retq

#include <iostream>

void func(int a){
int b=0;
if(a) throw 1;
throw 2;
};

int main(){

 int a=10;
try{
 func(a);
 }catch(int s)
   {
    if(s==1) std::cout<<" Ok \n";
     else std::cout<<" BAD \n";
  };
};

0000000000400a20 <_Z4funci>:
  400a20:       55                      push   %rbp
  400a21:       48 89 e5                mov    %rsp,%rbp
  400a24:       48 83 ec 20             sub    $0x20,%rsp
  400a28:       89 7d ec                mov    %edi,-0x14(%rbp)
  400a2b:       c7 45 fc 00 00 00 00    movl   $0x0,-0x4(%rbp)
  400a32:       83 7d ec 00             cmpl   $0x0,-0x14(%rbp)
  400a36:       74 22                   je     400a5a <_Z4funci+0x3a>
  400a38:       bf 04 00 00 00          mov    $0x4,%edi
  400a3d:       e8 8e fe ff ff          callq  4008d0 <__cxa_allocate_exception@plt>
  400a42:       c7 00 01 00 00 00       movl   $0x1,(%rax)
  400a48:       ba 00 00 00 00          mov    $0x0,%edx
  400a4d:       be a0 21 60 00          mov    $0x6021a0,%esi
   400a52:       48 89 c7                mov    %rax,%rdi
  400a55:       e8 86 fe ff ff          callq  4008e0 <__cxa_throw@plt>
  400a5a:       bf 04 00 00 00          mov    $0x4,%edi
  400a5f:       e8 6c fe ff ff          callq  4008d0 <__cxa_allocate_exception@plt>
  400a64:       c7 00 02 00 00 00       movl   $0x2,(%rax)
  400a6a:       ba 00 00 00 00          mov    $0x0,%edx
  400a6f:       be a0 21 60 00          mov    $0x6021a0,%esi
  400a74:       48 89 c7                mov    %rax,%rdi
  400a77:       e8 64 fe ff ff          callq  4008e0 <__cxa_throw@plt>

0000000000400a7c <main>:
  400a7c:       55                      push   %rbp
  400a7d:       48 89 e5                mov    %rsp,%rbp
  400a80:       53                      push   %rbx
   400a81:       48 83 ec 18             sub    $0x18,%rsp
  400a85:       c7 45 ec 0a 00 00 00    movl   $0xa,-0x14(%rbp)
  400a8c:       8b 45 ec                mov    -0x14(%rbp),%eax
  400a8f:       89 c7                   mov    %eax,%edi
  400a91:       e8 8a ff ff ff          callq  400a20 <_Z4funci>
  400a96:       b8 00 00 00 00          mov    $0x0,%eax
  400a9b:       eb 5b                   jmp    400af8 <main+0x7c>
  400a9d:       48 89 c3                mov    %rax,%rbx
  400aa0:       e8 4b fe ff ff          callq  4008f0 <__cxa_end_catch@plt>
  400aa5:       48 89 d8                mov    %rbx,%rax
  400aa8:       48 89 c7                mov    %rax,%rdi
  400aab:       e8 70 fe ff ff          callq  400920 <_Unwind_Resume@plt>
  400ab0:       48 83 fa 01             cmp    $0x1,%rdx
  400ab4:       74 08                   je     400abe <main+0x42>
  400ab6:       48 89 c7                mov    %rax,%rdi
  400ab9:       e8 62 fe ff ff          callq  400920 <_Unwind_Resume@plt>
  400abe:       48 89 c7                mov    %rax,%rdi
  400ac1:       e8 3a fe ff ff          callq  400900 <__cxa_begin_catch@plt>
  400ac6:       8b 00                   mov    (%rax),%eax
  400ac8:       89 45 e8                mov    %eax,-0x18(%rbp)
  400acb:       83 7d e8 01             cmpl   $0x1,-0x18(%rbp)
  400acf:       75 11                   jne    400ae2 <main+0x66>
  400ad1:       be f0 0b 40 00          mov    $0x400bf0,%esi
  400ad6:       bf 80 20 60 00          mov    $0x602080,%edi
  400adb:       e8 e0 fd ff ff          callq  4008c0 <_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc@plt>
  400ae0:       eb 0f                   jmp    400af1 <main+0x75>
  400ae2:       be f6 0b 40 00          mov    $0x400bf6,%esi
  400ae7:       bf 80 20 60 00          mov    $0x602080,%edi
  400aec:       e8 cf fd ff ff          callq  4008c0 <_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc@plt>
  400af1:       e8 fa fd ff ff          callq  4008f0 <__cxa_end_catch@plt>
  400af6:       eb 9e                   jmp    400a96 <main+0x1a>
  400af8:       48 83 c4 18             add    $0x18,%rsp
  400afc:       5b                      pop    %rbx
  400afd:       5d                      pop    %rbp
  400afe:       c3                      retq

Какие есть серьёзные аргументы против исключений и за (извиняюсь за каламбур) возврат к кодам возврата? Ведь это же ужасный код, когда после вызова каждой функции мы тут же проверяем err и если он не null, просто передаём его наверх. Это то, от чего избавляют исключения.

Оправдывает себя только для случаев, когда исключением можно обработать глобальные
сбой или ошибку, с или остановкой приложения, или его, в некотором смысле, полным перезапуском,
с какими другими входными данными и иным способом.

        int func1_1(int a)
        {
            if (a > 1000000)
                return -1;
            else
                return a + 1;
        }

        int func1_2(int a)
        {
            if (a > 1000001)
                return -1;
            else
                return func1_1(a);
        }

        int func1_3(int a)
        {
            if (a > 1000002)
                return -1;
            else
                return func1_2(a);
        }

        int func1_4(int a)
        {
            if (a > 1000003)
                return -1;
            else
                return func1_3(a);
        }

        int func1_5(int a)
        {
            if (a > 1000004)
                return -1;
            else
                return func1_4(a);
        }

        int func2_1(int a)
        {
            if (a > 1000000)
                throw new Exception("qq");

            return a + 1;
        }

        int func2_2(int a)
        {
            return func2_1(a);
        }

        int func2_3(int a)
        {
            return func2_2(a);
        }

        int func2_4(int a)
        {
            return func2_3(a);
        }

        int func2_5(int a)
        {
            return func2_4(a);
        }

        private string Run(string title, int max)
        {
            var start1 = DateTime.Now;
            int res1 = 0;
            for (int i = 0; i < max; i++)
            {
                res1 += func1_5(i);
            }
            var end1 = DateTime.Now;

            var start2 = DateTime.Now;
            int res2 = 0;
            for (int i = 0; i < max; i++)
            {
                int val;
                try
                {
                    val = func2_5(i);
                }
                catch
                {
                    val = -1;
                }
                res2 += val;
            }
            var end2 = DateTime.Now;

            return String.Format("{0}: {1} ({2}), {3} ({4})", title, end1 - start1, res1, end2 - start2, res2);
        }

        private void button1_Click(object sender, EventArgs e)
        {
            Run("test run", 1000010);

            var line1 = Run("Single exception", 1000002);
            var line2 = Run("Two exceptions", 1000003);

            System.IO.File.WriteAllLines("D:\\temp.txt", new[] { line1, line2 });
        }

var x = null;
try{
  x = sourceFromFile('a');
  fallback x = sourceFromFile('b');
  fallback x = sourceFromFile('z');
} catch() {
...
}

void Save()
{
    ...
    if(...) throw MyException("не могу открыть файл");
    ...
    if(...) throw MyException("не могу сериализовать данные");
    ...
    if(...) throw MyException("не могу записать данные в файл");
    ...
}
...
try{
    Save();
}catch(MyException& e){
    ShowError("Не могу сохранить данные.");
}

int Save()
{
    ...
    if(...) return ERROR_OPEN;
    ...
    if(...) return ERROR_SERIAL;
    ...
    if(...) return ERROR_WRITE;
    ...
    return OK;
}
...
if(Save()!=OK) ShowError("Не могу сохранить данные.");

BOOL X();
BOOL Y();

class UserDao {
    exception SQLException translate to DaoException;

    User getUser(long id) throws DaoException {
        //code can cause SQL exception
    }
}

class CloseException extends Exception {};

interface Closeable {
    void close() throws CloseException;
}

From the caller's perspective, language support for unchecked exceptions means something like:
"On any function call, instead of returning with a result with the expected type, a function may have the effect of running any destructors in scope, and then exiting the function to repeat the process, skipping all the actual instructions you wanted to execute or returning the type you were specified to return. Were you doing anything but calling functions in a linear sequence? I hope not, because the order in which they were called is going to affect your program's behavior now! Don't like it? Too bad!

So anyway, you never know whether this will happen or not. It's totally nondeterministic. You have no idea how often it happens, whether it's supposed to happen, if it can happen at all, anything. It's okay, though, because you can totally plan ahead and wrap it in a try block, and then if you have a "catch" block that accepts a type T, it might be called with data of that type, instead of returning from the function!
It might not, though. You don't really know. Make sure your code works if it does or doesn't.
But wait, if you have a finally clause after your try, that always runs, whether an exception was thrown or not! I mean, even if you return in the middle of the function, this block still runs! So that's pretty useful, no gotchas there! It's really nice, because it's the only part of this system where you can just write straightforward code!
(Just don't, like, call any functions or anything, because if you do that you might overwrite the exception type. Well, I guess you don't know if there's an exception type in scope or not. I guess just be, like, extra careful? Oh, and don't return in the finally block, that's bad news, that swallows the type too. Actually, don't do any nontrivial control flow at all. Okay, maybe it's not totally like normal code.)
Anyway, any time you call a function, make sure you keep all that in mind! And make sure that none of the above listed ways you can exit from your function can ever leave any of your state inconsistent in a way that violates the caller's expected invariants, because it would be pretty embarrassing if the caller decided to catch the exception at an inopportune moment! Oh, and make sure any destructors in scope also can't operate on their types while they're in an inconsistent state, or that could cause extreme terribleness!"
You have to think about this for every function call. And that's just the tip of the iceberg. I didn't even go into the various ways that exceptions screw you over in practice. Let's take Java, for example (which does not have destructors and does have checked exceptions, which are actually somewhat tolerable):

* Unchecked exceptions can actually happen basically anywhere. Not just inside functions. Because the Java specification raises exceptions for things like stack overflows, VM internal errors, allocation failure, etc. And Java also allocates everywhere.
* By the way, implicit conversions from unboxed to boxed primitives are function calls in this context and can thus trigger these errors.
* Thanks to the magic of inheritance, you generally can't actually enumerate all the possible error types (unless you are the that one Java developer who hates OOP and makes every class final. To that Java developer: I like you!). But that's okay, because most people just create a single error type and put 30 different exceptions under it, and just throw that from all their functions. If you're lucky.
* Also, thanks to Thread.stop, checked exceptions of any type can happen anywhere.
* Also, if you catch Throwable, you screw over anyone who was listening for a different type of exception.
* ALSO, InterruptedException has special semantics where when it's caught, it unsets the isInterrupted flag. Wisely, most people just make everything a RuntimeError or an IOException and wrap the old exception, so now you lose the flag and can't see the exception!
* Did I mention that the above is what Oracle recommends you do to use exceptions with try-with-resources?
* If you call a reflection API, you just get one exception type and get to unwrap it at runtime!

Every function call.
The "elegance" of (non-typesafe) exceptions is a myth. They're awful. You use them when you don't have an alternative.

        int func1_1(int a, out int result)
        {
            result = a + 1;

            if (a > 1000000)
                return -1;
            else
                return 0;
        }

        int func1_2(int a, out int result)
        {
            if (func1_1(a, out result) == 0)
                return 0;
            else
                return -1;
        }

        int func1_3(int a, out int result)
        {
            if (func1_2(a, out result) == 0)
                return 0;
            else
                return -1;
        }

        int func1_4(int a, out int result)
        {
            if (func1_3(a, out result) == 0)
                return 0;
            else
                return -1;
        }

        int func1_5(int a, out int result)
        {
            if (func1_4(a, out result) == 0)
                return 0;
            else
                return -1;
        }

        int func2_1(int a)
        {
            if (a > 1000000)
                throw new Exception("qq");

            return a + 1;
        }

        int func2_2(int a)
        {
            return func2_1(a);
        }

        int func2_3(int a)
        {
            return func2_2(a);
        }

        int func2_4(int a)
        {
            return func2_3(a);
        }

        int func2_5(int a)
        {
            return func2_4(a);
        }

        private string Run(string title, int max)
        {
            var start1 = DateTime.Now;
            int res1 = 0;
            for (int i = 0; i < max; i++)
            {
                int val;
                func1_5(i, out val);
                res1 += val;
            }
            var end1 = DateTime.Now;

            var start2 = DateTime.Now;
            int res2 = 0;
            try
            {
                for (int i = 0; i < max; i++)
                {
                    res2 += func2_5(i);
                }
            }
            catch
            {
                // do nothing
            }
            var end2 = DateTime.Now;

            return String.Format("{0}: {1} ({2}), {3} ({4})", title, end1 - start1, res1, end2 - start2, res2);
        }

        private void button1_Click(object sender, EventArgs e)
        {
            Run("test run", 1000010);

            var line1 = Run("Single exception", 1000002);
            var line2 = Run("Two exceptions", 1000003);

            System.IO.File.WriteAllLines("D:\\temp.txt", new[] { line1, line2 });
        }

_>auto f1 = open_file(get_profile(username));
_>if(!f1) f1=open_file(get_default_profile());
_>s1_ = open_socket(f1); // читаем из конфига
_>

try {
  try {
    f1 = open_file(get_profile(username));
  } catch (...) {
    f1 = open_file(get_default_profile());
  }
  s1_ = open_socket(f1); // читаем из конфига
}
catch(...) { std::throw_with_nested( EEnvSetup(username) ); }

auto get_profile_or_default(string username)
{
  try {
    return open_file(get_profile(username));
  } catch(...) {
    return open_file(get_default_profile());
  }
}

try {
  f1  = get_profile_or_default(username);
  s1_ = open_socket(f1); // читаем из конфига
}
catch(...) { std::throw_with_nested( EEnvSetup(username) ); }

bool OpenSocket(string fileName, out int handle)
{
    handle = -1;

    var f = open_file(get_profile_dir(username) + fileName);

    if (f < 0)
    {
        Log.Write(GetLastErrorInfo());
        return false;
    }

    handle = open_socket(f);

    if (handle < 0)
    {
        Log.Write(GetLastErrorInfo());
        return false;
    }

    return true;
}

bool OpenAll()
{
    return
        OpenSocket("file1", out s1_) &&
        OpenSocket("file2", out s2_) &&
        OpenSocket("file3", out s3_) &&
        OpenSocket("file4", out s4_);
}

using(var stream = openSerializationStream())
{
  stream.Write("Customer", customer);
  if (customer.Status < Status.Ready)
    return; // #1 - no data saved for the not ready customers

  var orders = Orders.GetOrders(customer) ;
 
  if (orders.Length==0)
    return; #2 - nothing to save
  stream.Write("OrdersTotal", orders.Total(o=>o.Amount));
  foreach(var o in orders)
    if (o.Status != Status.Ready)
       break; # 3 - list all ready orders, then exit
    else
       stream.Write("Order #"+o.Id, o);
}

J>Типа ты вызываешь функцию для долгого расчета интеграла, а в ответ получаешь ошибку "не смогли восстановить курсор-стрелочку".