@@ -63,17 +63,7 @@ class Exception: public std::exception
         return *this;
     }
 
-    virtual Exception* Clone() const
-    {
-        return new Exception(*this);
-    }
-
-    virtual void Throw() const
-    {
-        throw *this;
-    }
-
-    virtual const char* what() const throw()
+    virtual const char* what() const
     {
         return message.c_str();
     }
 
@@ -117,7 +117,7 @@ void ParallelForBase(RANGES ranges, Functor functor, TaskManager& manager)
     {
         if ((*it)->GetLastException() != 0)
         {
-            (*it)->GetLastException()->Throw();
+            std::rethrow_exception((*it)->GetLastException());
         }
     }
 }
 
@@ -72,11 +72,11 @@ inline void ParallelInvoke(Functor1 func1, Functor2 func2)
 
         if (task1.GetLastException() != 0)
         {
-            task1.GetLastException()->Throw();
+            std::rethrow_exception(task1.GetLastException());
         }
         if (task2.GetLastException() != 0)
         {
-            task2.GetLastException()->Throw();
+            std::rethrow_exception(task2.GetLastException());
         }
     }
     else
 
@@ -101,7 +101,7 @@ class ReduceTask : public Task
                 {
                     if (tasks[i]->GetLastException() != 0)
                     {
-                        tasks[i]->GetLastException()->Throw();
+                        std::rethrow_exception(tasks[i]->GetLastException());
                     }
                 };
 
@@ -143,7 +143,7 @@ inline void ParallelReduce(Iterator start, Iterator end, Functor& functor, size_
         manager->WaitTask(*task);
         if (task->GetLastException() != 0)
         {
-            task->GetLastException()->Throw();
+            std::rethrow_exception(task->GetLastException());
         }
     }
     else
 
@@ -68,24 +68,15 @@ class alignas(_CPP_TASK_CACHE_LINE_SIZE_) Task
         {
             Execute();
         }
-        catch(Exception& err)
-        {
-            ScopedLock<Mutex> lock(exceptionGuard);
-            lastException.reset(err.Clone());
-        }
         catch(...)
         {
-            lastException.reset(new Exception("Unknown exception"));
+            lastException = std::current_exception();
         }
     }
 
-    const Exception* GetLastException() const
+    std::exception_ptr GetLastException() const
     {
-        if (!lastException)
-        {
-            return 0;
-        }
-        return lastException.get();
+        return lastException;
     }
 
     bool CheckFinished()
@@ -125,7 +116,7 @@ class alignas(_CPP_TASK_CACHE_LINE_SIZE_) Task
     Task(const Task&) = delete;
     const Task& operator=(const Task&) = delete;
 private:
-    std::unique_ptr<Exception> lastException;
+    std::exception_ptr lastException;
     Mutex exceptionGuard;
     Event waitEvent;
 };
 
