Программирование на С/С++ - тест 94

Упражнение 1:

---

Номер 1

Какие утверждения о шаблонах в языке С++ верны?

Ответ:

---

Номер 2

Какие утверждения о параметрах шаблонов верны?

Ответ:

---

Номер 3

		//====================== start of sample.cpp ==========================
		#include <vector>
		
		template <class Storage, int size>
		class Input
		{
		public:
			Input()
			: m_store(size) {}
		
		private:
		   Storage m_store;
		};
		
		int main()
		{
			Input<int,5> a1;
			Input<int,6> a2;
			Input<std::vector<int>,10> v3;
			Input<std::vector<short>,10> v4;
			Input<double, 30> *pMyInput = nullptr;
			return 0;
		}
		//======================  end of sample.cpp  ==========================
                

]]>Сколько описаний пользовательских типов будет в скомпилированном коде из файла sample.cpp?
Ответ:

---

Упражнение 2:

---

Номер 1

Какой код приводит к появлению конкретизированного кода метода в исполняемом файле?

Ответ:

---

Номер 2

		//====================== start of sample.cpp ==========================
		template <class Element, unsigned long max_size>
		class Storage {
		public:
			Storage(Element) {}
		};
		
		template <class Element>
		class Storage <Element, 0 /* unlimited*/> {
		public:
			Storage(Element e) {}
		};
		
		template <unsigned long max_size>
		class Storage <int, max_size> {
		public:
			Storage(int e) {}
		};
		
		template <>
		class Storage<char*, 0>
		{
		public:
			Storage(char* s) {}
		};
		
		template <>
		class Storage<char*, 100> {
		public:
			Storage(char* s) {}
		};
		
		int main()
		{
			int p1=4;
			Storage<int, 5> st1(p1);
			Storage<char*, 100> st2(char* s);
			Storage<double, 80000> st3(double n);
			Storage<double, 0> st4(double n);
		
			return 0;
		}
		//======================  end of sample.cpp  ==========================
                

]]>Какой из шаблонов Storage в файле sample.cpp не задействован в функции main в файле sample.cpp?
Ответ:

---

Номер 3

		//====================== start of sample3.h ==========================
		#include <list>
		#include <vector>
		
		template<class Storage>
		class MyIter {};
		
		template<class Storage>
		void my_input_process(Storage* in_item) {}
		
		template<class Storage, int size> void clear_all(Storage*);
		
		template <class Storage, class Element, int size>
		class BackupInput {};
		
		template <class Storage, class Element, int size>
		class Input
		{
		public:
			Input()
			: m_store(size) {}
		
			friend class MyIter<Storage>;
			friend void my_input_process<Storage>(Storage*);
			friend void clear_all<Storage, 100>(Storage*);
			friend class BackupInput<Storage, Element, size>;
		private:
		   Storage m_store;
		};
		
		Input<std::list<short>, short, 25> input25;
		
		int main()
		{
			MyIter<std::list<short>> my_iter;
			BackupInput<std::list<short>, short, 25> backup_input;
		
			my_input_process<std::vector<short>>(nullptr);
			clear_all<std::vector<short>, 25>(nullptr);
			clear_all<std::list<short>, 100>(nullptr);
			return 0;
		}
		//======================  end of sample3.h  ==========================
                

]]>Какие функции и классы в файле sample.cpp имеют доступ к всем атрибутам глобального объекта input25?
Ответ:

---

Упражнение 3:

---

Номер 1

		//====================== start of sample.cpp ==========================
		template<unsigned long N>
		class binary
		{
		public:
			static unsigned long const value =
					binary<N / 10>::value << 1 | N % 10;
		};
		
		template<>
		class binary<0>
		{
		public:
			static unsigned long const value = 0;
		
		};
		
		int main(int argc, char* argv[])
		{
			if (argc > 1)
			{
				static unsigned const two = binary<10>::value;
			}
			return 0;
		}
		//======================  end of sample.cpp  ==========================
                

]]>Когда будет посчитано значение переменной two?
Ответ:

---

Номер 2

		//====================== start of sample.cpp ==========================
		template<unsigned long N>
		class binary
		{
		public:
			static unsigned long const value =
					binary<N / 10>::value << 1 | N % 10;
		};
		
		template<>
		class binary<0>
		{
		public:
			static unsigned long const value = 0;
		};
		
		int main(int argc, char* argv[])
		{
			static unsigned const xyz = binary<111>::value;
			return 0;
		}
		//======================  end of sample.cpp  ==========================
                

]]>Конкретизация шаблона с значением 111 приводит:
Ответ:

---

