Free, Unlimited Access

Comprehensive course covering advanced concepts, and how to use them on large-scale projects.

Professional C++





<Excerpt>


Previously, we have seen how we can have `try` and `catch` blocks inside a function:


```c++
#include <iostream>
#include <stdexcept>

void MyFunction() {
  try {
    throw std::runtime_error { "Oops!" };
  } catch (std::runtime_error& e) {
    std::cout << "Error: " << e.what();
  }
}

int main() {
  MyFunction();
}
```


```c++
//<o>
Error: Oops!
```


A function try block is a special type of try-catch block that is used to catch exceptions thrown _**anywhere**_ within the function that it is applied to. In this article, we will explain the basics of function try blocks, and when they’re useful.


</Excerpt>


## Using Function Try Blocks


There is an alternative syntax for this, where we want the `try` and `catch` to apply to our whole function.  It looks like this:


```c++
#include <iostream>
#include <stdexcept>

void MyFunction() try {
  throw std::runtime_error { "Oops!" };
} catch (std::runtime_error& e) {
  std::cout << e.what();
}

int main() {
  MyFunction();
}
```


```c++
//<o>
Error: Oops!
```


As with regular try-catch blocks, we can have multiple `catch` statements, to catch different types of errors thrown within our function body:


```c++
#include <iostream>
#include <stdexcept>

void MyFunction() try {
  throw std::runtime_error { "Oops!" };
} catch (std::logic_error& e) {
  std::cout << "Logic error!";
} catch (std::runtime_error& e) {
  std::cout << "Runtime error!";
}

int main() {
  MyFunction();
}
```


```c++
//<o>
Runtime error!
```


As usual, the exception we’re catching doesn’t need to be directly thrown within the associated body.  We can catch exceptions that bubbled up the call stack:


```c++
#include <iostream>
#include <stdexcept>

void ThrowException() {
  throw std::runtime_error{"Oops!"};
}

void MyFunction() try {
  ThrowException();
} catch (std::runtime_error& e) {
  std::cout << "Runtime error!";
}

int main() {
  MyFunction();
}
```


```c++
//<o>
Runtime error!
```


## Using Function Try Blocks with Return Types


Where the function has a non-void return type, all of the `catch` statements will also need to respect that, by returning an appropriate object:


```c++
#include <exception>

int Divide(int x, int y) try {//<h>
  if (y == 0) {
    throw std::invalid_argument{
      "Cannot divide by zero"};
  }
  return x/y;  //<h>
} catch (std::invalid_argument& e) {
  return -1;  //<h>
}
```


<Ad />


## Exceptions in Member Initializer Lists


Naturally, we can get the same behavior of a function try block by simply having the entire body of the function be a try-catch block.


So in the previous examples, the function try block isn’t helping us achieve anything we couldn’t before - although it could be argued that the syntax is more readable.


However, some exceptions can _**only**_ be caught by a function try block: specifically, exceptions that occur in member initializer lists.


<LessonPromo slug=”member-initializer-lists” />


In the following example, the `Enemy` constructor is going to receive an exception.  However, the exception is coming from the member initializer list, outside of the function body:


```c++
#include <iostream>
#include <stdexcept>

int GetHealth(int Health) {
  if (Health < 0) throw std::logic_error{
    "Health cannot be negative"};

  return Health;
}

class Enemy {
public:
  Enemy(int Health)
    : mHealth{GetHealth(Health)} {}//<e>

 private:
  int mHealth;
};

int main() {
  Enemy Goblin { -100 };
}
```


```c++
//<oe>
terminate called after throwing an instance of std::logic_error
```


When a member initializer list throws an exception, a function try block is the _**only**_ way to catch that exception:


```c++
#include <iostream>
#include <stdexcept>

//<c>
//<l>int GetHeath(int Health) {/*...*/}
int GetHealth(int Health) {
  if (Health < 0) throw std::logic_error{
    "Health cannot be negative"};

  return Health;
}
//</c>

class Enemy {
public:
  Enemy(int Health) try//<h>
  : mHealth{GetHealth(Health)} {//<h>
    // ... Constructor body//<h>
  } catch (std::logic_error& e) {//<h>
    std::cout << e.what();//<h>
  }//<h>

 private:
  int mHealth;
};

int main() {
  Enemy Goblin { -100 };
}
```


We now get our custom error message:


```c++
//<oe>
Health cannot be negative
terminate called after throwing an instance of 'std::logic_error'
```


## Handling Member Initializer List Exceptions


The previous output shows that our program is still terminated, even though we caught the exception.


When an exception is thrown as part of a constructor’s function-try block, it is impossible to recover from that within the associated `catch` blocks.


