Z testu je možné získat maximálně 30 bodů, 15 bodů z obsáhlejších otázek na této stránce a 15 bodů z krátkých otázek.

1. Uvažujte následující program. Co bude na standardním výstupu po jeho provedení? [3B]

   struct object {
       object() { std::cout << "1 "; }
       object(const object&) { std::cout << "2 "; }
       object& operator=(const object&) {
           std::cout << "3 ";
           return *this;
       }
       object(object&&) { std::cout << "4 "; }
       object& operator=(object&&) {
           std::cout << "5 ";
           return *this;
       }
       ~object() { std::cout << "6 "; }
       void pozdrav() {
           std::cout << "Ahoj! ";
       }
       void pozdrav() const {
           std::cout << "Nazdar! ";
       }
   };
    
   object foo(const object& o){
       o.pozdrav();
       return o;
   }
    
   int main(){
       object o1;
       object o2(o1);
       o1.pozdrav();
       o1 = foo(o1);
   }

   řešení
   1 2 Ahoj! Nazdar! 2 5 6 6 6
2. Je takto definovaný konstruktor v pořádku? Proč? [1B]

   template <typename T>
   class array {
   public:
       array(T* data, std::size_t length) :
           len{length}, elements{ new T[len] } {
           for (int i = 0; i < len; ++i) {
               elements[i] = data[i];
           }
       }
   private:
       T* elements;
       std::size_t len;
   };

   řešení
   Ne, protože len je použito před inicializací (sice je to napsáno v init-listu před elements, ale init-list se vykoná v pořadí deklarace).
3. Co bude na výstupu tohoto programu? [2B]

   int main(){
       std::vector<int> v ({
           6, 5, 3, 9, 7, 4, 0, 2, 8, 1
       });
       std::sort(begin(v), end(v), [](int a, int b) {
           if ((a & 1) == (b & 1)){
               return a < b;
           } else {
               return (a & 1) < (b & 1);
           }
       });
       for (const auto& elem : v) {
           std::cout << elem << " ";
       }
   }

   řešení
   0 2 4 6 8 1 3 5 7 9
4. Co bude na výstupu tohoto kousku kódu? [1B]

   class B {};
   class D : public B {};
    
   void f(B& throwable) { throw throwable; }
    
   int main() {
       D status;
       try {
           f(status);
       } catch (B& e) {
           std::cout << "Chytil jsem B!\n";
       } catch (...) {
           std::cout << "To je divny...\n";
       }
   }

   řešení
   Chytil jsem B!
5. Co bude na výstupu po proběhnutí tohoto programu? [2B]

   struct A {
       virtual void say() {
           std::cout << "A zdravi.\n";
       }
   };
    
   struct B : A {
       void say() {
           std::cout << "B zdravi.\n";
       }
   };
    
   void bar(A& a) {
       a.say();
   }
    
   void foo(A a) {
       a.say();
       bar(a);
   }
    
   int main() {
       A a;
       B b;
       bar(a);
       bar(b);
       foo(b);
   }

   řešení
   A zdravi.
   B zdravi.
   A zdravi.
   A zdravi.
6. Naimplementujte šablonovou funkci clamp(min, max, val). Clamp omezí hodnotu val na interval [min, max].
   Příklad použití:

   clamp(0, 10,  2) == 2;
   clamp(0, 10, -1) == 0;
   clamp(0, 10, 11) == 10;

   Nezapomeňte, že T nemusí podporovat všechny operace které podporuje int. [1B]
   řešení

   template <typename T>
   T clamp(const T& min, const T& max, const T& val){
       if (val < min){
           return min;
       }
       if (max < val){
           return max;
       }
       return val;
   }
    
   template <typename T>
   T clamp(const T& min, const T& max, const T& val){
       return std::min(std::max(min, val), max);
   }