Номер 3

		//====================== start of sample.cpp ==========================
		template<unsigned long N>
		class binary
		{
		public:
			static unsigned long const value =
					binary<N / 10>::value << 1 | N % 10;
		};
		
		template<>
		class binary<0>
		{
		public:
			static unsigned long const value = 0;
		};
		
		template<>
		class binary<1>
		{
		public:
			static unsigned long const value = 1;
		};
		
		int main(int argc, char* argv[])
		{
			static unsigned const x0 = binary<0>::value;
			static unsigned const x1 = binary<1000>::value;
			static unsigned const x2 = binary<1001>::value;
			static unsigned const x3 = binary<1010>::value;
			static unsigned const x4 = binary<1011>::value;
			return 0;
		}
		//======================  end of sample.cpp  ==========================
                

]]>При инициализации какой переменной не будет использоваться конкретизация шаблона с параметром 0?
Ответ:

---

Упражнение 4:

---

Номер 1

Специализация класса позволяет:

Ответ:

---

Номер 2

Какие утверждения о идиоме SFINAE верны?

Ответ:

---

Номер 3

Библиотека boost::type_traits позволяет:

Ответ:

---

Упражнение 5:

---

Номер 1

	//====================== start of sample.cpp ==========================
		template<typename T>
		typename T::difference_type my_diff( T& v1,  T& v2);
		
		template<typename T>
		T my_diff2(T& v1, T& v2);
		
		class A {
		public:
			A(int in = 5);
			typedef short difference_type;
			difference_type operator-(A&);
		};
		
		int main()	{
			A i(5);
			A j(10);
			my_diff(i,j);
			int x = 5;
			int y = 10;
			my_diff(x,y);
			return 0;
		}
	//======================  end of sample.cpp  ==========================
                

]]>Какие проблемы может решить использование идиомы SFINAE в вышеприведённом коде?
Ответ:

---

Номер 2

	//====================== start of sample.cpp ==========================
		#include <type_traits >
		class A		{
		public:
			A(int in = 5);
		};
		
		int main()
		{
			std::is_pointer<A> is_ptr;
			return 0;
		}
	//======================  end of sample.cpp  ==========================
                

]]>Как может использоваться объявление переменной is_ptr?
Ответ:

---

Номер 3

	//====================== start of sample.cpp ==========================
		#include <type_traits>
		class A  {
		public:
			A(int in = 5);
		};
		
		int main() 	{
			std::true_type my_true;
			std::false_type my_false;
			return 0;
		}
	//======================  end of sample.cpp  ==========================
                

]]>Какие утверждения о переменных my_true и my_false верны?
Ответ:

---

Упражнение 6:

---

Номер 1

	//====================== start of sample.cpp ==========================
		template <typename T>
		struct remove_extend
		{
			typedef T type;
		};
		
		template <typename T, std::size_t N>
		struct remove_extend<T[N]>
		{
			typedef T type;
		};
	//======================  end of sample.cpp  ==========================
                

]]>Что произойдёт если не определять специализированный шаблон remove_extend<T[N]> для массива??
Ответ:

---

Номер 2

	//====================== start of sample.cpp ==========================
		#include <type_traits>
		
		template <typename IT_1, typename IT_2, bool b>
		IT_2 copy_imp(IT_1 first, IT_1 last, IT_2 out,
					  const std::integral_constant<bool, b>&)  {
			while(first != last)  {
				*out = *first;
				++out;
				++first;
			}
			return out;
		}
		
		template <typename T>
		T* copy_imp(const T* first, const T* last, T* out, const std::true_type&) 	{
			memmove(out, first, (last-first)*sizeof(T));
			return out * (last-first);
		}
		
		template <typename I1, typename I2>
		inline I2 copy(I1 first, I1 last, I2 out)  {
			typedef typename std::iterator_traits<I1>::value_type value_type;
			return copy_imp(first, last, out, std::has_trivial_assign<value_type>());
		}
		
		class A {};
		
		int main()
		{
			std::vector<A> vec1;
			std::vector<A> vec2;
			copy(vec1.begin(), vec1.end(), vec2.begin());
			return 0;
		}
	//======================  end of sample.cpp  ==========================
                

]]>Какие утверждения про то какая функция копирования copy_impl() будет использована верны?
Ответ:

---

Номер 3

	//====================== start of sample.cpp ==========================
		#include <type_traits>
		
		template <typename IT_1, typename IT_2, bool b>
		IT_2 copy_imp(IT_1 first, IT_1 last, IT_2 out,
					  const std::integral_constant<bool, b>&)
		{
			while(first != last)
			{
				*out = *first;
				++out;
				++first;
			}
			return out;
		}
		
		template <typename T>
		T* copy_imp(const T* first, const T* last, T* out, const std::true_type&)
		{
			memmove(out, first, (last-first)*sizeof(T));
			return out * (last-first);
		}
		
		template <typename I1, typename I2>
		inline I2 copy(I1 first, I1 last, I2 out)
		{
			typedef typename std::iterator_traits<I1>::value_type value_type;
		
			return copy_imp(first, last, out, std::has_trivial_assign());
		}
		
		class A {};
		
		int main()
		{
			std::vector<short> arr1;
			std::vector<short> arr2;
			copy(arr1.begin(), arr1.end(), arr2.begin());
			return 0;
		}
	//======================  end of sample.cpp  ==========================
                

]]>Какие утверждения про используемую функцию копирования copy_impl() верны?
Ответ:

