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

Количество вопросов - 342

В каких случаях происходит по членная инициализация объекта класса?

Какие основные элементы STL инкапсулируют хранение различных значений и объектов?

Каким образом предполагается решать проблему множественного наследования в языке С++?

Каковы основные правила при присвоении одного указателя другому?

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

<pre>//====================== start of sample.cpp ========================== int main() { Reader readers1[] = {&quot;&quot;, &quot;&quot;}; std::vector<Reader> readers2; Reader reaedr3 = {(22, &quot;Vasily&quot;, &quot;Ivanov&quot;, 123456), (45, &quot;Alex&quot;, &quot;V&quot;, 993421) }; return 0; }//====================== end of sample.cpp ========================== </pre> Какие конструкторы должны быть определены для типа Reader, что бы инициализации массивов объектов этого типа и объявления контейнеров, приведённые в файле sample.cpp были успешными?

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

<pre> //====================== start of sample.cpp ========================== #include &lt;iostream&gt; class Program; class ProgDataGetter { public: const char* prog_name(const Program&amp; prg); long get_version(const Program&amp; prg); }; class Program { long threads_count; double time_of_work; class Module { char* module_name; }; char* prog_name; long version; Module modules[16]; friend std::iostream&amp; operator &gt;&gt; (std::iostream&amp; io, Program&amp; prg); friend std::iostream&amp; operator &lt;&lt; (std::iostream&amp; io, const Program&amp; prg); friend class VersionGetter; friend const char* ProgDataGetter::prog_name(const Program&amp;); }; std::iostream&amp; operator &gt;&gt; (std::iostream&amp; io, Program&amp; prg) { io &gt;&gt; prg.prog_name &gt;&gt; prg.threads_count; } std::iostream& operator &lt;&lt; (std::iostream& io, const Program& prg) { io &lt;&lt; prg.prog_name &lt;&lt; prg.modules[0].module_name &lt;&lt; prg.modules[1].module_name; } class VersionGetter { public: long get_version(Program&amp; prg) { return prg.version; } }; const char* ProgDataGetter::prog_name(const Program&amp; prg) { return prg.prog_name; } long ProgDataGetter::get_version(const Program&amp; prg) { return prg.version;} //====================== end of sample.cpp ========================== </pre> Для каких функций и методов корректно организован доступ к членам класса Program файле sample.cpp?

Какая группа шаблонов отвечает за организацию сочленения объектов и классов?

На этапе проектирования находятся компромиссы между следующими характеристиками системы:

К каким последствиям приведёт использование ключевого слова extern при описании переменной, находящейся внутри тела функции?

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

Какими аспектами характеризуются различные классы памяти?

<pre> //====================== start of sample.hpp ========================== class ARef { public: /* Сonstructory */ ARef(A&amp; a, int i) : _a(a), _ix(i) {} /* operator= */ ARef&amp; operator= (T t) { return *this;} private: A&amp; _a; // Reference to A object int _ix; // index in container }; class BRef { public: BRef(B &amp;b, int i) : _b(b), _ix(i) {} BRef&amp; operator= (T t) { return *this;} private: B&amp; _b; int _ix; }; /* * Class CRef имплементирует шаблон проектирования X * хранит в себе ссылку на коллекцию типа A, которая является коллекцией * объектов типа T и предоставляет к ним доступ */ class CRef { public: CRef(C &amp;c, int i) : _c(c), _ix(i) {} CRef&amp; operator= (T t) { return *this;} private: C&amp; _c; /* та коллекция объектов, доступ к которой и предоставляется*/ int _ix; /* индекс текущего объекта в контейнере */ }; /* * Class DRef */ class DRef { public: // конструктор инициализирует объект DRef(D &amp;d, int i) : m_d(d), _ix(i) {} // оператор возвращает ссылку на себя DRef&amp; operator= (T t) { return *this;} private: D&amp; m_d; // хранимый объект int _ix; // индекс }; //====================== end of sample.hpp ========================== </pre> Комментарии какого из классов в файле sample.hpp являются необходимыми и достаточными?

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

Какие возможности даёт использование поведенческий шаблон: итератор?

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

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

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

<pre>//====================== start of sample.cpp ========================== class Input { public: Input(); }; class USBInput: public Input { public: USBInput(): Input() {} }; class Device { public: Device(); }; class ManualUserDev: public Device { public: ManualUserDev() : Device() {} }; class Keyboard: public USBInput, public ManualUserDev { public: Keyboard(): ManualUserDev(), USBInput() {} };//====================== end of sample.cpp ========================== </pre> Тело конструктора какого класса будет исполнено последним перед вызовом тела конструктора Keyboard при создании класса типа Keyboard?

Каким образом можно оптимизировать работу с памятью в high-load приложениях?

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

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

Какие операции можно делать с ссылками?

Какими типами конкретизируются контейнерные адаптеры?

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

Какие утверждения об отношениях сравнения, используемых в обобщённых алгоритмах STL верны?

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

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

На что необходимо обратить внимание при проектировании системы что бы избежать её переделки через некоторое время?

Каково текущее состояние языка С по отношению к С++?

Какие функции и особенности директив препроцессора #define - #undef указаны верно?

Какие утверждения про кэш память процессора верны?

Какие утверждения относительно характеристики класса памяти - связывания верны?

Для каких классов памяти связывание отсутствует?

Какие операции адресной арифметики имеют смысл?

Каким образом будет инициализирован массив целых чисел, если объявлена его инициализация одним числом: int А[10] = {10};?

Результаты каких функций POSIX необходимо проверять?

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

Какие утверждения о размещения элементов многомерного массива в памяти верны?

В чём преимущества вектора векторов перед многомерным массивом?

Каковы условия контракта, который заключается с компилятором использованием ключевого слова restrict при объявлении указателя?

Какие особенности динамических массивов указаны верно?

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

Какие возможности даёт использование утилиты pahole?

Какие утверждения о функции __builtin_expect() верны?

Какие плюсы и минусы даёт встраивание функций?

<pre> /*---- start of main.c ----*/ #include &lt;stdio.h&gt; const char* g_name = &quot;programm&quot;; char directory[8]; int main(int argc, char* argv[] ) { int i = 1; const char* right_name = &quot;right&quot;; for (; i<argc; ++i) { if (0 == strcmp(argv[i], right_name)) return 0; } return 1; } /*---- end of main.c ----*/ </pre> В какой части памяти программы из выше приведённого файла main.c находится переменная right_name?

Что описывает стандарт POSIX?

Какими средствами поддерживается в языке С++ функциональное программирование?

<pre> //====================== start of sample.h ========================== struct S_EMPTY {}; struct A { int i; double g; }; class B { long jj; public: char _str[6]; private: static char str_4_all[9]; }; union mytypes_t { int i; float f; } My; //====================== end of sample.h ========================== </pre> Доступ к каким из членов класса, описанных в файле sample.h (выше), является открытым?

<pre> //====================== start of sample.cpp ========================== class User {}; class Bank {} my_bank; class User my_user; class Bank *pMyBank = &amp;my_bank; class Bank&amp; rBank = &amp;my_bank; User *const &amp;prUser = &amp;my_user; User& secondUser = &amp;my_user; //====================== end of sample.cpp ========================== </pre> Какие присвоения и объявления в файле sample.cpp валидны?

В каких ситуациях выполняется создание объекта типа?

<pre> //====================== start of sample.cpp ========================== class User { public: const char* get_name() const; inline int get_age const; private: volatile double get_balance(); mutable char* get_job_name(); protected: long long get_phone_number(); static int get_phone_prefix(); }; //====================== end of sample.cpp ========================== </pre> Какие методы класса User объявлены корректно?

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

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

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

