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]

   class object {
   public:
       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 foo(object x) {
       std::cout << "foo! ";
   }
    
   int main() {
       object o1;
       object o2;
       object o3 = std::move(o2);
       foo(o3);
       o1 = o2;
   }

   řešení
   1 1 4 2 foo! 6 3 6 6 6
2. Obsahuje konstruktor třídy array chybu? Pokud ano, jakou? [1B]

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

   řešení
   Ano, proměnná len je použita před inicializací.
3. Co bude na výstupu po provedení tohoto programu? [2B]

   void foo() {
       std::vector<int> vec = { 1, 2, 3, 2, 3, 7, 7, 5, 2 };
       int i = 0;
       std::for_each(begin(vec), end(vec), [i](int elem) mutable {
           static int temp = 0;
           temp += elem % 3;
           i += temp + elem % 4;
       });
       std::cout << i << std::endl;
   }

   řešení
   0 protože i je do lambdy bráno hodnotou.
4. Navrhněte interface (napište definici) šablonovaného zásobníku, stack<T>. O T předpokládejte, že podporuje kopírující operace. Následující program předvádí, jak má zásobník fungovat. [2B]

   int main() {
       stack<int> s1;
       stack<int> s2;
    
       s1.push(12);
       s1.push(13);
       s1.push(17);
    
       s2 = s1;
       while (!s2.empty()) {
           int temp = s2.top();
           s2.pop();
           std::cout << temp << std::endl;
       }
       std::cout << std::boolalpha << s1.empty() << std::endl;
   }

   Očekávaný výstup je 
   17
   13
   12
   False

   řešení

   template <typename T>
   class stack {
   public:
       void push(const T&);
       void pop();
       T& top();
       bool empty() const;
       // ty dal uz nejsou nutne
       const T& top() const;
       stack();
       stack(const stack&);
       stack& operator=(const stack&);
   };

5. Napište definici šablonové třídy Pair (jsou v ní dva objekty libovolných typů) a operátor zápisu do proudu pro tuto třidu. [2B]
   řešení
   

   template <typename T, typename U>
   class Pair {
       T first;
       U second;
       friend ostream& operator<<(std::ostream&, const Pair&);
   };
    
   ostream& operator<<(std::ostream& out, const Pair& p){
       out << p.first << ' ' << p.second;
       return out;
   }