fix: make smart-pointer exercise easier (#934)

Author: vaeng

exercises/concept/power-of-troy/.docs/instructions.md

@@ -60,6 +60,9 @@ The world of Troy is all about interaction.
 You want people to make trades by exchanging their possessions.
 
 Write a function `exchange_artifacts` that returns nothing but takes two artifact smart-pointers to exchange the items.
+Remember, that you cannot copy a `unique_ptr`.
+This includes the usage in function parameters.
+Use a reference to the `unique_ptr` instead.
 
 ```cpp
 human uchiha{};

exercises/concept/power-of-troy/.docs/introduction.md

@@ -1,5 +1,48 @@
 # Introduction
 
+## The `auto` Keyword in C++
+
+In C++, the `auto` keyword is a powerful feature introduced in C++11, used to declare variables with an inferred data type.
+The compiler deduces the type of the variable based on its initializer, which can make code more readable and easier to maintain.
+
+## Example Usage
+
+Consider the following example where `auto` is used to declare variables:
+
+```cpp
+auto dragon_population{3};          // dragon_population is deduced as an integer
+auto westeros{7.7777};              // westeros is deduced as a double
+auto wedding_location{"The Twins"}; // wedding_location is deduced as a const char*, not std::string
+```
+
+In each case, the type of the variable is inferred from the value it is initialized with.
+
+## Type Inference
+
+The `auto` keyword helps by writing more concise and readable code by reducing the verbosity of explicit types.
+
+```cpp
+const std::vector<std::string> pigeon_pie{"flour", "butter", "pigeon", "salt"};
+auto purple_wedding_pie{pigeon_pie};
+purple_wedding_pie.emplace_back("the strangler");
+```
+
+In this loop, `auto` deduces the type of `purple_wedding_pie` as `std::vector<std::string>`, avoiding the need to explicitly specify the type again.
+
+## Compatibility
+
+The `auto` keyword is compatible with various C++ constructs making it a versatile tool in modern C++ programming.
+
+```cpp
+auto& element{array[0]};           // reference to an element
+const auto object{otherObject};    // const type version of otherObject's type
+auto* ptr{&x};                     // pointer to x with the same type as x, but as a pointer.
+```
+
+In later concept we will often see the `auto` keyword with lambda expressions, range-based for-loops, and iterators.
+
+## Smart Pointers
+
 Smart pointers are a modern C++ feature designed to provide automatic memory management, helping to prevent memory leaks and dangling pointers commonly associated with raw pointers.
 They act as wrappers around raw pointers, adding additional functionality such as automatic memory deallocation when the pointer is no longer needed.
 

exercises/concept/power-of-troy/.meta/exemplar.h

@@ -6,10 +6,14 @@
 namespace troy {
 
 struct artifact {
+    // constructors needed (until C++20)
+    artifact(std::string name) : name(name) {}
     std::string name;
 };
 
 struct power {
+    // constructors needed (until C++20)
+    power(std::string effect) : effect(effect) {}
     std::string effect;
 };
 

exercises/concept/power-of-troy/power_of_troy.h

@@ -5,10 +5,14 @@
 namespace troy {
 
 struct artifact {
+    // constructors needed (until C++20)
+    artifact(std::string name) : name(name) {}
     std::string name;
 };
 
 struct power {
+    // constructors needed (until C++20)
+    power(std::string effect) : effect(effect) {}
     std::string effect;
 };