<pre> //====================== start of sample.cpp ========================== class Program { char* prog_name; public: long threads_count; double time_of_work; long version; }; const Program&amp; get_my_program(); int main() { Program&amp; prg = const_cast<Program&amp;>(get_my_program()); long Program::*pmy_thr_count = &Program::threads_count; long my_threads_1 = *pmy_thr_count; long my_threads_2 = prg.*pmy_thr_count; long Program::*pversion = &amp;Program::version; long my_version = (&amp;prg)-&gt;*pversion; char* Program::*pmy_name = &amp;Program::prog_name; char* my_name = prg.*pmy_name; return 0; } //====================== end of sample.cpp ========================== </pre> Какие присвоения значений членов класса переменным будут успешны в файле sample.cpp?

Что необходимо сделать для реализации потокового ввода-вывода для своего класса?

<pre> //====================== start of sample.cpp ========================== union Lesson { long math_lection_number; short home_work_number; } my_lesson; class Lection { public: union { char* proffesor; short graduate_number; } main_person; union { short home_work_task; char *home_book_name; }; }; int main() { Lesson* pmy_lesson = &amp;my_lesson; Lection my_lection; long lection = my_lesson.math_lection_number; short* phome_work = &amp;(pmy_lesson->home_work_number); char* proffesor = my_lection.proffesor; short gr_number = my_lection.main_person.graduate_number; short my_task = Lection::home_work_task; const char * my_book = my_lection.home_book_name; return 0; } //====================== end of sample.cpp ========================== </pre> Присвоение данных класса каким переменным выполнено корректно (т.е. данные объявлены корректно и доступ к ним так же корректен) файле sample.cpp?

<pre>//====================== start of sample.cpp ========================== struct Book { short year; char* author; char* name; }; class Person { short m_age; const char* m_name; const char* m_subname; public: Person(short age, const char* name, const char* subname) : m_age(age), m_name(name), m_subname(subname){} }; class Library { public: long m_books_count; char* m_name; char* m_city; Library(long books_count): m_books_count(books_count){} }; int main() { Book book1 = {&quot;Owrell&quot;, 1984, &quot;1984&quot;}; Book book2 = {1984}; Person main_author = {65, &quot;Bjarne&quot;, &quot;Stroustrup&quot;}; Person my_author(65, &quot;Bjarne&quot;, &quot;Stroustrup&quot;); Library my_lib = 25; return 0; }//====================== end of sample.cpp ========================== </pre> Инициализация каких объектов в файле sample.cpp выполнена корректно?

<pre>//====================== start of sample.cpp ========================== #include &lt;vector&gt; class Person { short m_age; const char* m_name; const char* m_surname; public: Person(short age, const char* name, const char* subname) : m_age(age), m_name(name), m_surname(subname){} Person() : m_name(&quot;unknown&quot;){} }; class Reader: public Person { long m_ticket_number; public: Reader(long tick_numb = 0) : Person() , m_ticket_number(tick_numb) {} Reader(short age, const char* name, const char* surname, long tick_numb) : Person(age, name, surname) , m_ticket_number(tick_numb){} }; int main() { Reader reader1; Reader reader2 = 35; Reader reaedr3(22, &quot;Vasily&quot;, &quot;Ivanov&quot;, 123456); return 0; }//====================== end of sample.cpp ========================== </pre> Значения каких атрибутов каких объектов корректно инициализируются не нулевыми значениями?

Для чего могут служить закрытые и защищённые конструкторы?

<pre>//====================== start of sample.cpp ========================== #include &lt;stdio.h&gt; class Region; class Person { public: short m_age; const char* m_name; const char* m_surname; const char* m_region_name; Person(const char* name) : m_name(name) {} operator short () {return m_age;} operator const char* () {return &quot;&quot;;} }; class Region { public: const char* region_name; const char* cheef_name; long size; Region(const char* region_nm = &quot;&quot;) : region_name(region_nm) {} operator long () {return size;} operator const char* () {return region_name;} }; int main() { Person p1(&quot;Vasily Ivanov&quot;); Region r; printf(&quot;Region number %u, driver %s&quot;, static_cast&lt;unsigned short&gt;(r), static_cast&lt;const char*&gt;(p1)); return 0; }//====================== end of sample.cpp ========================== </pre> Какие из имеющихся в файле sample.cpp конструкторов и операторов преобразования задействованы в операциях в функции main()?

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

<pre>//====================== start of sample.cpp ========================== #include &lt;vector&gt; class Person { public: short m_age; const char* m_name; const char* m_surname; const char* m_region_name; }; class Region { public: const char* region_name; const char* cheef_name; long size; }; int main() { std::vector&lt;unsigned char&gt;* mybuffer = new std::vector&lt;unsigned char&gt;(sizeof(Person) + sizeof(Region), 0); Person* my_person = new (&amp;(mybuffer->at(0))) Person(); my_person-&gt;~Person(); delete my_person; Region* p_region = new (&amp;(mybuffer-&gt;at(0))) Region(); p_region-&gt;~Region(); delete p_region; delete mybuffer; return 0; }//====================== end of sample.cpp ========================== </pre> Какие операции освобождений ресурсов в файле sample.cpp являются лишними или ошибочными?

Чем отличается оператор присваивания от оператора присваивания с переносом?

Какие утверждения насчёт позднего связывания верны?

Какие утверждения насчёт абстрактных и конкретных классов верны?

<pre>//====================== start of sample.cpp ========================== class Computer { public: Computer(OutPutDev&amp; outdev) : m_proc(&quot;amd64&quot;) , m_disk2(1024) , m_disk1(128) , m_mem(4096) , m_output(outdev) { m_pinput = new InputDev(); } private: Processor m_proc; HDDDev m_disk1; HDDDev m_disk2; InputDev* m_pinput; OutPutDev&amp; m_output; Memory m_mem; };//====================== end of sample.cpp ========================== </pre> Какие утверждения о порядке вызовов конструкторов классов при создании объекта типа Computer в файле sample.cpp верны?

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

Какие операции в языке С++ поддерживают RTTI?

<pre> //====================== start of sample.cpp ========================== #include &lt;vector&gt; template &lt;class Storage, int size&gt; class Input { public: Input() : m_store(size) {} private: Storage m_store; }; int main() { Input&lt;int,5&gt; a1; Input&lt;int,6&gt; a2; Input&lt;std::vector&lt;int&gt;,10&gt; v3; Input&lt;std::vector&lt;short&gt;,10&gt; v4; Input&lt;double, 30&gt; *pMyInput = nullptr; return 0; } //====================== end of sample.cpp ========================== </pre> Сколько описаний пользовательских типов будет в скомпилированном коде из файла sample.cpp?

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

<pre> //====================== start of sample.cpp ========================== template&lt;unsigned long N&gt; class binary { public: static unsigned long const value = binary&lt;N / 10&gt;::value &lt;&lt; 1 | N % 10; }; template&lt;&gt; class binary&lt;0&gt; { public: static unsigned long const value = 0; }; template&lt;&gt; class binary&lt;1&gt; { public: static unsigned long const value = 1; }; int main(int argc, char* argv[]) { static unsigned const x0 = binary&lt;0&gt;::value; static unsigned const x1 = binary&lt;1000&gt;::value; static unsigned const x2 = binary&lt;1001&gt;::value; static unsigned const x3 = binary&lt;1010&gt;::value; static unsigned const x4 = binary&lt;1011&gt;::value; return 0; } //====================== end of sample.cpp ========================== </pre> При инициализации какой переменной не будет использоваться конкретизация шаблона с параметром 0?

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