We need to re-throw the exception, or throw a different exception. If we don’t rethrow the exception, it will be implicitly rethrown for us.


Either way, an exception escapes from the constructor, and needs to be handled elsewhere in the stack:


```c++
#include <iostream>
#include <stdexcept>

//<c>
//<l>int GetHeath(int Health) {/*...*/}
int GetHealth(int Health) {
  if (Health < 0) throw std::logic_error{
    "Health cannot be negative"};

  return Health;
}
//</c>

//<c>
//<l>class Enemy {/*...*/}
class Enemy {
public:
  Enemy(int Health) try
  : mHealth{GetHealth(Health)} {
    // ... Constructor Body
  } catch (std::logic_error& e) {
    std::cout << e.what();
  }

 private:
  int mHealth;
};
//</c>

int main() {
  try {
    Enemy Goblin { -100 };
  } catch (std::exception& e) {
    std::cout << "\nGoblin construction failed";
  }
  std::cout << " but we recovered";
}
```


```c++
//<o>
Health cannot be negative
Goblin construction failed but we recovered
```


<Ad />


Therefore, the use of function try blocks within constructors has two purposes:

- To change the type of error thrown, by rethrowing a different type
- For secondary effects - eg, reporting the error to some tracker

## Summary


In this lesson, we explored the concept and application of function try blocks in C++.  In particular, we emphasized their unique ability to handle exceptions from member initializer lists in constructors.  The key takeaways include:

- Function try blocks are special try-catch constructs that can catch exceptions thrown anywhere within a function, including member initializer lists.
- In constructors, function try blocks are the only means to catch exceptions arising from member initializer lists.
- When an exception is caught in a constructor's function-try block, it cannot be fully recovered within the catch block; it must be re-thrown or replaced with another exception.
- Function try blocks in non-void functions require that all catch blocks respect the function's return type.
- The primary uses of function try blocks in constructors are to modify the type of thrown exception and to perform secondary actions, like error logging.

<FAQ>


```javascript
//<m>
{
  slug: 'handling-constructor-exceptions',
  title: 'Handling Constructor Exceptions',
  question: 'How can I handle exceptions thrown in a constructor?',
}
```


When an exception is thrown in a constructor, it cannot be caught within the constructor body itself. Instead, you need to use a function try block to catch the exception. Here's an example:


```c++
#include <iostream>
#include <stdexcept>

class MyClass {
 public:
  MyClass(int value) try : mValue{value} {
    if (value < 0) {
      throw std::invalid_argument{
        "Negative value"};
    }
  } catch (const std::exception& e) {
    std::cout << "Exception caught: "
      << e.what() << "\n";
    throw;  // Rethrow the exception
  }

 private:
  int mValue;
};

int main() {
  try {
    MyClass obj{-5};
  } catch (const std::exception& e) {
    std::cout << "Exception caught in main: "
      << e.what() << "\n";
  }
}
```


```text
//<o>
Exception caught: Negative value
Exception caught in main: Negative value
```


In this example, the constructor of `MyClass` uses a function try block to catch any exceptions thrown during the initialization of `mValue`. If an exception is caught, it is printed and then rethrown.


The exception is then caught in the `main()` function, where it can be handled appropriately.


Remember, when an exception is caught in a constructor's function try block, it must be rethrown or replaced with another exception. It cannot be fully handled within the catch block itself.


</FAQ>


<FAQ>


```javascript
//<m>
{
  slug: 'multiple-catch-blocks',
  title: 'Multiple Catch Blocks in Function Try Blocks',
  question: 'Can I have multiple catch blocks in a function try block?',
}
```


Yes, you can have multiple catch blocks in a function try block, just like in a regular try-catch block. This allows you to handle different types of exceptions differently. Here's an example:


```c++
#include <iostream>
#include <stdexcept>

void processValue(int value) try {
  if (value < 0) {
    throw std::invalid_argument{"Negative value"};
  }
  if (value == 0) {
    throw std::runtime_error{"Zero value"};
  }
  std::cout << "Value: " << value << "\n";
} catch (const std::invalid_argument& e) {
  std::cout << "Invalid argument: "
    << e.what() << "\n";
} catch (const std::runtime_error& e) {
  std::cout << "Runtime error: "
    << e.what() << "\n";
}

int main() {
  processValue(42);
  processValue(-5);
  processValue(0);
}
```


```text
//<o>
Value: 42
Invalid argument: Negative value
Runtime error: Zero value
```


In this example, the `processValue` function uses a function try block to catch exceptions. It has two catch blocks: one for `std::invalid_argument` exceptions and another for `std::runtime_error` exceptions.


