Как распространять исключения из подфункций в многопоточной программе?

Вы вызываете writeToCSV() в контексте того же потока, который вызывает run(), поэтому любое исключение, которое writeToCSV() выбрасывает и не перехватывается, уже будет распространяться на run(), как и ожидалось. Для этого вам не нужно делать ничего дополнительно. Просто не делайте catch исключение вообще, а если и сделали, то просто повторно throw его (не std::rethrow_exception()). Использование std::thread в этой ситуации не имеет значения.

int run () {
  ...
  try {
    testException(file);
  } catch (const std::exception &e) {
    // this should catch whatever testException() throws...
    std::cerr << "Error: " << e.what() << std::endl;
  }
  return 0;
}

void testException(const std::string &file) {
  TestCSV csv(file);
  csv.writeToCSV(file, a, b, c);

  // or:

  try {
    TestCSV csv(file);
    csv.writeToCSV(file, a, b, c);
  }
  catch (const std::exception &e) {
    ...
    throw;
  }
}

С другой стороны, если ваш вопрос касается распространения исключений между потоками, вам следует изменить свой тест, чтобы отразить это. Перемещение writeToCSV() в std::thread было бы лучшей проверкой std::current_exception и std::rethrow_exception.

std::current_exception позволяет вам перехватить перехваченное исключение, чтобы вы могли получить к нему доступ за пределами catch. Вы можете зафиксировать исключение в исходном потоке, который его вызвал, переместить его в нужный поток, а затем вызвать std::rethrow_exception в этом потоке. В этом случае после того, как вы join ввели std::thread, если exception_ptr был назначен, например:

void testThread(const std::string &file, std::exception_ptr &exceptionPtr) {
  try {
    TestCSV csv(file);
    csv.writeToCSV(...);
  } catch (const std::exception &) {
    exceptionPtr = std::current_exception();
  }
}

void testException(const std::string &file) {
  std::exception_ptr exceptionPtr = nullptr;
  std::thread writer(testThread, file, std::ref(exceptionPtr));
  ...
  writer.join();
  if (exceptionPtr)
    std::rethrow_exception(exceptionPtr);
}

int run () {
  ...
  try {
    testException(file);
  } catch (const std::exception &e) {
    // this should catch whatever testThread() throws...
    std::cerr << "Error: " << e.what() << std::endl;
  }
  return 0;
}

Один из способов решения этой проблемы — использовать std::future для достижения результатов.

std::future<T> — это асимметричный союз между T и исключением. Когда вы вызываете .get(), он выдает исключение, если оно содержит исключение.

Есть помощники для работы с std::future, а именно std::packaged_task<R(Args...)> и std::promise<T>.

Предположим, у вас есть пул потоков, который работает с очередью задач.

Во-первых, потокобезопасная конструкция очереди:

template<class T>
struct threadsafe_queue {
  T pop();
  std::queue<T> pop_all();
  template<class Duration>
  std::optional<T> wait_or_pop( Duration );

  void push(T);
  void push_many(std::queue<T>);
private:
  auto lock() const { return std::unique_lock{m}; }
  mutable std::mutex m;
  std::condition_variable cv;
  std::deque<T> q;
};

реализация оставлена ​​на усмотрение читателя.

Затем пул потоков:

struct thread_pool {

  template<class F>
  auto queue_task( F f ) {
    using R = std::invoke_result_t<F&>;
    std::packaged_task<R()> t = std::forward<F>(f);
    std::future<R> f = t.get_future();
    q.push( std::packaged_task<void()>( std::move(t) );
    return f;
  }

  void start_thread( std::size_t n=1 );
private:
  threadsafe_queue<std::packaged_task<void()>> q;
  std::vector<std::thread> threads;
};

теперь вы передаете свои задачи thread_pool. Их сбивают с толку packaged_task. Если они выбрасывают исключение, их исключение перемещается в std::future.

Чтобы распространить исключение, вы просто вызываете .get() в будущем.

Чтобы перехватывать исключения из каждого потока, сгенерированного из основного, нам нужно создать массив исключений_ptr(s), соответствующий количеству потоков, а затем обработать исключения из каждого потока в основном потоке, как показано ниже.

#include<iostream>
#include<thread>
#include<exception>
#include<stdexcept>
#include <memory>
#include <sstream>
#include <ctime>

using namespace std;

exception_ptr eptr[10];

void f(int i)
{
    try {
        auto id = this_thread::get_id();
        cout << "Thread " << id << " sleeping ..." << '\n';
        this_thread::sleep_for(chrono::seconds(1));
        if (i & 1) {
          stringstream ss;
          ss << id ;
          string str ("Exception from " + ss.str());
          throw std::runtime_error(str.c_str());
        }
    }
    catch(...)
    {
        eptr[i] = current_exception();
    }
}

int main(int argc, char **argv)
{
  thread th[10];
  for(int i = 0; i < 10; ++i) {
    this_thread::sleep_for(chrono::seconds(1));
    th[i] = thread(f,i);
  }

  for(int i = 0; i < 10; ++i) {
    if (th[i].joinable())
      th[i].join();

    if (eptr[i]) {
      try{
            std::rethrow_exception(eptr[i]);
      }
      catch(const std::exception &ex)
      {
            std::cerr << "Thread exited with exception: " << ex.what() << "\n";
      }
    }
  }

  return 0;
}

Пример вывода:

$ ./excep_thread1
Thread 0xa000128e0 sleeping ...
Thread 0xa000229f0 sleeping ...
Thread 0xa00022b10 sleeping ...
Thread 0xa00022c10 sleeping ...
Thread 0xa000233a0 sleeping ...
Thread 0xa00023050 sleeping ...
Thread 0xa00023150 sleeping ...
Thread 0xa000234a0 sleeping ...
Thread 0xa000235a0 sleeping ...
Thread 0xa000236a0 sleeping ...
Thread exited with exception: Exception from 0xa000229f0
Thread exited with exception: Exception from 0xa00022c10
Thread exited with exception: Exception from 0xa00023050
Thread exited with exception: Exception from 0xa000234a0
Thread exited with exception: Exception from 0xa000236a0