<pre> //====================== start of sample.cpp ========================== template&lt;typename T&gt; typename T::difference_type my_diff( T&amp; v1, T&amp; v2); template&lt;typename T&gt; T my_diff2(T&amp; v1, T&amp; v2); class A { public: A(int in = 5); typedef short difference_type; difference_type operator-(A&amp;); }; 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 ========================== </pre> Какие проблемы может решить использование идиомы SFINAE в вышеприведённом коде?

<pre> //====================== start of sample.cpp ========================== #include &lt;type_traits&gt; template &lt;typename IT_1, typename IT_2, bool b&gt; IT_2 copy_imp(IT_1 first, IT_1 last, IT_2 out, const std::integral_constant&lt;bool, b&gt;&amp;) { while(first != last) { *out = *first; ++out; ++first; } return out; } template &lt;typename T&gt; T* copy_imp(const T* first, const T* last, T* out, const std::true_type&amp;) { memmove(out, first, (last-first)*sizeof(T)); return out * (last-first); } template &lt;typename I1, typename I2&gt; inline I2 copy(I1 first, I1 last, I2 out) { typedef typename std::iterator_traits&lt;I1&gt;::value_type value_type; return copy_imp(first, last, out, std::has_trivial_assign&lt;value_type&gt;()); } class A {}; int main() { std::vector&lt;A&gt; vec1; std::vector&lt;A&gt; vec2; copy(vec1.begin(), vec1.end(), vec2.begin()); return 0; } //====================== end of sample.cpp ========================== </pre> Какие утверждения про то какая функция копирования copy_impl() будет использована верны?

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

<pre> //====================== start of sample.cpp ========================== struct A {}; struct B {}; struct C {}; struct D {}; struct E {}; struct F {}; int main() { try { foo(); } catch(const A&amp; a) {} catch(static const B*) {} catch(C c) {} catch(volatile D* d) {} catch(virtual E* e) {} catch(F*&amp;) {} catch(...) { return 5; } return 0; } //====================== end of sample.cpp ========================== </pre> Обработчики исключений какого типа записаны неправильно?

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

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

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

В чём заключается архитектурное свойств STL - гарантии вычислительной сложности?

Какие основные элементы STL решают вопросы обработки данных, размещённых в стандартных контейнерах STL?

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

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

Какова сложность создания копии контейнера вектор?

Какие отличия списка от вектора?

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

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

Разыменование какого итератора ведёт к вставке элемента в контейнер?

<pre> //====================== start of sample.cpp ========================== template &lt;typename ForwardIterator, typename T&gt; void replace ( ForwardIterator first, ForwardIterator last, const T&amp; x, const T&amp; y) { while(first != last) { if (*first == x) *first = y; ++first; } return first; } //====================== end of sample.cpp ========================== </pre> Каковы требования к итераторам, участвующим в алгоритме replace(), имплементация которого приведена выше, корректны?

Чем отличаются неупорядоченные ассоциативные контейнеры, добавленные в стандарте С++ 11 от уже имеющихся ассоциативных контейнеров?

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

<pre> //====================== start of sample.cpp ========================== #include &lt;algorithm&gt; #include &lt;vector&gt; int main(int argc, char* argv[]) { std::vector&lt;int&gt; v1; auto lf1 = [] (int x) {return x > 0;}; auto lf3 = [] (int&amp; x) { x++; return;}; auto lf5 = [] (bool&amp; 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&amp; y) -> double {return x+y;}); int cnt5 = std::count_if(v1.begin(), v1.end(), lf5); return cnt1; } //====================== end of sample.cpp ========================== </pre> При вычислении каких переменных лямбда-функции в алгоритме count_if используются корректно?

<pre> //====================== 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 = [&amp;] (int x) { x++; return x;}; auto lf5 = [] (bool&amp; z) { z = !z; return;}; return 0; } //====================== end of sample.cpp ========================== </pre> Какие лямбда функции из примера выше имеют доступ к значению переменной X?

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

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

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

<pre> //====================== start of sample.cpp ========================== #include &lt;boost/circular_buffer.hpp&gt; int main(int argc, char* argv[]) { boost::circular_buffer&lt;int&gt; 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 ========================== </pre> Какие значения останутся в циклическом буфере circ в примере в файле sample.cpp?

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

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

<pre> //====================== start of sample.cpp ========================== #include &lt;boost/shared_ptr.hpp&gt; #include &lt;boost/weak_ptr.hpp&gt; #include &lt;vector&gt; struct A { virtual ~A(); }; struct B: public A {}; struct C {}; void foo1(boost::shared_ptr&lt;A&gt;&amp; a); void foo2(boost::shared_ptr&lt;A const&gt; a); void foo3(boost::shared_ptr&lt;B&gt;&amp; a); void foo4(boost::shared_ptr&lt;const A&gt; a, boost::shared_ptr&lt;C&gt; c); void foo5(std::vector&lt; boost::shared_ptr&lt;C&gt; &gt;&amp; c); int main(int argc, char* argv[]) { boost::shared_ptr&lt;A&gt; b1(new A); boost::shared_ptr&lt;B&gt; b2(new B); boost::shared_ptr&lt;C&gt; b3(new C); boost::weak_ptr&lt;A&gt; b4(b1); std::vector&lt;boost::shared_ptr&lt;C&gt;&gt; v1; v1.push_back(b3); foo1(b1); foo2(b2); foo3(b3); foo4(b4.lock(), b3); foo5(v1); return 0; } //====================== end of sample.cpp ========================== </pre> Вызовы каких функций выполнены корректно и операции создания их параметров не содержат очевидных проблем?

<pre> //====================== start of sample.cpp ========================== struct A { A(); virtual ~A(); private: A(A&amp;a); A&amp; operator=(const A&amp; a); }; struct B: public A {}; struct C {}; struct D { D(); D&amp; operator=(const D&amp; d); }; //====================== end of sample.cpp ========================== </pre> Какие из типов из файла sample.cpp удовлетворяют требованию CopyConstructible?

Какие вопросы решаются при определении реализации объектов системы?

На какие будущие изменения проектируемой системы необходимо обратить внимание при её проектировании?

Какие из шаблонов относятся к уровню шаблонов объектно-ориентированного проектирования?

При каких способах композиции и наследования время жизни инкапсулируемого объекта не зависит от времени жизни инкапсулирующего объекта?

Каковы особенности базового шаблона «интерфейсный класс»?

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

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

<pre> //====================== start of sample.cpp ========================== template &lt;class Receiver&gt; class MyCommand: public Command { public: typedef void (Receiver::* Action)(); MyCommand(Receiver r, Action a): _receiver(r), _action(a){} void Execute(); int GetStatus(); private: Action _action; Receiver* _receiver; int _last_error; }; //====================== end of sample.cpp ========================== </pre> Какие атрибуты и методы класса MyCommand являются необходимыми для имплементации шаблона команда в файле sample.cpp?

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

Какие из приведённых принципов относятся к S.O.L.I.D.?

Какие утверждения о идиомах языка программирования верны?

<pre> //====================== start of sample.cpp ========================== class ARef { public: ARef(A &amp;a, int i) : _a(a), _ix(i) {} ARef&amp; operator= (T t) { return *this;} operator T() {return _t;} operator A() {return _a;} A& getA() { return _a;} bool operator == (A&amp; a) {return _a == a;} private: A&amp; _a; int _ix; T _t; }; class A { friend class ARef; public: A() {} ARef operator[] (int ix) {return ARef(*this, ix);} operator ARef() {return ARef(*this, ix);} }; //====================== end of sample.cpp ========================== </pre> Какие из методов класса ARef из файла sample.cpp являются необходимыми для поддержки идиомы контекстно-зависимой перегрузки операции индексирования агрегата?