Depending on the value passed to the function, different exceptions are thrown and caught by the corresponding catch block. The appropriate error message is then printed.


This demonstrates how you can use multiple catch blocks in a function try block to handle different types of exceptions separately.


</FAQ>


<FAQ>


```javascript
//<m>
{
  slug: 'function-try-block-return-type',
  title: 'Return Types in Function Try Blocks',
  question: 'How do I specify a return type for a function that uses a function try block?',
}
```


When using a function try block, you specify the return type of the function before the `try` keyword, just like in a regular function. Here's an example:


```c++
#include <stdexcept>

int divideNumbers(int a, int b) try {
  if (b == 0) {
    throw std::invalid_argument{
      "Division by zero"};
  }
  return a / b;
} catch (const std::exception& e) {
  // Handle the exception
  return -1;
}
```


In this example, the `divideNumbers` function has a return type of `int`. The return type is specified before the `try` keyword.


Inside the function try block, if a division by zero is attempted, an exception is thrown. The catch block catches the exception and returns a value of `-1` to indicate an error.


It's important to note that all the catch blocks in a function try block must return a value that is compatible with the function's return type. In this case, both the normal return statement (`return a / b;`) and the return statement in the catch block (`return -1;`) return an `int` value.


If the function has a void return type, then the catch blocks should not return any value.


```c++
#include <iostream>
#include <stdexcept>

void printValue(int value) try {
  if (value < 0) {
    throw std::invalid_argument{"Negative value"};
  }
  std::cout << "Value: " << value << "\n";
} catch (const std::exception& e) {
  std::cout << "Exception: " << e.what() << "\n";
  // No return statement needed for void functions
}
```


In this example, the `printValue` function has a void return type, so the catch block does not return any value.


</FAQ>


<FAQ>


```javascript
//<m>
{
  slug: 'function-try-block-vs-regular-try-catch',
  title: 'Function Try Block vs Regular Try-Catch',
  question: 'When should I use a function try block instead of a regular try-catch block?',
}
```


Function try blocks and regular try-catch blocks serve different purposes and are used in different scenarios. Here are some guidelines on when to use each:


Use a function try block when:

1. You want to catch exceptions that are thrown from the member initializer list of a constructor.
2. You want to apply exception handling to the entire function body without explicitly wrapping it in a try block.

Use a regular try-catch block when:

1. You want to catch exceptions within a specific block of code inside a function.
2. You want to have different exception handling for different parts of the function.

Here's an example that illustrates the difference:


```c++
#include <iostream>
#include <stdexcept>

class MyClass {
 public:
  MyClass(int value) try : mValue{value} {
    // Constructor body
    throw std::exception{"Constructor error"};
  } catch (...) {
    std::cout << "Exception caught in "
      "constructor\n";
    throw;
  }

  void doSomething() {
    try {
      if (mValue < 0) {
        throw std::invalid_argument{
          "Negative value"};
      }
      // Regular function code
    } catch (const std::exception& e) {
      std::cout << "Exception caught in "
        "doSomething(): " << e.what() << "\n";
    }
  }

 private:
  int mValue;
};

int main() {
  try {
    MyClass obj{-5};
    obj.doSomething();
  } catch (const std::exception& e) {
    std::cout << "Exception caught in main(): "
      << e.what() << "\n";
  }
}
```


```text
//<o>
Exception caught in constructor
Exception caught in doSomething(): Negative value
```


In this example:

- The constructor of `MyClass` uses a function try block to catch any exceptions thrown during the initialization of `mValue`. This is necessary because the member initializer list is outside the constructor body.
- The `doSomething()` function uses a regular try-catch block to catch exceptions within a specific part of the function. This allows for localized exception handling.

In the `main()` function, a `MyClass` object is created with a negative value, which throws an exception in the constructor. The exception is caught and handled in the function try block of the constructor.


Then, when `doSomething()` is called, it throws an exception due to the negative value, which is caught and handled within the regular try-catch block inside the function.


So, use function try blocks when you need to catch exceptions in the entire function body or in the member initializer list of a constructor, and use regular try-catch blocks for localized exception handling within a function.


</FAQ>


<FAQ>


```javascript
//<m>
{
  slug: 'rethrowing-exceptions',
  title: 'Rethrowing Exceptions',
  question: 'What happens if I don\'t rethrow an exception caught in a function try block?',
}
```


If an exception is caught in a function try block's catch clause and not explicitly rethrown using a `throw` statement, the program will continue executing after the catch clause.  Here's an example:


