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

Какую парадигму программирования поддерживают лямбда-функция в языке С/С++

В каких случаях эффективно использование лямбда-функции?

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

	//====================== start of sample.h ==========================
		int main(int argc, char* argv[])
		{
			auto lf1 = [] (int x) {return x > 0;};
			auto lf2 = [] (int x) -> bool {return x+1;};
			auto lf3 = [] (int& x) { x++; return;};
			auto lf4 = [] (int x, int& y) -> double {return x+y;};
			auto lf5 = [] (bool& z) { z = !z; return;};
			return lf1(0);
		}
	//======================  end of sample.h  ==========================
                

	//====================== start of sample.cpp ==========================
		#include <algorithm>
		#include <vector>
		
		int main(int argc, char* argv[])
		{
			std::vector<int> v1;
		
			auto lf1 = [] (int x) {return x > 0;};
			auto lf3 = [] (int& x) { x++; return;};
			auto lf5 = [] (bool& z) { z = !z; return;};
		
			int cnt1 = std::count_if(v1.begin(), v1.end(), lf1);
			int cnt2 = std::count_if(v1.begin(), v1.end(), [] (int x) -> bool {return x+1;});
			int cnt3 = std::count_if(v1.begin(), v1.end(), lf3);
			int cnt4 = std::count_if(v1.begin(), v1.end(), [] (int x, int& y) -> double {return x+y;});
			int cnt5 = std::count_if(v1.begin(), v1.end(), lf5);
		
			return cnt1;
		}
	//======================  end of sample.cpp  ==========================
                

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

	//====================== start of sample.cpp ==========================
		int main(int argc, char* argv[])
		{
			int a = 0;
			int b = 0;
			int X = 0;
		
			auto lf1 = [a,b,X] (int x) {return x > 0;};
			auto lf2 = [a,b] (int x) { x++; return x;};
			auto lf3 = [=] (int x) { x++; return x;};
			auto lf4 = [&] (int x) { x++; return x;};
			auto lf5 = [] (bool& z) { z = !z; return;};
		
			return 0;
		}
	//======================  end of sample.cpp  ==========================
                

	//====================== start of sample.cpp ==========================
		int main(int argc, char* argv[])
		{
			const int a = 0;
			int b = 0;
			const int X = 0;
			int Y = 0;
			int Z = 0;
		
			auto lf1 = [&Y, Z, &a, &b, X] (double x) {return x > 0;};
			return 0;
		}
	//======================  end of sample.cpp  ==========================
                

	//====================== start of sample.cpp ==========================
		int main(int argc, char* argv[])
		{
			int a = 0;
			int b = 0;
			int X = 0;
		
			auto lf1 = [&a,&b,&X] (int x) {return x > 0;};
			auto lf2 = [a,b] (int x) { x++; return x;};
			auto lf3 = [=] (int x) { x++; return x;};
			auto lf4 = [&] (int x) { x++; return x;};
			auto lf5 = [] (bool& z) { z = !z; return;};
		
			return 0;
		}
	//======================  end of sample.cpp  ==========================
                

Каковы основные цели разработки boost?

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

Какие преимущества даёт использование boost?

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

Какие из объектов шаблонов и макросов в рассмотренных библиотеках boost предоставляют безопасный обобщённый контейнер с возможностью хранения различных типов?

Какие из объектов шаблонов и макросов в рассмотренных библиотеках boost предоставляют безопасный обобщённый класс хранилище единичных значений любых различных типов?

Какие из объектов шаблонов и макросов в рассмотренных библиотеках boost предоставляют STL совместимый контейнер с перезаписью элементов при заполнении?

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

Какие преимущества обеспечивает тип boost::variant по сравнению с union?

Какие операции можно выполнять с объектом boost::any?

Какие утверждения о контейнере boost::circular_buffer верны?

	//====================== start of sample.cpp ==========================
		#include <climits>
		#include <limits>
		#include <boost/static_assert.hpp>
		
		namespace name {
		BOOST_STATIC_ASSERT(std::numeric_limits<int>::digits == 32);
		}
		
		int main(int argc, char* argv[]) {
			return 0;
		}
	//======================  end of sample.cpp  ==========================
                

	//====================== start of sample.cpp ==========================
		#include <boost/variant/variant.hpp>
		
		struct A {};
		
		struct B {
			B(int src);
		private:
			B(const B& src);
		};
		
		struct C {
			C(int src);
		private:
			C();
		};
		
		struct D {};
		
		int main(int argc, char* argv[])
		{
			boost::variant<int, A, B, C> myvariant;
		
			int x;
			int* y;
			A a;
			B b(x);
			C c(x);
			D d;
		
			myvariant = x;
			myvariant = y;
			myvariant = a;
			myvariant = b;
			myvariant = c;
			myvariant = d;
			return 0;
		}
	//======================  end of sample.cpp  ==========================
                

	//====================== start of sample.cpp ==========================
		#include <boost/circular_buffer.hpp>
		
		int main(int argc, char* argv[])
		{
			boost::circular_buffer<int> circ(3);
			circ.push_back(1);
			circ.push_back(2);
			circ.push_back(3);
			circ.push_back(4);
			circ.push_back(5);
			circ.pop_back();
			return 0;
		}
	//======================  end of sample.cpp  ==========================
                