Какие утверждения про реализацию перегруженных операторах new и delete класса верны?

В чём состоит идиома «Конверт/письмо»?

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

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

Каким образом можно оценить «структурное качество» программы?

При оценке каких показателей согласно модели SQuaRE, предполагается рассмотрение корректности обработки ошибок?

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

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

В чём основные отличие «гибких» методологий, от методологий, основанных на "каскадной" модели жизненного цикла разработки ПО?

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

Какие основные элементы STL абстрагируют перемещение по коллекциям объектов?

Каковы основные особенности композиции?

Какие утверждения насчёт ассоциативных контейнеров верны?

<pre> //====================== start of sample.cpp ========================== class Program { long threads_count; double time_of_work; public: char* prog_name; long version; long get_threads_count(); double get_time_of_work(); }; const Program&amp; get_my_program(); typedef double (Program::*my_getter)(); int main() { long Program::*pversion = &amp;Program::version; char* Program::*pmy_name = &amp;Program::prog_name; long (Program::*f_threads_count)() = &amp;Program::get_threads_count; Program&amp; prg = const_cast&lt;Program&amp;&gt;(get_my_program()); long my_version = (prg)-&gt;*pversion; char* my_name = prg.*pmy_name; long my_threads_count = (prg.f_threads_count)(); my_getter getter = &amp;Program::get_time_of_work; double my_time_of_work = (prg.*getter)(); return 0; } //====================== end of sample.cpp ========================== </pre> Какие присвоения значений членов класса переменным будут успешны в файле sample.cpp?

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

<pre> //====================== start of sample.cpp ========================== #include &lt;string&gt; #include &lt;type_traits&gt; struct my_string { std::string s; my_string(const std::string&amp; s); }; int main(int argc, char* argv[]) { is_copy_constructible&lt;my_string&gt;; return 0; } //====================== end of sample.cpp ========================== </pre> Каким образом можно проверить требование CopyConstructable посредством шаблона стандартной библиотеки is_copy_constructible для типа my_string из файла sample.cpp?

Указателю на какой тип можно присвоить указатель на тип Т?

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

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

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

На поиск каких ошибок кодирования, являющихся типовыми, направлено ревью кода?

При оценке каких показателей согласно модели SQuaRE, предполагается рассмотрение соблюдение правил кодирования?

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

Каковы особенности базового шаблона «неизменяемый объект»?

<pre> //====================== start of sample.cpp ========================== class Program { public: static char* country; static const int version = 5; static short buid_num = 2223; static char* name; static long long date; }; Program prog; //====================== end of sample.cpp ========================== </pre> Какие объявления и обращения к членам класса и объекта prog, типа Program в файле sample.cpp корректны?

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

<pre> //====================== start of sample.cpp ========================== class MyAClass { public: const MyAClass&amp; getMe() const { return *this; } }; MyAClass *myAFactory1 = new MyAClass(); MyAClass myAFactory2; MyAClass *myA1 = myAFactory1-&gt;getMe(); MyAClass myA2 = myAFactory1-&gt;getMe(); MyAClass const &amp;myA3 = myAFactory1-&gt;getMe(); MyAClass &amp;myA4 = myAFactory1-&gt;getMe(); MyAClass const &amp;myA5 = myAFactory2.getMe().getMe(); //====================== end of sample.cpp ========================== </pre> Какие присвоения и объявления в файле sample.cpp валидны?

По каким причинам может потребоваться перегрузка операторов new и delete - глобальных или класса?

<pre> //====================== start of sample.cpp ========================== template &lt;typename T&gt; struct remove_extend { typedef T type; }; template &lt;typename T, std::size_t N&gt; struct remove_extend&lt;T[N]&gt; { typedef T type; }; //====================== end of sample.cpp ========================== </pre> Что произойдёт если не определять специализированный шаблон remove_extend<T[N]> для массива??

Какие присвоения для const int ct; const unsigned int* pt; long const* cpt; допустимы?

Как в языке С++ поддерживается идиома RAII?

Какие утверждения о назначении потоковых итераторов верны?

Каковы основные особенности наследования?

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

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

Где и для чего используется ключевое слово restrict?

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

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

<pre> //====================== start of sample.cpp ========================== std::merge( vector1.begin(), vector1.end(), std::istream_iterator(cin), std::istream_iterator(), std::back_inserter(list1) ); //====================== end of sample.cpp ========================== </pre> Который по номеру из параметров из вызова стандартного алгоритма, приведённого выше служит для индикации конца потока?

<pre> //====================== 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&amp; x) { x++; return;}; auto lf4 = [] (int x, int&amp; y) -> double {return x+y;}; auto lf5 = [] (bool&amp; z) { z = !z; return;}; return lf1(0); } //====================== end of sample.h ========================== </pre> Какие из приведённых выше лямбда функций возвращают тип bool?

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

К каким действиям препроцессора приводит использование директивы #include?

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

чем статические объекты памяти отличаются от автоматических объектов памяти?

Какие утверждения про операцию sizeof в языке C верны?

Какими способами можно передать массив в функцию?

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

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

В чём ограничены массивы переменной длины?

Каковы особенности выравнивания структур?

Какую информацию можно получить с помощью утилиты pfunct?

<pre> /*---- start of main.c ----*/ #include &lt;stdio.h&gt; const char* g_name = &quot;programm&quot;; char directory[8]; int main(int argc, char* argv[] ) { int i = 1; const char* right_name = &quot;right&quot;; for (; i&lt;argc; ++i) { if (0 == strcmp(argv[i], right_name)) return 0; } return 1; } /*---- end of main.c ----*/ </pre> В какой части памяти программы из вышеприведённого файла main.c находится переменная argc?

Какие операции выполняет функция malloc?

Какие парадигмы программирования поддерживает язык C++?

<pre> //====================== start of sample.h ========================== struct S_EMPTY {}; struct A { int i; double g; }; class B { long jj; public: char _str[6]; private: static char str_4_all[9]; }; union mytypes_t { int i; float f; } My; //====================== end of sample.h ========================== </pre> Доступ к каким из членов класса, описанных в файле sample.h (выше), является закрытым?

<pre> //====================== start of sample.cpp ========================== struct A {}; struct B; struct B *pb = new B; struct A *pa = new A; struct B b = *pb; class C { struct B m_b; }; class D { struct A m_a; }; //====================== end of sample.cpp ========================== </pre> Какие присвоения и объявления в файле sample.cpp валидны?

<pre> //====================== start of sample.cpp ========================== class User { public: const char* name; inline int age; private: volatile double balance; mutable char* job_name; protected: long long phone_number; static int phone_prefix = 499; }; //====================== end of sample.cpp ========================== </pre> Какие атрибуты класса User объявлены корректно?

В каких из приведённых ниже выражений нельзя обойтись без указателя this?

<pre> //====================== start of sample.cpp ========================== class Program { const char* prog_name; long threads_count; mutable double time_of_work; public: const char* get_name() const { return prog_name; } long get_threads_count() { return threads_count; } bool set_time_of_work(double in_time) const { time_of_work = in_time; return true; } bool add_time_of_work(double in_time) { time_of_work += in_time; return true; } }; const Program&amp; get_my_program(); int main() { const Program&amp; prg = get_my_program(); const char* prg_name1 = prg.get_name(); long my_thr_count1 = prg.get_threads_count(); bool result1 = prg.add_time_of_work(1); Program&amp; prg2 = const_cast&lt;Program& &gt;(prg); long my_thr_count2 = prg2.get_threads_count(); bool result2 = prg2.set_time_of_work(0); bool result3 = prg2.add_time_of_work(1); return 0; } //====================== end of sample.cpp ========================== </pre> При присвоении значений каким переменным в файле sample.cpp корректно используются корректно определённые методы?

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

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