---

Упражнение 7:

---

Номер 1

Какие утверждения о работе с исключениями в языке С/С++ верны?

Ответ:

---

Номер 2

Чем отличается обработка ошибок посредством прерываний от проверки кода возврата?

Ответ:

---

Номер 3

Какие утверждения о блоках try и catch верны?

Ответ:

---

Упражнение 8:

---

Номер 1

	//====================== start of sample.cpp ==========================
		#include <stdexcept>
		void my_open1()
		{
			throw int(8);
		}
		
		void my_open2()
		try
		{
			throw std::logic_error("");
		}
		catch(std::runtime_error& err) {}
		
		void my_open3()
		try
		{
			throw std::runtime_error(&guot;runtime");
		}
		catch(const std::runtime_error* err) {}
		
		struct ERR_ {};
		
		void my_open4() {
			try
			{
				throw ERR_();
			}
			catch(...) {}
		}
		
		int main() {
			try {
			}
			catch(...) 	{
				return 5;
			}
			return 0;
		}
	//======================  end of sample.cpp  ==========================
                

]]>Вызов каких из функций изнутри блока try в функции main() приведёт к завершению программы с результатом 5?
Ответ:

---

Номер 2

	//====================== start of sample.cpp ==========================
		struct A {};
		struct B {};
		struct C {};
		struct D {};
		struct E {};
		struct F {};
		
		int main()
		{
			try
			{
				foo();
			}
			catch(const A& a) {}
			catch(static const B*) {}
			catch(C c) {}
			catch(volatile D* d) {}
			catch(virtual E* e) {}
			catch(F*&) {}
			catch(...)
			{
				return 5;
			}
			return 0;
		}
	//======================  end of sample.cpp  ==========================
                

]]>Обработчики исключений какого типа записаны неправильно?
Ответ:

---

Номер 3

	//====================== start of sample.cpp ==========================
		struct A {};
		struct B {};
		struct C {};
		struct D {};
		struct E {};
		struct F {};
		
		void foo(int i)
			try
			{
				switch(i)
				{
				case 1: throw A();
				case 2: throw B();
				case 4: throw D();
				default:
					throw F();
				}
			}
			catch(A&)  {  }
			catch(B&)  { throw D(); }
			catch(D&)  { throw C(); }
			catch(...) { throw; }
		
		int main(int argc, char* argv[])
		{
			try
			{
				foo(argc);
			}
			catch(const A& a) {}
			catch(const B*) {}
			catch(C c) {}
			catch(E* e) {}
			catch(...)
			{
				return 5;
			}
			return 0;
		}
	//======================  end of sample.cpp  ==========================
                

]]>При каких значении argc программа вернёт значение 5?
Ответ:

---

Упражнение 9:

---

Номер 1

Какие утверждения о структурной безопасности ПО верны?

Ответ:

---

Номер 2

Какие утверждения про безопасные функции и классы верны?

Ответ:

---

Номер 3

	//====================== start of sample.cpp ==========================
		struct A {};
		struct B {};
		struct C {};
		struct D {};
		struct E {};
		struct F {};
		
		class BaseIO
		{
		public:
			virtual int state() throw(A) = 0;
			virtual void read() throw(A, B) = 0;
			virtual void write() throw (C, D) = 0;
			virtual void open() throw (E,F) = 0;
			virtual void close() throw() = 0;
		};
		
		class DiskIO: public BaseIO
		{
		public:
			virtual int state() throw();
			virtual void read() throw (A, B);
			virtual void write() throw (C);
			virtual void open() throw (A, E);
			virtual void close() throw (F);
		};
	//======================  end of sample.cpp  ==========================
                

]]>Перегрузка каких виртуальных методов базового класса в классе DiskIO выполнена корректно?
Ответ:

---

Упражнение 10:

---

Номер 1

Какие методы класса не должны бросать исключения наружу?

Ответ:

---

Номер 2

Какие утверждения про корректное поведение при удалении объекта и освобождении ресурсов верны?

Ответ:

---

Номер 3

Нейтральный код (функция или метод класса) должны:

Ответ:

---

Упражнение 11:

---

Номер 1

Какие утверждения про стандартные исключения верны?

Ответ:

---

Номер 2

Почему лучше использовать исключения, унаследованные от стандартных исключений?

Ответ:

---

Номер 3

Какой главный вопрос относительно исключений стандартной библиотеки необходимо решить при разработке своего программного продукта?

Ответ:

---