Какие из приведённых умных указателей выполняет автоматическое удаление объекта?

Какие операторы перегружаются для умных указателей (в частности для shard_ptr)?

Каковы минимальные требования к объектам, указатель на которые могут быть храниться в умных указателях?

Каковы особенности умного указателя boost::scoped_ptr?

Каковы особенности умного указателя boost::shared_ptr?

Каковы особенности умного указателя boost::weak_ptr?

Каковы особенности умного указателя boost::intrusive_ptr?

	//====================== start of sample.cpp ==========================
		#include <boost/shared_ptr.hpp>
		#include <boost/scoped_ptr.hpp>
		#include <boost/weak_ptr.hpp>
		#include <vector>
		
		struct A {
			virtual ~A();
		};
		
		struct B: public A {};
		
		struct C {};
		
		void foo1(boost::scoped_ptr<A> a);
		void foo2(boost::scoped_ptr<B>& a);
		void foo3(boost::shared_ptr<C> a);
		void foo4(boost::scoped_ptr<A>* a);
		void foo5(std::vector< boost::scoped_ptr<C> >& c);
		
		int main(int argc, char* argv[])
		{
			boost::scoped_ptr<A> b1(new A);
			boost::scoped_ptr<B> b2(new B);
			boost::scoped_ptr<C> b3(new C);
			boost::scoped_ptr<A> b4;
			std::vector< boost::scoped_ptr<C> > v1;
		
			v1.push_back(b3);
		
			foo1(b1);
			foo2(b2);
			foo3(b3.lock());
			foo4(&b4);
			foo5(v1);
		
			return 0;
		}
	//======================  end of sample.cpp  ==========================
                

	//====================== start of sample.cpp ==========================
		#include <boost/shared_ptr.hpp>
		#include <boost/weak_ptr.hpp>
		#include <vector>
		
		struct A {
			virtual ~A();
		};
		struct B: public A {};
		
		struct C {};
		
		void foo1(boost::shared_ptr<A>& a);
		void foo2(boost::shared_ptr<A const> a);
		void foo3(boost::shared_ptr<B>& a);
		void foo4(boost::shared_ptr<const A> a, boost::shared_ptr<C> c);
		void foo5(std::vector< boost::shared_ptr<C> >& c);
		
		int main(int argc, char* argv[])
		{
			boost::shared_ptr<A> b1(new A);
			boost::shared_ptr<B> b2(new B);
			boost::shared_ptr<C> b3(new C);
			boost::weak_ptr<A> b4(b1);
			std::vector<boost::shared_ptr<C>> v1;
		
			v1.push_back(b3);
		
			foo1(b1);
			foo2(b2);
			foo3(b3);
			foo4(b4.lock(), b3);
			foo5(v1);
		
			return 0;
		}
	//======================  end of sample.cpp  ==========================
                

	//====================== start of sample.cpp ==========================
		#include <boost/shared_ptr.hpp>
		#include <boost/scoped_ptr.hpp>
		#include <boost/weak_ptr.hpp>
		#include <vector>
		
		struct A {
			virtual ~A();
		};
		
		struct B: public A {};
		
		struct C {};
		
		void foo1(boost::shared_ptr<A> a);
		void foo2(boost::weak_ptr<B>& a);
		void foo3(boost::shared_ptr<C> a);
		void foo4(boost::scoped_ptr<A>& a);
		void foo5(std::vector< boost::weak_ptr<C> >& c);
		
		int main(int argc, char* argv[])
		{
			boost::shared_ptr<A> a(new A);
			boost::shared_ptr<B> b(new B);
			boost::shared_ptr<C> c(new C);
			boost::weak_ptr<A> b1(a);
			boost::weak_ptr<B> b2(b);
			boost::weak_ptr<C> b3(c);
			std::vector< boost::weak_ptr<C> > v1;
		
			v1.push_back(b3);
		
			foo1(b2.lock());
			foo2(b2);
			try
			{
				boost::shared_ptr<C> c1(c);
				foo3(c1);
			}
			catch(boost::bad_weak_ptr& e)
			{ }
		
			foo4(b2.lock());
			foo5(v1);
		
			return 0;
		}
	//======================  end of sample.cpp  ==========================
                

Какая из библиотек Boost поддерживает работу с тернарной логикой?

Какая из библиотек Boost поддерживает анализ размерностей операндов вычислительных операций?

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

	//====================== start of sample.cpp ==========================
		struct A {
			A();
		
			virtual ~A();
		
		private:
			A(A&a);
			A& operator=(const A& a);
		};
		
		struct B: public A {};
		
		struct C {};
		
		struct D {
			D();
			D& operator=(const D& d);
		};
	//======================  end of sample.cpp  ==========================
                

	//====================== start of sample.cpp ==========================
		#include <string>
		#include <type_traits>
		
		struct my_string
		{
			std::string s;
			my_string(const std::string& s);
		};
		
		int main(int argc, char* argv[])
		{
			is_copy_constructible<my_string>;
			return 0;
		}
	//======================  end of sample.cpp  ==========================
                

Какие типы и методы должен поддерживать контейнер, соответствующий требованию Container?