<pre>//====================== start of sample.cpp ========================== #include &lt;vector&gt; class ServiceOrganization; class Building { static char* m_city; const unsigned int m_high_size; std::vector&lt;int&gt; m_flats; unsigned int m_square; ServiceOrganization&amp; m_organization; public: Building(); }; int main() { Building house; return 0; }//====================== end of sample.cpp ========================== </pre> Какие члены класса Building из файла sample.cpp обязательно должны быть инициализированы в списке инициализации?

<pre>//====================== start of sample.cpp ========================== class Input { public: Input(); }; class Output { public: Output(); }; class USBInput { }; class USBOutput { }; class SimpleComputer { long m_memory; const char* m_processor; Input m_input; Output m_output; public: long GetPerformance(); void Start(); void Reset(); }; class PersonalComputer: public SimpleComputer { USBInput m_input; UserOutput m_output; }; class LaptopComputer: public PersonalComputer { const char* m_processor; public: void Start(); void Reset(); };//====================== end of sample.cpp ========================== </pre> Какие атрибуты и методы базового класса SimpleComputer в файле sample.cpp остались не перекрыты в унаследованном классе LaptopComputer?

<pre>//====================== start of sample.cpp ========================== class Input { public: Input(); ~Input(); }; class USBInput: public Input { public: USBInput(); virtual ~USBInput(); }; class Device { public: Device(); ~Device(); }; class USBDevice: virtual public Device { public: USBDevice(); virtual ~USBDevice(); }; class ManualUserDev: public virtual USBInput { public: ManualUserDev(); virtual ~ManualUserDev(); }; class Key { public: Key(); ~Key(); }; class Keyboard: public Input, public Key { public: Keyboard(); ~Keyboard(); };//====================== end of sample.cpp ========================== </pre> Для которых из классов в файле sample.cpp в конструкторе может потребоваться явно вызвать конструкторы базовых классов?

Какие утверждения про производительность работы объектно-ориентированных программ на С++ верны?

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

<pre> //====================== start of sample3.h ========================== #include &lt;list&gt; #include &lt;vector&gt; template&lt;class Storage&gt; class MyIter {}; template&lt;class Storage&gt; void my_input_process(Storage* in_item) {} template&lt;class Storage, int size&gt; void clear_all(Storage*); template &lt;class Storage, class Element, int size&gt; class BackupInput {}; template &lt;class Storage, class Element, int size&gt; class Input { public: Input() : m_store(size) {} friend class MyIter&lt;Storage&gt;; friend void my_input_process&lt;Storage&gt;(Storage*); friend void clear_all&lt;Storage, 100&gt;(Storage*); friend class BackupInput&lt;Storage, Element, size&gt;; private: Storage m_store; }; Input&lt;std::list&lt;short&gt;, short, 25&gt; input25; int main() { MyIter&lt;std::list&lt;short&gt;&gt; my_iter; BackupInput&lt;std::list&lt;short&gt;, short, 25&gt; backup_input; my_input_process&lt;std::vector&lt;short&gt;&gt;(nullptr); clear_all&lt;std::vector&lt;short&gt;, 25&gt;(nullptr); clear_all&lt;std::list&lt;short&gt;, 100&gt;(nullptr); return 0; } //====================== end of sample3.h ========================== </pre> Какие функции и классы в файле sample.cpp имеют доступ к всем атрибутам глобального объекта input25?

<pre> //====================== start of sample.cpp ========================== template&lt;unsigned long N&gt; class binary { public: static unsigned long const value = binary&lt;N / 10&gt;::value &lt;&lt; 1 | N % 10; }; template&lt;&gt; class binary&lt;0&gt; { public: static unsigned long const value = 0; }; int main(int argc, char* argv[]) { static unsigned const xyz = binary&lt;111&gt;::value; return 0; } //====================== end of sample.cpp ========================== </pre> Конкретизация шаблона с значением 111 приводит:

<pre> //====================== start of sample.cpp ========================== #include &lt;type_traits &gt; class A { public: A(int in = 5); }; int main() { std::is_pointer&lt;A&gt; is_ptr; return 0; } //====================== end of sample.cpp ========================== </pre> Как может использоваться объявление переменной is_ptr?

<pre> //====================== start of sample.cpp ========================== #include &lt;type_traits&gt; template &lt;typename IT_1, typename IT_2, bool b&gt; IT_2 copy_imp(IT_1 first, IT_1 last, IT_2 out, const std::integral_constant&lt;bool, b&gt;&amp;) { while(first != last) { *out = *first; ++out; ++first; } return out; } template &lt;typename T&gt; T* copy_imp(const T* first, const T* last, T* out, const std::true_type&amp;) { memmove(out, first, (last-first)*sizeof(T)); return out * (last-first); } template &lt;typename I1, typename I2&gt; inline I2 copy(I1 first, I1 last, I2 out) { typedef typename std::iterator_traits&lt;I1&gt;::value_type value_type; return copy_imp(first, last, out, std::has_trivial_assign<value_type>()); } class A {}; int main() { std::vector&lt;short&gt; arr1; std::vector&lt;short&gt; arr2; copy(arr1.begin(), arr1.end(), arr2.begin()); return 0; } //====================== end of sample.cpp ========================== </pre> Какие утверждения про используемую функцию копирования copy_impl() верны?

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

<pre> //====================== start of sample.cpp ========================== #include &lt;stdexcept&gt; void my_open1() { throw int(8); } void my_open2() try { throw std::logic_error(&quot;&quot;); } catch(std::runtime_error&amp; err) {} void my_open3() try { throw std::runtime_error(&guot;runtime&quot;); } 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 ========================== </pre> Вызов каких из функций изнутри блока try в функции main() приведёт к завершению программы с результатом 5?

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

Какие отличия дека от вектора?

В чем отличие ассоциативных контейнеров от последовательных контейнеров?

Какие данные на вход обычно принимают обобщённые алгоритмы?

Какому классу итераторов эквивалентны указатели С++?

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

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

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

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

Какие вопросы решаются при определении интерфейсов объектов системы?

<pre> //====================== start of sample.cpp ========================== Декоратор Компоновщик Мост Фасад //====================== end of sample.cpp ========================== </pre> К какой группе шаблонов относятся приведённые выше шаблоны объектно-ориентированного проектирования?

Про какого из поражающих шаблонов можно сказать: «шаблон уровня объекта, отделяющий конструирование сложного объекта от его реализации»?

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

Какие утверждения про поведенческий шаблон «шаблонный метод» верны?

Какие из приведённых ниже атрибутов класса являются необходимыми при реализации идиомы «подсчёт ссылок»?

Какие утверждения насчёт реализации идиомы «Конверт/письмо» верны?

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

На что следует обратить внимание при оптимизации программ по производительности?

При оценке каких показателей согласно модели SQuaRE, предполагается анализ связности и переносимости кода?

Какие факторы способствуют накоплению технического долга?

