Index: code/branches/cpp11_v2/src/libraries/core/command/Executor.h
===================================================================
--- code/branches/cpp11_v2/src/libraries/core/command/Executor.h	(revision 10827)
+++ code/branches/cpp11_v2/src/libraries/core/command/Executor.h	(revision 10828)
@@ -42,6 +42,6 @@
     orxonox::Executor is used to wrap an orxonox::Functor and to store default values for
     its parameters. Usually one uses the function createExecutor() to create a new executor.
-    This function returns an orxonox::ExecutorPtr which is a typedef of @ref orxonox::SharedPtr
-    "SharedPtr<Executor>", used to manage the pointer to the executor.
+    This function returns an orxonox::ExecutorPtr which is a typedef of "std::shared_ptr<Executor>",
+    used to manage the pointer to the executor.
 
     Executors are mostly used to execute callbacks. Because some callback functions need arguments,
@@ -74,6 +74,6 @@
     @endcode
 
-    Because executors that were created with createExecutor() are managed by an orxonox::SharedPtr,
-    they don't need to be deleted after usage.
+    Executors don't need to be deleted after usage normally because they are managed by an
+    std::shared_ptr when they were created with createExecutor().
 */
 
Index: code/branches/cpp11_v2/src/libraries/core/command/ExecutorPtr.h
===================================================================
--- code/branches/cpp11_v2/src/libraries/core/command/ExecutorPtr.h	(revision 10827)
+++ code/branches/cpp11_v2/src/libraries/core/command/ExecutorPtr.h	(revision 10828)
@@ -32,7 +32,7 @@
     @brief Typedefs and definitions of ExecutorPtr, ExecutorStaticPtr, and ExecutorMemberPtr
 
-    Instances of orxonox::Executor are usually managed by an orxonox::SharedPtr. This ensures
+    Instances of orxonox::Executor are usually managed by an std::shared_ptr. This ensures
     that Executors will be destroyed after usage. To make things easier, there's a typedef
-    that defines ExecutorPtr as SharedPtr<Executor>.
+    that defines ExecutorPtr as std::shared_ptr<Executor>.
 
     Because there's not only orxonox::Executor, but also orxonox::ExecutorStatic, and
Index: code/branches/cpp11_v2/src/libraries/core/command/Functor.h
===================================================================
--- code/branches/cpp11_v2/src/libraries/core/command/Functor.h	(revision 10827)
+++ code/branches/cpp11_v2/src/libraries/core/command/Functor.h	(revision 10828)
@@ -40,7 +40,7 @@
 
     To create a Functor, the helper function createFunctor() is used. It returns an instance
-    of orxonox::FunctorPtr which is simply a typedef of @ref orxonox::SharedPtr "SharedPtr<Functor>".
-    This means you don't have to delete the Functor after using it, because it is managed
-    by the SharedPtr.
+    of orxonox::FunctorPtr which is simply a typedef of "std::shared_ptr<Functor>". This
+    means you don't have to delete the Functor after using it, because it is managed
+    by the std::shared_ptr.
 
     Example:
Index: code/branches/cpp11_v2/src/libraries/core/command/FunctorPtr.h
===================================================================
--- code/branches/cpp11_v2/src/libraries/core/command/FunctorPtr.h	(revision 10827)
+++ code/branches/cpp11_v2/src/libraries/core/command/FunctorPtr.h	(revision 10828)
@@ -32,7 +32,7 @@
     @brief Typedefs and definitions of FunctorPtr, FunctorMemberPtr, FunctorStaticPtr, and FunctorPointerPtr
 
-    Instances of orxonox::Functor are usually managed by an orxonox::SharedPtr. This ensures
+    Instances of orxonox::Functor are usually managed by an std::shared_ptr. This ensures
     that Functors will be destroyed after usage. To make things easier, there's a typedef
-    that defines FunctorPtr as SharedPtr<Functor>.
+    that defines FunctorPtr as std::shared_ptr<Functor>.
 
     Because there's not only orxonox::Functor, but also orxonox::FunctorStatic, and
Index: code/branches/cpp11_v2/src/libraries/core/object/StrongPtr.h
===================================================================
--- code/branches/cpp11_v2/src/libraries/core/object/StrongPtr.h	(revision 10827)
+++ code/branches/cpp11_v2/src/libraries/core/object/StrongPtr.h	(revision 10828)
@@ -43,5 +43,5 @@
     orxonox::StrongPtr is an implementation of a smart pointer - it wraps a pointer to an
     object  and keeps this object alive until no StrongPtr points to this object anymore.
-    In contrast to orxonox::SharedPtr, StrongPtr works only with classes that are derived
+    In contrast to std::shared_ptr, StrongPtr works only with classes that are derived
     from orxonox::Destroyable, because it's an intrusive implementation, meaning the
     reference counter is stored in the object itself.
@@ -51,5 +51,5 @@
     at any time and also convert it back to a normal pointer if you like. This is possible
     because the reference counter is stored in the object itself and not in StrongPtr (in
-    contrast to SharedPtr).
+    contrast to std::shared_ptr).
 
     @b Important: If you want to delete an object, you must not use @c delete @c object but