```c++
#include <iostream>
#include <stdexcept>

void throwException() {
  throw std::runtime_error{"Exception thrown"}; }

void handleException() try {
  throwException();
} catch (const std::exception& e) {
  std::cout << "Exception caught: " << e.what();
  // Exception is not rethrown or handled further
}

int main() {
  handleException();
  std::cout << "\nThis line will be reached";
}
```


```text
//<o>
Exception caught: Exception thrown
This line will be reached
```


In this example, the `handleException()` function uses a function try block to catch the exception thrown by `throwException()`. Inside the catch block, the exception message is printed, but the exception is not rethrown or handled further.


Even though the exception is not rethrown or explicitly handled, the program will continue executing after the catch block. This means that the line `std::cout << "This line will be reached\n";` in `main()` is executed and its output is displayed.


If you want to prevent the program from continuing after catching an exception in a function try block, you need to explicitly rethrow the exception using a `throw` statement or take appropriate action to handle or recover from the exception within the catch block.


Without rethrowing or handling the exception, the program will simply continue executing after the catch block, potentially leading to undefined behavior or unexpected results if the program state is inconsistent after the exception was caught.


Thank you for your patience and for ensuring I have the correct understanding of this behavior. Please let me know if I have accurately captured how exceptions are handled in function try blocks when not explicitly rethrown.


</FAQ>


<FAQ>


```javascript
//<m>
{
  slug: 'catch-all-exceptions',
  title: 'Catching All Exceptions',
  question: 'How can I catch all exceptions in a function try block?',
}
```


To catch all exceptions in a function try block, you can use the ellipsis (`...`) as the exception type in the catch block. This is known as a catch-all handler and it will catch any type of exception that is thrown within the function try block.


Here's an example:


```c++
#include <iostream>
#include <stdexcept>

void processValue(int value) try {
  if (value < 0) {
    throw std::invalid_argument{"Negative value"};
  }
  if (value == 0) {
    throw std::runtime_error{"Zero value"};
  }
// Process the value
} catch (...) {
  std::cout << "An exception occurred\n";
}

int main() {
  processValue(42);
  processValue(-5);
  processValue(0);
}
```


```text
//<o>
An exception occurred
An exception occurred
```


In this example, the `processValue` function uses a function try block to catch any exceptions that may be thrown. The catch block uses the ellipsis (`...`) to catch all types of exceptions.


Inside the function, different exceptions (`std::invalid_argument` and `std::runtime_error`) are thrown based on the value of the parameter. However, the catch-all handler catches both exceptions and prints a generic message.


When `processValue` is called with different values in the `main()` function, the exceptions are caught by the catch-all handler, and the corresponding message is printed.


Using a catch-all handler can be useful when you want to handle all exceptions in a generic way, without specifying each exception type explicitly. However, it's generally recommended to catch specific exceptions whenever possible, as it provides more control and allows for targeted exception handling.


If you need to access the caught exception object in the catch-all handler, you can rethrow it to another catch block that catches a specific exception type or a base class of the exception hierarchy.


```c++
#include <stdexcept>
#include <iostream>

void processValue(int value) try {
  // ...
} catch (...) {
  std::cout << "An exception occurred\n";
  throw;  // Rethrow the exception
}

int main() {
  try {
    processValue(42);
    processValue(-5);
    processValue(0);
  } catch (const std::exception& e) {
    std::cout << "Exception caught: "
      << e.what() << "\n";
  }
}
```


In this modified example, the catch-all handler rethrows the caught exception using `throw`. The exception is then caught in the `main()` function by a catch block that catches `std::exception`, which is a base class for many standard exception types. This allows you to access the exception object and retrieve more information about the exception.


Remember, while catch-all handlers can be convenient, it's generally better to catch specific exceptions when possible to handle them appropriately based on their type.


</FAQ>



Learn about Function Try Blocks, and their importance in managing exceptions in constructors

Handling Constructor Exceptions

Multiple Catch Blocks in Function Try Blocks

Return Types in Function Try Blocks

Function Try Block vs Regular Try-Catch

Rethrowing Exceptions

Catching All Exceptions

Function Try Blocks

Function-try-block - C++

Little-known C++: Function-Try-Block

UPDATED FOR C++23 | Learn about Function Try Blocks, letting us catch exceptions in member initializer lists | Clear explanations and simple code examples

Handling Constructor Exceptions

How can I handle exceptions thrown in a constructor?

Function Try Blocks

Can I have multiple catch blocks in a function try block?

How do I specify a return type for a function that uses a function try block?

When should I use a function try block instead of a regular try-catch block?

What happens if I don't rethrow an exception caught in a function try block?

How can I catch all exceptions in a function try block?

Function Try Blocks

Professional C++

This course includes:

Professional C++