<pre> //====================== ========================== class A { int _i; char* _name; public: A(); A(const A&amp; a); ~A(); A&amp; operator=(const A&amp; a); bool operator==(const A&amp; a) const; const char* getName() const; }; class B { public: B(int i, const char* name); ~B(); bool operator==(const B&amp; b) const; const char* getName() const; int getIndex() const; private: int _i; char* _name; }; class C { public: C(); C(C c); C(int i, const char* name); ~C(); C&amp; operator=(C c); const char* getName() const; int getIndex() const; int setIndex(); private: int _i; char* _name; }; class D { public: D(); D(const D&amp; d); ~D(); D&amp; operator=(const C&amp; d); int _i; char* _name; }; //====================== ========================== </pre> Код какого из приведённых в фрагменте кода классов соответствуют сложившимся эмпирическим правилам организации исходного кода на С++ и канонической форме класса?

<pre>//====================== start of sample.cpp ========================== class Person { short m_age; char* m_name; char* m_subname; public: Person(short age, char* name, char* subname) : m_age(age), m_name(name), m_subname(subname){} }; class Library { public: long m_books_count; const char* m_name; const char* m_city; }; int main() { Library my_lib = {1240, &quot;Main&quot;, &quot;DefaultCity&quot;}; Library *p_lib = new Library; Library empty_lib; Person any_person(25, &quot;Djon&quot;,&quot;S&quot;); Person *pother_person = new Person; return 0; }//====================== end of sample.cpp ========================== </pre> Инициализация каких объектов в файле sample.cpp выполняется корректно конструктором по умолчанию?

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

<pre> //====================== 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 = [&amp;Y, Z, &amp;a, &amp;b, X] (double x) {return x &gt; 0;}; return 0; } //====================== end of sample.cpp ========================== </pre> Значения каких переменным лямбда функция lf1 может изменить?

В чём основные отличия процессов, основанных на "каскадной" модели жизненного цикла разработки ПО от итеративного процесса разработки?

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

<pre> //====================== start of sample.cpp ========================== int main(int argc, char* argv[]) { int a = 0; int b = 0; int X = 0; auto lf1 = [&amp;a,&amp;b,&amp;X] (int x) {return x &gt; 0;}; auto lf2 = [a,b] (int x) { x++; return x;}; auto lf3 = [=] (int x) { x++; return x;}; auto lf4 = [&amp;] (int x) { x++; return x;}; auto lf5 = [] (bool&amp; z) { z = !z; return;}; return 0; } //====================== end of sample.cpp ========================== </pre> Какие из приведённых в примере лямбда функций могут изменить значения переменных а и b?

Какие контейнеры STL являются последовательными?

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

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

Какими средствами поддерживается в языке С++ обобщённое программирование?

Какие утверждения насчёт дружественных отношений в С++ верны?

Чем отличаются различные стадии разработки в жизненном цикле разработки системы?

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

<pre> //====================== 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&amp;) { } catch(B&amp;) { throw D(); } catch(D&amp;) { throw C(); } catch(...) { throw; } int main(int argc, char* argv[]) { try { foo(argc); } catch(const A&amp; a) {} catch(const B*) {} catch(C c) {} catch(E* e) {} catch(...) { return 5; } return 0; } //====================== end of sample.cpp ========================== </pre> При каких значении argc программа вернёт значение 5?

Какие директивы препроцессора необходимы при организации условной компиляции программ на языке С?

Для чего используется атрибут aligned компилятора gcc?

Какие из приведённых ниже операторов присвоения для элементов массива double m[8][4] являются правильными?

К какой характеристике класса памяти относится следующее определение: "откуда, из каких точек мы можем обратиться к этой переменной по её имени"?

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

Какие утверждения о размере процессорного кэша первого уровня верны?

Какие утверждения относительно инициализации многомерных массивов верны?

Каким образом порядок полей в структуре влияет на производительность памяти при работе с структурой (и массивом структур)?

<pre> //====================== start of sample.cpp ========================== class User { public: struct Region { short country_code; short city_code; static char* city_name; }; const char* name; int age; double balance; Region region; const char* get_name() const { return (*this).name; } int get_age() const { return this-&gt;age; } double get_balance() const { return (*this)-&gt;balance; } short get_country_code() const { return Region::country_code; } short get_city_code() const { return region.city_code; } const char* get_city_name() const { return Region::city_name; } }; //====================== end of sample.cpp ========================== </pre> В каких методах обращения к членам объекта класса user типа User корректны?

<pre> //====================== start of sample.cpp ========================== volatile unsigned long idx; volatile double times[16]; struct Program { double proc_time; long long mem_size; long long threads[20]; }; int main() { volatile Program prg; long my_idx = idx; double my_time1 = times[1]; double pmy_time5 = dynamic_cast&lt;double*&gt;(&times[5]); double *pmy_time10 = const_cast&lt;double*&gt; (&times[10]); Program *pmy_prog = static_cast&lt;Program*&gt;(&prg); long long* pmy_thread3 = const_cast&lt;long long*&gt;(&prg.threads[3]); return 0; } //====================== end of sample.cpp ========================== </pre> Присвоения значений каким переменным в файле sample.cpp корректны?

<pre> //====================== start of sample.cpp ========================== class Program { static char* prog_name; volatile long threads_count; mutable double time_of_work; long version; public: static char* get_name() { return prog_name; } long* getthreadscount() { return &amp;threads_count; } volatile long* get_threads_count() { return &amp;threads_count; } static double get_time_of_work() { return time_of_work; } volatile long get_version() { return version; } }; //====================== end of sample.cpp ========================== </pre> Какие методы в файле sample.cpp корректно обращаются к членам класса?

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

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

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

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

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

Контейнеры отличаются друг от друга:

Какие встроенные типы контейнера являются итераторами?

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

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

<pre> //====================== start of sample.cpp ========================== #include &lt;boost/variant/variant.hpp&gt; struct A {}; struct B { B(int src); private: B(const B&amp; src); }; struct C { C(int src); private: C(); }; struct D {}; int main(int argc, char* argv[]) { boost::variant&lt;int, A, B, C&gt; 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 ========================== </pre> Какие объекты можно присвоить объекту myvariant из примера в файле sample.cpp?

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

<pre> //====================== start of sample.cpp ========================== #include &lt;boost/shared_ptr.hpp&gt; #include &lt;boost/scoped_ptr.hpp&gt; #include &lt;boost/weak_ptr.hpp&gt; #include &lt;vector&gt; struct A { virtual ~A(); }; struct B: public A {}; struct C {}; void foo1(boost::scoped_ptr&lt;A&gt; a); void foo2(boost::scoped_ptr&lt;B&gt;&amp; a); void foo3(boost::shared_ptr&lt;C&gt; a); void foo4(boost::scoped_ptr&lt;A&gt;* a); void foo5(std::vector&lt; boost::scoped_ptr&lt;C&gt; &gt;&amp; c); int main(int argc, char* argv[]) { boost::scoped_ptr&lt;A&gt; b1(new A); boost::scoped_ptr&lt;B&gt; b2(new B); boost::scoped_ptr&lt;C&gt; b3(new C); boost::scoped_ptr&lt;A&gt; b4; std::vector&lt; boost::scoped_ptr&lt;C&gt; &gt; v1; v1.push_back(b3); foo1(b1); foo2(b2); foo3(b3.lock()); foo4(&amp;b4); foo5(v1); return 0; } //====================== end of sample.cpp ========================== </pre> В каких из функциях умный указатель boost::scoped_ptr используется правильно?

Какие объекты появляются и рассматриваются при проектировании?

Для каких порождающих шаблонов инстанциируемые классы определяются динамически?

Какие особенности использования структур и классов?

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

Какие из приведённых ниже сигнатур операций new и delete, которые могут быть перегружены указаны правильно?

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

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

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

