Zde jsou ukázkové praktické otázky, ty tvoří druhou část zkouškového testu. Pro první část, navštivte stránku krátkými teoretickými otázkami.

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);
   }