@@ -46,7 +46,7 @@ inline TaskThread::TaskThread(TaskThreadPool& threadPool, Semaphore& newTaskEven
 inline TaskThread::~TaskThread()
 {
     Stop();
-    Wait();
+    Join();
 }
 
 inline void TaskThread::Run()
Original file line number	Diff line number	Diff line change
`@@ -63,17 +63,7 @@ class Exception: public std::exception`
`63`	`63`	`return *this;`
`64`	`64`	`}`
`65`	`65`
`66`		`- virtual Exception* Clone() const`
`67`		`- {`
`68`		`- return new Exception(*this);`
`69`		`- }`
`70`		`-`
`71`		`- virtual void Throw() const`
`72`		`- {`
`73`		`- throw *this;`
`74`		`- }`
`75`		`-`
`76`		`- virtual const char* what() const throw()`
	`66`	`+ virtual const char* what() const`
`77`	`67`	`{`
`78`	`68`	`return message.c_str();`
`79`	`69`	`}`
Original file line number	Diff line number	Diff line change
`@@ -117,7 +117,7 @@ void ParallelForBase(RANGES ranges, Functor functor, TaskManager& manager)`
`117`	`117`	`{`
`118`	`118`	`if ((*it)->GetLastException() != 0)`
`119`	`119`	`{`
`120`		`- (*it)->GetLastException()->Throw();`
	`120`	`+ std::rethrow_exception((*it)->GetLastException());`
`121`	`121`	`}`
`122`	`122`	`}`
`123`	`123`	`}`
Original file line number	Diff line number	Diff line change
`@@ -72,11 +72,11 @@ inline void ParallelInvoke(Functor1 func1, Functor2 func2)`
`72`	`72`
`73`	`73`	`if (task1.GetLastException() != 0)`
`74`	`74`	`{`
`75`		`- task1.GetLastException()->Throw();`
	`75`	`+ std::rethrow_exception(task1.GetLastException());`
`76`	`76`	`}`
`77`	`77`	`if (task2.GetLastException() != 0)`
`78`	`78`	`{`
`79`		`- task2.GetLastException()->Throw();`
	`79`	`+ std::rethrow_exception(task2.GetLastException());`
`80`	`80`	`}`
`81`	`81`	`}`
`82`	`82`	`else`
Original file line number	Diff line number	Diff line change
`@@ -101,7 +101,7 @@ class ReduceTask : public Task`
`101`	`101`	`{`
`102`	`102`	`if (tasks[i]->GetLastException() != 0)`
`103`	`103`	`{`
`104`		`- tasks[i]->GetLastException()->Throw();`
	`104`	`+ std::rethrow_exception(tasks[i]->GetLastException());`
`105`	`105`	`}`
`106`	`106`	`};`
`107`	`107`
`@@ -143,7 +143,7 @@ inline void ParallelReduce(Iterator start, Iterator end, Functor& functor, size_`
`143`	`143`	`manager->WaitTask(*task);`
`144`	`144`	`if (task->GetLastException() != 0)`
`145`	`145`	`{`
`146`		`- task->GetLastException()->Throw();`
	`146`	`+ std::rethrow_exception(task->GetLastException());`
`147`	`147`	`}`
`148`	`148`	`}`
`149`	`149`	`else`
Original file line number	Diff line number	Diff line change
`@@ -68,24 +68,15 @@ class alignas(_CPP_TASK_CACHE_LINE_SIZE_) Task`
`68`	`68`	`{`
`69`	`69`	`Execute();`
`70`	`70`	`}`
`71`		`- catch(Exception& err)`
`72`		`- {`
`73`		`- ScopedLock<Mutex> lock(exceptionGuard);`
`74`		`- lastException.reset(err.Clone());`
`75`		`- }`
`76`	`71`	`catch(...)`
`77`	`72`	`{`
`78`		`- lastException.reset(new Exception("Unknown exception"));`
	`73`	`+ lastException = std::current_exception();`
`79`	`74`	`}`
`80`	`75`	`}`
`81`	`76`
`82`		`- const Exception* GetLastException() const`
	`77`	`+ std::exception_ptr GetLastException() const`
`83`	`78`	`{`
`84`		`- if (!lastException)`
`85`		`- {`
`86`		`- return 0;`
`87`		`- }`
`88`		`- return lastException.get();`
	`79`	`+ return lastException;`
`89`	`80`	`}`
`90`	`81`
`91`	`82`	`bool CheckFinished()`
`@@ -125,7 +116,7 @@ class alignas(_CPP_TASK_CACHE_LINE_SIZE_) Task`
`125`	`116`	`Task(const Task&) = delete;`
`126`	`117`	`const Task& operator=(const Task&) = delete;`
`127`	`118`	`private:`
`128`		`- std::unique_ptr<Exception> lastException;`
	`119`	`+ std::exception_ptr lastException;`
`129`	`120`	`Mutex exceptionGuard;`
`130`	`121`	`Event waitEvent;`
`131`	`122`	`};`
Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ inline TaskThread::TaskThread(TaskThreadPool& threadPool, Semaphore& newTaskEven`
`46`	`46`	`inline TaskThread::~TaskThread()`
`47`	`47`	`{`
`48`	`48`	`Stop();`
`49`		`- Wait();`
	`49`	`+ Join();`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`inline void TaskThread::Run()`