Методы и атрибуты базового класса с каким модификатором доступа доступны классам потомкам?

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

Чем отличаются статические методы класса от нестатических?

Что влияет на наличие лакун в памяти при описании структуры?

Каких областей видимости нет в языке С, но есть в С++?

<pre> //====================== start of sample1.h ========================== struct S_EMPTY {}; typedef S_EMPTY my_empty_str; typedef std::vector&lt;int&gt; my_vector; typedef char[15] my_char15; class B { long jj; public: char _str[6]; private: static char str_4_all[9]; }; typedef B my_B; union mytypes_t { int i; float f; } My; typedef mytypes_t __My; //====================== end of sample1.h ========================== </pre> Какие из типов, описанных в файле sample1.h (выше), являются классом в широком смысле этого слова?

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

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

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

Переменные в каких областях памяти инициализируются до входа программы в функцию main()?

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

По какой причине необходимо отдельно рассматривать быстродействие оперативной памяти?

У каких классов памяти область видимости ограничена блоком кода?

Какой оптимальный вариант перебора данных для многомерного массива?

Почему в объявлении POSIX функции memmove() и memcmp() для параметров не используется ключевое слово restrict, а для memcpy используется?

Какие утверждения насчёт "пузырей" в конвейере инструкций ЦП верны?

Какие утверждения относительно функции free() верны?

<pre>//====================== start of sample.cpp ========================== class Input { public: Input(); ~Input(); }; class USBDev { public: ~USBDev(); }; class USBInput: public Input { USBDev m_dev; public: USBInput(): Input() {} ~USBInput(); }; class Device { public: Device(); ~Device(); }; class ManualUserDev: public Device { public: ManualUserDev() : Device() {} ~ManualUserDev(); }; class Key { public: ~Key(); }; class Keyboard: public USBInput, public ManualUserDev { Key* key; public: Keyboard(): ManualUserDev(), Input() {key = new Key();} ~Keyboard() { delete key; } };//====================== end of sample.cpp ========================== </pre> В каком порядке вызываются деструкторы при удалении объекта Keyboard из файла sample.cpp?

<pre>//====================== start of sample.cpp ========================== class Input { public: Input(); ~Input(); virtual void f(); }; class ManualUserDev: public Input { public: ManualUserDev(); virtual ~ManualUserDev(); }; class Keyboard: public Input { public: Keyboard(); ~Keyboard(); }; int main() { Keyboard keyboard; Input&amp; rinp = keyboard; Input* pinp = &amp:keyboard; ManualUserDev&amp; rmy_mdev = dynamic_cast&lt;ManualUserDev&amp;&gt;(rinp); ManualUserDev* pmy_mdev = dynamic_cast&lt;ManualUserDev*&gt;(pinp); Keyboard&amp; rmy_keyboard = dynamic_cast&lt;Keyboard&amp;&gt;(rinp); Keyboard* pmy_keyboard = dynamic_cast&lt;Keyboard*&gt;(pinp); return 0; }//====================== end of sample.cpp ========================== </pre> При инициализации какой переменной в файле sample.cpp будет брошено исключение?

<pre> //====================== start of sample.cpp ========================== template &lt;class Element, unsigned long max_size&gt; class Storage { public: Storage(Element) {} }; template &lt;class Element&gt; class Storage &lt;Element, 0 /* unlimited*/&gt; { public: Storage(Element e) {} }; template &lt;unsigned long max_size&gt; class Storage &lt;int, max_size&gt; { public: Storage(int e) {} }; template &lt;&gt; class Storage&lt;char*, 0&gt; { public: Storage(char* s) {} }; template &lt;&gt; class Storage&lt;char*, 100&gt; { public: Storage(char* s) {} }; int main() { int p1=4; Storage&lt;int, 5&gt; st1(p1); Storage&lt;char*, 100&gt; st2(char* s); Storage&lt;double, 80000&gt; st3(double n); Storage&lt;double, 0&gt; st4(double n); return 0; } //====================== end of sample.cpp ========================== </pre> Какой из шаблонов Storage в файле sample.cpp не задействован в функции main в файле sample.cpp?

<pre> //====================== start of sample.cpp ========================== #include &lt;type_traits&gt; 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 ========================== </pre> Какие утверждения о переменных my_true и my_false верны?

В чём заключается архитектурные свойства STL - взаимозаменяемость компонентов и унификация интерфейса?

Каковы основные особенности контейнера STL вектор?

По каким причинам для списка не подходят алгоритмы сортировки, реализованные как стандартные алгоритмы?

<pre> //====================== start of sample.h ========================== #include &lt;algorithm&gt; int main(int argc, char* argv[]) { size_t N = 40; int A[N]; size_t B[N*2]; char C[N]; int D[N]; std::replace(&amp;B[0], &amp;B[N/2], 0, 42); std::replace(C, (C+N+1), 'D', 'T'); std::copy(&amp;A[0], &amp;A[N-1], &amp;D[0]); std::copy(A, (A+N), D); return 0; } //====================== end of sample.h ========================== </pre> В каких из вызовов обобщённых алгоритмов встроенные массивы С++ использованы без ошибок?

В чём основное отличие итератора вставки от других итераторов STL?

<pre> //====================== start of sample.cpp ========================== bind2nd(greater&lt;int&gt;(), 100); //====================== end of sample.cpp ========================== </pre> Какие утверждения про приведённый выше адаптер верны?

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

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

<pre> //====================== start of sample.cpp ========================== #include &lt;climits&gt; #include &lt;limits&gt; #include &lt;boost/static_assert.hpp&gt; namespace name { BOOST_STATIC_ASSERT(std::numeric_limits&lt;int&gt;::digits == 32); } int main(int argc, char* argv[]) { return 0; } //====================== end of sample.cpp ========================== </pre> Что случится c программой из файла sample.cpp если в системе размер int больше 32 разрядов?

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

В ходе разработки дизайна должны быть обязательно выполнены следующие шаги:

По какой причине может потребоваться переделка дизайна в многослойной архитектуре?

Каковы особенности агрегирования по сравнению с осведомлённостью?

Какие возможности даёт использование поведенческий шаблон: наблюдатель?

Какие утверждения о поведенческом шаблоне «посетитель» верны?

Какие из нижеприведённых идиом являются объектно-ориентированными идиомами?

<pre> //====================== start of sample.cpp ========================== class ARef { public: ARef(A &amp;a, int i) : _a(a), _ix(i) {} ARef&amp; operator= (T t) { return *this;} operator T() {return _t;} operator A() {return _a;} A&amp; getA() { return _a;} bool operator == (A&amp; a) {return _a == a;} private: A&amp; _a; int _ix; T _t; }; class A { friend class ARef; public: A() {} ARef operator[] (int ix) {return ARef(*this, ix);} operator ARef() {return ARef(*this, ix);} }; int main() { A a; int i, j; T t; t = a[j]; return 0; } //====================== end of sample.cpp ========================== </pre> Какие из методов классов ARef и A из файла sample.cpp оказываются задействованы при операции t=a[j]?

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

<pre> //====================== 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 ========================== </pre> Перегрузка каких виртуальных методов базового класса в классе DiskIO выполнена корректно?

Для разработки каких классов программ широко используется язык С?

Какие возможности даёт использование поведенческий шаблон: команда?

В каких случаях проявляется проблема множественного наследования?

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

<pre> //====================== start of sample.cpp ========================== #include &lt;boost/shared_ptr.hpp&gt; #include &lt;boost/scoped_ptr.hpp&gt; #include &lt;boost/weak_ptr.hpp&gt; #include &lt;vector&gt; struct A { virtual ~A(); }; struct B: public A {}; struct C {}; void foo1(boost::shared_ptr&lt;A&gt; a); void foo2(boost::weak_ptr&lt;B&gt;&amp; a); void foo3(boost::shared_ptr&lt;C&gt; a); void foo4(boost::scoped_ptr&lt;A&gt;&amp; a); void foo5(std::vector&lt; boost::weak_ptr&lt;C&gt; &gt;&amp; c); int main(int argc, char* argv[]) { boost::shared_ptr&lt;A&gt; a(new A); boost::shared_ptr&lt;B&gt; b(new B); boost::shared_ptr&lt;C&gt; c(new C); boost::weak_ptr&lt;A&gt; b1(a); boost::weak_ptr&lt;B&gt; b2(b); boost::weak_ptr&lt;C&gt; b3(c); std::vector&lt; boost::weak_ptr&lt;C&gt; &gt; v1; v1.push_back(b3); foo1(b2.lock()); foo2(b2); try { boost::shared_ptr&lt;C&gt; c1(c); foo3(c1); } catch(boost::bad_weak_ptr&amp; e) { } foo4(b2.lock()); foo5(v1); return 0; } //====================== end of sample.cpp ========================== </pre> Вызовы каких функций выполнены корректно и операции создания их параметров не содержат очевидных проблем?

Какие утверждения про одномерные массивы в языке С верны?

В чём преимущества многомерного массива перед вектором векторов?

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

<pre> //====================== start of sample.cpp ========================== struct Semaphor { const long power_on:1; long red:1; long yellow:1; long green:1; static long is_new_version:1; }; int main() { Semaphor my_semaphor={1}; bool is_red = my_semaphor.red; long* pyellow = &amp;(my_semaphor.yellow); bool power_on = my_semaphor.power_on; int new_version = my_semaphor.is_new_version; return 0; } //====================== end of sample.cpp ========================== </pre> Какие присвоения битовых полей корректны (и соответственно описания этих полей) файле sample.cpp?

<pre>//====================== start of sample.cpp ========================== class Region; class Person { public: short m_age; const char* m_name; const char* m_surname; const char* m_region_name; Person(const char* name) : m_name(name) {} operator short () {return m_age;} operator const char* () {return &quot;&quot;;} operator Region* (); }; class Region { public: const char* region_name; const char* cheef_name; long size; Region(const char* region_nm) : region_name(region_nm) {} operator long () {return size;} operator const char* () {return region_name;} operator Person () {return Person(cheef_name);} }; Person::operator Region* () {return new Region(m_region_name);}//====================== end of sample.cpp ========================== </pre> Какие операторы преобразования класса Person не являются корректными с точки зрения архитектуры?

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

Какие утверждения про различные виды обобщённых алгоритмов верны?

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

В каких случаях используется идиома «Конверт/письмо»?

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

<pre> //====================== start of sample.cpp ========================== template &lt;typename T&gt; class multiplies: public binary_function&lt;T,T,T&gt; { public: T operator() (const T&amp; x, const T&amp; y) const { return x * y; } }; //====================== end of sample.cpp ========================== </pre> Какие утверждения про приведённый выше код функтора multiplies верны?

Какие характеристики описывают «структурное качество» программы?

Какие цели могут быть достигнуты рефакторингом?

На что распространяется константность константного объекта класса?

Какие утверждения относительно идиомы RAII верны?

Какие утверждения насчёт явного вызова деструктора верны?

<pre>//====================== start of sample.cpp ========================== #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;vector&gt; class ServiceOrganization; class BuildingElement { static char* m_city; std::vector&lt;int&gt; m_flats; unsigned int m_square; ServiceOrganization& m_organization; FILE *m_document; BuildingElement* m_pNext; public: BuildingElement(); BuildingElement(BuildingElement&amp;&amp; src) : m_square(0) , m_organization(src.m_organization) , m_document(src.m_document) , m_pNext(src.m_pNext) { m_flats = src.m_flats; src.m_flats.clear(); src.m_organization = ServiceOrganization(); ::fclose(src.m_document); src.m_document = NULL; ::free(src.m_pNext); src.m_pNext = NULL; } };//====================== end of sample.cpp ========================== </pre> Какие операции, выполняемые в конструкторе переноса в файле sample.cpp являются лишними?

<pre>//====================== start of sample.cpp ========================== class Person { public: long GetAge(); bool IsMale(); }; class Trader: private Person { public: long GetAge(); long GetAccount(); }; class Worker { public: long GetExperience(); long GetSalary(); }; class Developer : public Worker, private Person { }; class Boss: protected Worker { public: unsigned short GetLevel(); const char* GetDepartment(); }; class HeadOfAll: public Boss {};//====================== end of sample.cpp ========================== </pre> Для какого из производных классов в файле sample.cpp наследование выполнено для наследования интерфейса?

<pre> //====================== start of sample.cpp ========================== template&lt;unsigned long N&gt; class binary { public: static unsigned long const value = binary&lt;N / 10&gt;::value &lt;&lt; 1 | N % 10; }; template&lt;&gt; class binary&lt;0&gt; { public: static unsigned long const value = 0; }; int main(int argc, char* argv[]) { if (argc &gt; 1) { static unsigned const two = binary&lt;10&gt;::value; } return 0; } //====================== end of sample.cpp ========================== </pre> Когда будет посчитано значение переменной two?

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

Какие недостатоки шаблона «абстрактная фабрика»?

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

На что следует обратить внимание при оптимизации программ по размеру объектного кода и памяти данных?

Для чего предназначено макроопределение NULL?

<pre> //====================== start of sample.cpp ========================== class Region { short country_code; short city_code; char* city_name; public: Region(); short get_country_code() { return country_code; } inline short get_city_code() const; const char* get_city_name() const; }; Region::Region() : country_code(0) , city_code(0) , city_name(0) {} inline short Region::get_city_code() const { return city_code; } const char* Region::get_city_name() const { return city_name; } //====================== end of sample.cpp ========================== </pre> Какие из методов являются встроенными и объявлены корректно?

Каковы особенности шаблона «делегирование»?

<pre> //====================== start of sample.h ========================== struct A {}; struct B; struct B *pb = 0; struct A *pa = 0; struct B b; struct A a; void foo(const struct B&amp; in_b); //====================== end of sample.h ========================== </pre> Какие присвоения и объявления в файле sample.h валидны?

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

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

Целями проектирования всегда являются:

Какие задачи решаются на самом начальном этапе проектирования системы?

Какие возможности даёт использование поведенческий шаблон: посредник?

Для каких объектов данных связывание отсутствует?

К чему приведёт объявление переменной регистровой?

К какой характеристике класса памяти относится следующее определение: "насколько долго участок памяти, будет занят соответствующей переменной"?

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

Какие свойства отличают несложный код?

<pre>//====================== start of sample.cpp ========================== class Person { public: short m_age; const char* m_name; const char* m_surname; }; class Library { public: long m_books_count; std::string m_name; static std::string m_city; }; class Program { public: std::string prog_name; long version; void* prog_data; }; class Region { public: short country_code; short city_code; std::shared_ptr&lt;Library&lt; main_library; };//====================== end of sample.cpp ========================== </pre> Для какого из классов в фрагменте файла sample.cpp необходима реализация своего оператора копирования?

Какие цели преследовались и каким ценностям отдавалось предпочтение при создании STL?

Какие преимущества даёт инкапсуляция?

Какие утверждения про тип size_t в языке C верны?

С какими вариантами модификаторов и сигнатур могут быть деструкторы?