Главная /
Программирование /
Программирование на С/С++
Программирование на С/С++ - ответы на тесты Интуит
Правильные ответы выделены зелёным цветом.
Все ответы: Курс посвящен разработке приложений на языках программирования С и С++.
Все ответы: Курс посвящен разработке приложений на языках программирования С и С++.
Какие цели преследовались и каким ценностям отдавалось предпочтение при создании STL?
(1) максимальная общность
(2) максимальная эффективность
(3) максимальная понятность кода STL
(4) следование семантики работы с передачей по значению (семантика значений)
(5) следование фон-нэймоновской модели
Какую парадигму программирования поддерживают лямбда-функция в языке С/С++
(1) мето-программирование
(2) функциональное программирование
(3) объектно-ориентированное программирование
(4) процедурное программирование
Целями проектирования всегда являются:
(1) документирование дизайна системы позволяет детализировать описание задач для разработчиков
(2) моделирование поведения системы и оценка её архитектурных качеств
(3) получение максимально простой системы
(4) получение максимально гибкой системы
Какие утверждения о идиомах языка программирования верны?
(1) язык С++ содержит много идиоматики
(2) идиомы описываются в стандарте языка
(3) идиомы языка программирования универсальны и обычно одни и те же идиомы поддерживаются несколькими разными языками
(4) идиомы языка программирования позволяют более точно и аккуратно выразить архитектурные мысли
(5) идиомы языка С++ группируются по поддерживаемым парадигмам программирования
Каково текущее состояние языка С по отношению к С++?
(1) язык С - широко используемый самостоятельный язык, развивающийся параллельно языку С++
(2) язык С является основой языка С++ и в самостоятельном виде уже перестаёт сущест
(3) язык С продолжает развиваться в направлениях, некоторые из которых не являются основными для развития С++
(4) язык С интересен только в плане поддержки существующих продуктов, написанных на нём
Какие утверждения о размещения элементов многомерного массива в памяти верны?
(1) двухмерный массив T a[N][M] содержит N последовательно расположенных в памяти строк по M элементов
(2) двухмерный массив T a[N][M] содержит N произвольно расположенных в памяти строк по M элементов
(3) соглашения о размерности - это условности, с многомерным массивом можно работать как с одномерным
(4) многомерный массив может быть вектором векторов
Какие парадигмы программирования поддерживает язык C++?
(1) процедурное программирование
(2) обобщённое программирование
(3) объектно-ориентированное программирование
(4) декларативное программирование
(5) функциональное программирование
(6) логическое программирование
//====================== 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 = {"Owrell", 1984, "1984"};
Book book2 = {1984};
Person main_author = {65, "Bjarne", "Stroustrup"};
Person my_author(65, "Bjarne", "Stroustrup");
Library my_lib = 25;
return 0;
}
//====================== end of sample.cpp ==========================
]]>Инициализация каких объектов в файле sample.cpp выполнена корректно?
(1) book1
(2) book2
(3) main_author
(4) my_author
(5) my_lib
Какие утверждения о шаблонах в языке С++ верны?
(1) шаблонными могут быть не только классы или функции, но и структуры
(2) степень обобщённости класса зависит от количества параметров шаблона
(3) обобщённое программирование реализуется в языке С++ через шаблоны
(4) шаблон класса позволяет автоматически создавать конкретный класс по обобщённому описанию класса
(5) использование шаблонов позволяет сократить размер исполняемого файла
Какие основные элементы STL инкапсулируют хранение различных значений и объектов?
(1) контейнеры STL
(2) обобщённые алгоритмы STL
(3) итераторы STL
(4) адаптеры STL
(5) функциональные объекты
//====================== 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 ==========================
]]>Какие из приведённых выше лямбда функций возвращают тип bool?
(1) lf1
(2) lf2
(3) lf3
(4) lf4
(5) lf5
Какие объекты появляются и рассматриваются при проектировании?
(1) объекты модели проблемной области
(2) объекты стандарта С++ или другого языка программирования
(3) абстракции, применяемых в дизайне системы
(4) конкретизации шаблонов обобщенного программирования
(5) объекты, входящие в используемые в дизайне шаблоны проектирования
//====================== start of sample.cpp ==========================
class ARef
{
public:
ARef(A &a, int i) : _a(a), _ix(i) {}
ARef& operator= (T t) { return *this;}
operator T() {return _t;}
operator A() {return _a;}
A& getA() { return _a;}
bool operator == (A& a) {return _a == a;}
private:
A& _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 ==========================
]]>Какие из методов класса ARef из файла sample.cpp являются необходимыми для поддержки идиомы контекстно-зависимой перегрузки операции индексирования агрегата?
(1) operator= (T t);
(2) operator T();
(3) operator A();
(4) A& getA();
(5) bool operator == (A& a);
Какие утверждения о препроцессоре языка С верны?
(1) препроцессор - это компонент компилятора, на который первоначально отправляется код на языке С
(2) результатом работы препроцессора являются объектные файлы
(3) препроцессор содержится исключительно в компиляторе языка С, С++ и остальные языки не имеют препроцессоров
(4) препроцессор работает на основании фиксированного набора правил
Каким образом можно оптимизировать работу с памятью в high-load приложениях?
(1) оптимизировать обход многомерных массивов
(2) стараться размещать обрабатываемые совместно данные в соседних или близких ячейках памяти
(3) при инициализации массивов заполнять их нулями
(4) использовать векторные инструкции процессора
(5) переписать код на ассемблере
//====================== start of sample1.h ==========================
struct S_EMPTY
{};
typedef S_EMPTY my_empty_str;
typedef std::vector<int> 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 ==========================
]]>Какие из типов, описанных в файле sample1.h (выше), являются классом в широком смысле этого слова?
(1) my_empty_str
(2) my_vector
(3) my_char15
(4) my_B
(5) __My
Какие утверждения про конструктор с параметрами верны?
(1) конструктор с параметрами позволяет инициализировать как открытые, так и закрытые атрибуты класса
(2) конструктор с параметрами может быть использован в качестве конструктора по умолчанию
(3) если у класса не объявлен ни одни конструктор, то объект класса не может быть помещён ни в один из стандартных контейнеров STL
(4) использование конструктора с параметрами позволяет более эффективно, с точки зрения загрузки процессора, инициализировать атрибуты класса
Какой код приводит к появлению конкретизированного кода метода в исполняемом файле?
(1) взятие адреса конкретизированного метода класса
(2) взятие адреса конкретизированного объекта класса
(3) объявление специализации объекта класса
(4) объявление указателя на конкретизированный объект класса, с присвоением ему nullptr
Какие контейнеры STL являются последовательными?
(1) вектор
(2) множество
(3) список
(4) дека
(5) отображение
//====================== 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 ==========================
]]>Какие лямбда функции из примера выше имеют доступ к значению переменной X?
(1) lf1
(2) lf2
(3) lf3
(4) lf4
(5) lf5
По какой причине может потребоваться переделка дизайна в многослойной архитектуре?
(1) чрезмерное использование наследования
(2) верхний слой функций работает только с нижележащим слоем интерфейсов
(3) промежуточный слой использует функции всех нижележащих слоёв
(4) обработка одного из запросов верхнего уровня привязана к Windows платформе
(5) привязка алгоритмов обработки к представлению объектов
Какие из приведённых ниже сигнатур операций new и delete, которые могут быть перегружены указаны правильно?
(1) void *operator new(size_t size);
(2) void operator delete(void *p);
(3) void operator delete[](void *p);
(4) void *operator new[](size_t size, void *p)
К каким действиям препроцессора приводит использование директивы #include?
(1) препроцессор удаляет директиву
(2) препроцессор находит в файловой системе файл, имя которого задано в директиве
(3) препроцессор вставляет содержимое включаемого файла в то место, где была директива
(4) препроцессор игнорирует директивы #include, которые встречает в включаемом файле
В чём преимущества вектора векторов перед многомерным массивом?
(1) гарантирует смежное расположение всех элементов массива в памяти
(2) позволяет иметь разное количество элементов в каждой строке
(3) при большом размере массива снижает риск того, что в системе не найдётся подходящего куска памяти
(4) создавать и удалять вектор векторов проще чем массив
(5) уменьшает вероятность фрагментации памяти
//====================== 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& in_b);
//====================== end of sample.h ==========================
]]>Какие присвоения и объявления в файле sample.h валидны?
(1) pa
(2) pb
(3) a
(4) b
(5) void foo()
Для чего могут служить закрытые и защищённые конструкторы?
(1) предотвращение создания объектов класса из кода, который находится вне класса
(2) предотвращение операций копирования объектов класса
(3) преобразованию объектов класса в простые типы
(4) запретить создание объектов класса, доступных в коде программы
(5) оптимальное использование контейнеров стандартной библиотеки
//====================== 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?
(1) после успешной проверки условия argc
(2) при начале выполнения функции main
(3) при загрузке программы с оперативную память
(4) при компиляции программы
Какова сложность поиска перебором в последовательных контейнерах?
(1) O(1)
(2) O(ln(N))
(3) O(N)
(4) O(N**2
Каковы основные цели разработки boost?
(1) решение задач часто встречающихся задач, выходящих за пределы возможностей STL
(2) тестирование новых компиляторов С++
(3) тестирование новых библиотек-кандидатов на включение в принимаемые и перспективные стандарты языка С++
(4) стандартизация, используемых в различных компаниях, средств разработки ПО
//====================== start of sample.cpp ==========================
Декоратор
Компоновщик
Мост
Фасад
//====================== end of sample.cpp ==========================
]]>К какой группе шаблонов относятся приведённые выше шаблоны объектно-ориентированного проектирования?
(1) порождающие шаблоны
(2) структурные шаблоны
(3) поведенческие шаблоны
(4) базовые шаблоны
В каких случаях используется идиома «Конверт/письмо»?
(1) требуется работать с группой взаимозаменяемых классов и интерпретировать их, как принадлежащий одному типу
(2) преодолевать ограничения системы контроля типов, состоящие в жёсткой привязке имён переменных к объектам
(3) при реализации своего «сборщика мусора»
(4) повышение эффективности одновременного использования памяти отдельными классами
По какой причине необходимо отдельно рассматривать быстродействие оперативной памяти?
(1) используемые технические решения по кэшированию данных в процессоре, и поддержка их в операционных системах постоянно усложняются
(2) процессоры работают на большей частоте чем шина данных, по которой данные из оперативной памяти попадают процессору и быстродействие памяти становится критичным
(3) из-за того, что в кэш-памяти процессоров используются другие схемотехнические решения организации памяти
(4) есть возможности при разработке программ оптимизировать работу с кэшами процессора
Указателю на какой тип можно присвоить указатель на тип Т?
(1) указателю на void
(2) указателю на тип, совместимый с T
(3) указателю на тип, тождественный Т
(4) указателю только на тип Т
В каких ситуациях выполняется создание объекта типа?
(1) при объявлении объекта типа
(2) при объявлении указателя на объект типа
(3) при передаче объекта типа по ссылке из функции
(4) при передаче объекта тип по значению из функции
(5) при присвоении значения объекту типа
Какой из приведённых конструкторов копирования соответствуют канонической форме класса?
(1) Person(const Person* org);
(2) Person(Person* org);
(3) Person(const Person& org);
(4) Person(Person& org);
(5) Person(Person org);
Специализация класса позволяет:
(1) переопределить методы шаблона для заданных конкретизаций шаблона
(2) доопределить дополнительные методы и члены класса для заданных конкретизаций шаблона
(3) встроить специализированный шаблон в другую иерархию классов
(4) определять тип объекта по указателю на базовый класс
Каковы основные особенности контейнера STL вектор?
(1) произвольный доступ к элементам
(2) быстрое удаление и добавление последнего элемента контейнера
(3) быстрое удаление и добавление первого элемента контейнера
(4) полная гарантия корректности итераторов после вставки и удаления
(5) гарантия непрерывного размещения объектов контейнера в памяти
Какие из объектов шаблонов и макросов в рассмотренных библиотеках boost предназначены для предупреждения сборки с некорректными типами?
(1) BOOST_STATIC_ASSERT
(2) boost::variant
(3) boost::any
(4) boost::circular_buffer
Каковы основные особенности наследования?
(1) определяет реализацию одного класса в терминах другого
(2) позволяет выполнять подмену реализации во время исполнения программы
(3) используется меньшее количество объектов, в отличие от композиции
(4) размер класса получается меньше чем при композиции
(5) возникает высокая зависимость от реализации
Какие утверждения про рефакторинг верны?
(1) рефакторинг состоит из набора простых атомарных изменений кода
(2) рефакторинг не включает в себя изменения интерфейсов
(3) рефакторингу часто предшествует ревью кода
(4) рефакторинг помогает поддерживать качество продукта при продолжении разработки
(5) рефакторинг проводится тогда, когда больше не ожидается доработок и модификации программного продукта
К какой характеристике класса памяти относится следующее определение: "насколько долго участок памяти, будет занят соответствующей переменной"?
(1) время жизни
(2) область видимости
(3) связывание
(4) ни одно из вышеперечисленных
Где и для чего используется ключевое слово restrict?
(1) при объявлении указателей на объекты данных, для которых гарантируется что к ним нет никакого другого способа доступа кроме этих указателей
(2) при объявлении статических массивов объектов встроенных типов для оптимизации их размещения в памяти
(3) при передаче в функцию по указателю объектов данных, для которых гарантируется что к ним нет никакого другого способа доступа кроме этих указателей
(4) при объявлении указателей на объекты данных, которые желательно разместить в регистрах процессора
//====================== 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 ==========================
]]>Какие атрибуты класса User объявлены корректно?
(1) name
(2) age
(3) balance
(4) job_name
(5) phone_number
(6) phone_prefix
С какими вариантами модификаторов и сигнатур могут быть деструкторы?
(1) статический деструктор
(2) деструктор без модификаторов
(3) виртуальный деструктор
(4) деструктор с модификатором const
(5) деструктор с модификатором throw
(6) деструктор с одним параметром
//====================== 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 в вышеприведённом коде?
(1) проверка соответствия тела функции и необходимых методов класса
(2) исключение из списка подстановки для типа А перегрузок, которые не используют тип T::difference_type
(3) получение ошибки компиляции при отсутствии в шаблоне типа T::difference_type
(4) избежание ошибок компиляции, которые могут случиться при перегрузке функции неподходящим шаблоном
Какие отличия дека от вектора?
(1) последовательный доступ к элементам
(2) быстрая вставка и удаление в начало контейнера
(3) медленная вставка и удаление в конец контейнера
(4) быстрый поиск элемента по значению
Какие утверждения о применении и реализации проверки времени компиляции в boost верны?
(1) представляет собой аналог assert, но работает во время компиляции
(2) в реализации использованы отдельные шаблоны, для "корректного" и "некорректного" случаев и "корректный" шаблон ничего не делает
(3) в реализации использованы отдельные шаблоны, для "корректного" и "некорректного" случаев и оба шаблона выводят соответствующие сообщения
(4) в реализации использованы отдельные шаблоны, для "корректного" и "некорректного" случаев и "некорректный" шаблон ничего не делает
(5) не может быть применён внутри класса
Каковы особенности шаблона «делегирование»?
(1) назначение шаблона - передача ответственности на другой класс за выполнение запроса клиенту
(2) класс, поддерживающий шаблон "неизменяемый «объект» не должен иметь изменяемых атрибутов
(3) возникает 2 участника, которые могут быть в отношении наследования или композиции
(4) шаблон «отложенной инициализации» не может быть использован совместно с шаблоном «делегирование»
(5) при использовании шаблона «делегирование» упрощается статический анализ кода даже в случае сильной параметризации объектов
Какие из приведённых ниже особенностей кода являются неудачными решениями в области кодирования, дизайна и архитектуры?
(1) фрагменты кода, которые не исполняются в текущей сборке
(2) проверки интерфейса объекта вместо класса объекта
(3) обращение к неинициализированным переменным
(4) использование нескольких различных классов, вместо одного монолитного класса
(5) вставка в код фиксированных значений констант, ограничений и параметров конфигурации
Какие утверждения относительно характеристики класса памяти - связывания верны?
(1) связывание — это возможность обращаться к объекту данных (переменной)
(2) вариант связывания: внешний или внутренний определяется областью видимость объекта данных
(3) при внешнем связывании переменная доступна за пределами файла
(4) при внутреннем связывании время жизни определяется концом блока кода
Каким образом может быть объявлена функция, принимающая строку двухмерного или многомерного массива в качестве параметра?
(1) int foo(double a[][M], long N);
(2) int foo(long rows, long cols, double a[rows][cols]);
(3) int foo(double (*b)[M][M2][M3], long sz1)
(4) int foo(long , long , double a[*][*]);
(5) int foo(double (**b), long sz1)
Какие утверждения про статические члены класса верны?
(1) статический член класса - глобальный объект, существующий при отсутствии экземпляров класса
(2) статический член класса должен быть инициализирован в теле класса
(3) статический член класса принадлежит области видимости класса
(4) действие спецификаторов доступа не распространяется на статические члены класса
Какие утверждения насчёт явного вызова деструктора верны?
(1) при явном вызове деструктора не происходит освобождение памяти, занятого объектом
(2) работает в паре с оператором new c параметром - указателем на памяти, в которой должен быть размещён объект
(3) после явного вызова деструктора память нельзя снова использовать, необходимо её обязательно освободить
(4) после явного вызова деструктора память можно повторно использовать только под объекты этого же типа
//====================== 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]> для массива??
(1) при использовании типа, порождённого от базового шаблона будет бросаться excetption
(2) программа не соберётся из-за ошибки компиляции при подстановке массива в этот шаблон
(3) шаблонная структура определит remove_extend::type как Т[N] и этим типом неудобно пользоваться
(4) произойдёт резкое увеличение размера исполняемого файла из-за инстанциирования нового типа под каждый размер массива
В чем отличие ассоциативных контейнеров от последовательных контейнеров?
(1) время доступа значительно больше чем для любого последовательно контейнера
(2) хранимые данные должны иметь функцию сравнения
(3) имеются ограничения на модификацию хранимых данных
(4) добавление в начало и конец контейнера всегда константно
//====================== 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 ==========================
]]>Что случится c программой из файла sample.cpp если в системе размер int больше 32 разрядов?
(1) программа будет работать без изменений
(2) будет брошен exception при выполнении программы
(3) при запуске программы, как в assert будет поднято окно диалога с информацией о ошибке
(4) компиляция программы будет прервана, в логе компиляции будет сообщение о ошибке
(5) при компиляции возникнет предупреждение о возможной ошибке
Какой из порождающих шаблонов использует метод клонирования?
(1) абстрактная фабрика
(2) строитель
(3) фабричный метод
(4) прототип
(5) класс с единственным экземпляром
Какие характеристики описывают «структурное качество» программы?
(1) удобство сопровождения программы
(2) документированность архитектуры программы
(3) соответствие программы функциональным требованиям
(4) количество сбоев программы в единицу времени
(5) соответствие архитектуры критериям качества архитектуры
Для каких классов памяти связывание отсутствует?
(1) автоматический
(2) регистровый
(3) статический с внешним связыванием
(4) статический с внутренним связыванием
(5) статический без связывания
Каковы особенности выравнивания структур?
(1) структуры выравниваются в соответствии с наибольшей характеристикой среди элементов структуры
(2) объекты составных типов выравниваются в соответствии с характеристикой наибольшего элемента среди элементов структуры
(3) принудительное выравнивание статически размещаемых структур выполняется при помощи атрибута aligned
(4) принудительное выравнивание динамически размещаемых структур выполняется при выделении памяти функцией posix_memalig()
Какие утверждения про неустойчивые объекты верны?
(1) описываются модификатором volatile
(2) неустойчивые объекты могут быть изменены незаметно для компилятора, например в результате обработки прерываний
(3) компилятор должен оптимизировать хранение таких объектов, используя регистры процессора
(4) объекты, расположенные в разделяемой памяти обязательно должны быть объявлены как volatile
Какие утверждения верны относительно конструктора переноса и оператора присваивание с переносом?
(1) могут служить для передачи владения файлами
(2) в качестве входного параметра используется ссылка на право-допустимое значение
(3) могут служить для обеспечения доступа 2-х и более объектов к области памяти на который указывает атрибут класса
(4) методы класса с семантикой переноса позволяют повысить быстродействие и уменьшить потребности в памяти
Какие утверждения о работе с исключениями в языке С/С++ верны?
(1) исключения используются для обработки нештатных ситуаций времени исполнения программы
(2) в качестве классов исключений могут использоваться только пользовательские классы
(3) исключения используются для обработки ошибок времени компиляции
(4) если исключение не будет поймано, то будет вызвана системная функция terminate()
(5) часто в качестве класса исключений используются пустые типы
Какие утверждения про обобщённые алгоритмы верны?
(1) обобщённые алгоритмы предоставляют обобщённое решение разных задач обработки данных в обобщённых контейнерах
(2) для любого алгоритма существует копирующая версия алгоритма, которая переносит обработанные данные в другой контейнер
(3) обобщённые алгоритмы упорядочивания требуют определения операции сравнения элементов
(4) стандартом утверждена строгая классификация обобщённых алгоритмов
Какие из приведённых умных указателей выполняет автоматическое удаление объекта?
(1) scoped_ptr
(2) shared_ptr
(3) weak_ptr
(4) intrusive_ptr
Какой из структурных шаблонов помогает использовать чужой класс, интерфейс которого несовместим с классом, который его должен использовать?
(1) адаптер
(2) мост
(3) компоновщик
(4) декоратор
Каким показателем согласно модели SQuaRE, оценивается прочность и устойчивость системы, вероятность возникновения сбоев?
(1) надёжность
(2) эффективность
(3) безопасность
(4) удобство сопровождения
(5) размер программы
Какие утверждения про тип size_t в языке C верны?
(1) переменная этого типа возвращается операцией sizeof()
(2) может быть разного размера на разных платформах
(3) предназначен для оптимизации производительности программ на языке С
(4) используется часто в программах на С
Какие возможности даёт использование утилиты pahole?
(1) получить информацию о физическом размещении структур в памяти
(2) получить информацию о потерях быстродействия при доступе к памяти
(3) сколько линий кэш-памяти первого уровня займёт структура
(4) сколько строк и столбцов оперативной памяти займёт структура
(5) получить варианты реорганизации структуры
Какие утверждения про различные методы класса верны?
(1) нестатические методы могут быть использованы для работы с только нестатическими членами класса
(2) статические методы могут быть использованы для работы с только статическими членами класса
(3) доступ методов класса к его атрибутам определяется соотношением спецификаторов доступа метода и атрибута
(4) встроенные методы ведут к встраиванию кода метода в точку его вызова
(5) константные методы не могут модифицировать никакие данные класса, без исключений
(6) методы класса существуют даже если нет ни одного экземпляра класса
В каких случаях проявляется проблема множественного наследования?
(1) базовый класс имеет двух наследников
(2) производный класс унаследован от 2-х родительских классов, которые в свою очередь от наследованы от 2-х других разных классов
(3) производный класс унаследован от 2-х родительских классов, которые в свою очередь от наследованы от одного и того же базового класса
(4) производный класс унаследован от 2-х или более родительских классов, каждый из которых находится в своём namespace
//====================== 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?
(1) my_open1()
(2) my_open2()
(3) my_open3()
(4) my_open4()
Какие утверждения про итераторы верны?
(1) итераторы - это обобщённые указатели
(2) итераторы предназначены для обхода последовательности объектов в обобщённом контейнере
(3) классы итераторов различаются по быстродействию операций с ними
(4) любой итератор может быть успешно разыменован
Каковы особенности умного указателя boost::scoped_ptr?
(1) защищает объект от копирования
(2) поддерживает подсчёт ссылок на объект
(3) отсутствуют накладных расходов оперативной памяти
(4) может использоваться в контейнерах STL
(5) высокая скорость выполнения операций
Какой из структурных шаблонов помогает динамически добавлять новые обязанности объекту?
(1) адаптер
(2) мост
(3) компоновщик
(4) декоратор
(5) заместитель
Какие утверждения про атрибут качества - сложность программы верны?
(1) применение любых шаблонов проектирования уменьшает сложность
(2) сложность легко поддаётся количественной оценке
(3) накопление технического долга увеличивает сложность
(4) предварительное проектирование программы позволяет уменьшить сложность
(5) соблюдение общепринятых правил ОО-программирования уменьшает сложность
Какие утверждения про одномерные массивы в языке С верны?
(1) массив позволяет хранить серии значений в непрерывной области памяти
(2) массивы в языке С позволяет хранить объекты разного типа
(3) инициализация массивов должна быть только полной
(4) размер массивы при необходимости увеличивается вызовом функции realloc()
(5) рекомендуется передавать массивы в функцию с помощью указателей
Какие утверждения насчёт "пузырей" в конвейере инструкций ЦП верны?
(1) они появляются в результате предвыборки инструкций процессором и неоптимальной организации ассиметричных условных операторов
(2) "пузыри" в конвейере инструкций ЦП ведут к тому, что процессору приходится выполнять больше инструкций в единицу времени
(3) неоптимальная организация ассиметричных условных операторов ведёт к загрузке в кэш команд процессора инструкций, которые не будут выполняться
(4) неоптимальная организация ассиметричных условных операторов ведёт к загрузке в кэш данных процессора данных, которые не будут использоваться
(5) загрузка в кэш команд процессора инструкций, которые не будут выполняться, может быть полностью предотвращена использованием функции __builtin_expect()
Чем отличаются статические методы класса от нестатических?
(1) статическим методам не передаётся указатель this
(2) доступ к статическим методам возможен через операцию разрешения области видимости
(3) статические методы, в отличие от нестатических существуют даже тогда, когда нет ни одного экземпляра класса
(4) статические методы не могут быть встроенными
Какие утверждения насчёт абстрактных и конкретных классов верны?
(1) объект абстрактного класса не может быть создан
(2) у абстрактного класса не все методы имеют определение
(3) любой класс, унаследованный от абстрактного является конкретным классом и объект этого класса может быть создан
(4) абстрактные базовые классы специфицируют открытые интерфейсы и содержат общие для всей иеархии методы и атрибуты
(5) конкретный класс обязательно должен быть наследником абстрактного класса
(6) конкретный класс - это класс, объект которого можно создать
Какие утверждения о структурной безопасности ПО верны?
(1) структурная безопасность достигается обязательным отказом от использования исключений
(2) структурная безопасность требует большой аккуратности при написании кода приложения
(3) для достижения структурной безопасности важна разработка безопасной архитектуры
(4) структурная безопасность позволяет не бояться ошибок имплементации объявленных интерфейсов
Разыменование какого итератора ведёт к вставке элемента в контейнер?
(1) потоковый итератор
(2) итератор произвольного доступа
(3) итератор вставки
(4) изменяемый итератор прямого обхода
(5) никакой из перечисленных
//====================== 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 ==========================
]]>В каких из функциях умный указатель boost::scoped_ptr используется правильно?
(1) foo1
(2) foo2
(3) foo3
(4) foo4
(5) foo5
//====================== start of sample.cpp ==========================
template <class Receiver>
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 ==========================
]]>Какие атрибуты и методы класса MyCommand являются необходимыми для имплементации шаблона команда в файле sample.cpp?
(1) Execute();
(2) GetStatus();
(3) _action;
(4) _receiver;
(5) _last_error;
Какие утверждения про стандарты кодирования верны?
(1) стандарты оформления существуют для кода, написанного на языках высокого уровня
(2) стандарты оформления кода облегчают включение новых разработчиков в команду
(3) стандарты кодирования разработаны на основе исследований в различных областях математики и логики
(4) стандарты кодирования обычно имеют статус локальных правовых документов компании
(5) основу стандарта кодирования должны составлять низкоуровневые положения о оформлении кода (отступы, размер строки, имена переменных, итд.)
Для чего предназначено макроопределение NULL?
(1) для использования в операциях вычитания указателей
(2) для операций сравнения указателей
(3) для инициализации "пустых" указателей
(4) для улучшения понятности кода
Какие плюсы и минусы даёт встраивание функций?
(1) компилятор работает с линейным кодом, который весь загружен в кэш команд процессора
(2) исключаются операции, связанные с формированием кадра стека и вызовом функции
(3) полученный при встраивании большой блок кода компилятору сложнее оптимизировать
(4) если функции вызываются многократно из разных мест, то встраивание уменьшает объем объектного файла
(5) если маленькая функция вызываются многократно из разных мест, то встраивание может ухудшить производительность
Какие утверждения насчёт дружественных отношений в С++ верны?
(1) механизм дружественных отношений позволяет классу разрешать доступ к своим неоткрытым членам для внешних функций
(2) механизм дружественных отношений позволяет классу разрешать доступ к своим неоткрытым членам для всех функция пространства имён
(3) механизм дружественных отношений активно используется при потоковом вводе-выводе
(4) механизм дружественных отношений позволяет классу разрешать доступ к своим неоткрытым членам для всех методов другого класса
(5) механизм дружественных отношений позволяет классу разрешать доступ к заданным своим неоткрытым членам для отдельного метода другого класса
//====================== start of sample.cpp ==========================
class Computer
{
public:
Computer(OutPutDev& outdev)
: m_proc("amd64")
, 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& m_output;
Memory m_mem;
};
//====================== end of sample.cpp ==========================
]]>Какие утверждения о порядке вызовов конструкторов классов при создании объекта типа Computer в файле sample.cpp верны?
(1) атрибут m_proc инициализируется раньше всех
(2) для атрибута m_disk1 конструктор вызывается после вызова конструктора атрибута m_disk2
(3) конструктор InputDev для аттрибута m_pinput вызывается перед вызовом конструктора для инициализации атрибута m_mem
(4) конструктор OupPutDev для атрибута m_output вызывается до вызова конструктора класса Computer
Какие методы класса не должны бросать исключения наружу?
(1) конструкторы
(2) деструкторы
(3) константные методы
(4) безопасные методы
(5) статические методы
//====================== 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 ==========================
]]>Который по номеру из параметров из вызова стандартного алгоритма, приведённого выше служит для индикации конца потока?
(1) 1
(2) 2
(3) 3
(4) 4
(5) 5
Какая из библиотек Boost поддерживает работу с тернарной логикой?
(1) Boost Interval Container Library
(2) Boost.Tribool
(3) Boost.Units
(4) Math Toolkit
(5) Meta State Machine
Какие возможности даёт использование поведенческий шаблон: посредник?
(1) инкапсулировать обмен данными между клиентом и сервером в обмен объектам
(2) организация очереди исполняемых запросов
(3) обеспечивает доступ к содержимому агрегата без раскрытия его представления
(4) организовать взаимодействие большого количества объектов между собой
(5) построить широковещательные рассылки
Чем отличаются различные стадии разработки в жизненном цикле разработки системы?
(1) составом работ
(2) точкой зрения на систему
(3) на каждой стадии выполняется один, присущий только этой стадии тип работы
(4) существованием продукта. Он начинает существовать только с определённых стадий разработки
Для чего используется атрибут aligned компилятора gcc?
(1) для выравнивания в памяти глобальных переменных
(2) для выравнивания в памяти динамически размещаемых объектов
(3) для выравнивания в памяти автоматических переменных
(4) для задания размера процессорного кэша первого уровня
(5) для получения размера процессорного кэша первого уровня
Переменные в каких областях памяти инициализируются до входа программы в функцию main()?
(1) область данных
(2) сегмент BBS
(3) куча
(4) программный стек
Какие утверждения о классах-объединениях верны?
(1) служат для экономии памяти
(2) члены данных физически располагаются с одного и того же адреса
(3) размер равен максимальному размеру атрибута
(4) в одни момент времени хранит значение только одного из атрибутов
(5) внутри класса объединение должно иметь имя
Какие утверждения про виртуальные методы верны?
(1) по умолчанию в С++ все методы виртуальные
(2) метод объявленный виртуальным в базовом классе обязательно должен быть перегружен в классе потомке
(3) метод объявленный виртуальным в базовом классе будет виртуальным во всех потомках класса
(4) использование виртуальных методов включает полиморфизм и возможность позднего связывания
(5) виртуальность метода можно подавить
Какие утверждения про стандартные исключения верны?
(1) стандартная библиотека исключений содержит несколько независимых иерархий классов исключений
(2) иерархия исключений, используемая в разрабатываемом ПО должна быть основана на исключениях стандартной библиотеки
(3) все классы исключений из стандартной библиотеки являются производными от std::exceptiоn
(4) классы исключений из стандартной библиотеки являются безопасными
Какими типами конкретизируются контейнерные адаптеры?
(1) типами хранимых в контейнере элементов
(2) типами адаптируемых контейнеров
(3) типами итераторов вставки в контейнер
(4) значениями хранимых элементов
//====================== 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 ==========================
]]>Какие из типов из файла sample.cpp удовлетворяют требованию CopyConstructible?
(1) A
(2) B
(3) C
(4) D
Какие утверждения про поведенческий шаблон «шаблонный метод» верны?
(1) используется для задания в базовом классе порядка действий, выполняемых наследниками
(2) выполняемые действия обязательно должны быть реализованы в классах наследниках
(3) применяется когда код содержит много однотипных условных ветвлений
(4) при проектировании базового класса, реализующего алгоритм разработчик должен решить будет он использовать «зацепки» или «примитивные операции»
(5) шаблон шаблонный метод эмулирует технику выбора вызываемой операции «двойную диспетчеризацию»
Какие операции выполняет функция malloc?
(1) выделяет несколько фрагментов оперативной памяти, в сумме дающих заданный размер, увеличенный на размер служебной информации
(2) выделяет фрагмент оперативной памяти заданного размера и фрагмент памяти для служебной информации
(3) выделяет непрерывный фрагмент оперативной памяти, превышающий заданный размер на размер служебной информации
(4) обнуляет выделенный фрагмент памяти
(5) записывает служебную информацию начало выделенного фрагмента памяти
Какие операции в языке С++ поддерживают RTTI?
(1) sizeof
(2) dynamic_cast
(3) typeid
(4) reinterprent_cast
В чём заключается архитектурное свойств STL - гарантии вычислительной сложности?
(1) минимально возможный расход памяти для алгоритма
(2) гарантированное ограничение максимальной сложности работы алгоритма
(3) гарантии достижения минимально-возможной сложности работы алгоритма в каждом конкретном случае
(4) гарантии ограничения максимума расходуемом алгоритмом памяти
В каких случаях эффективно использование лямбда-функции?
(1) передача в обобщённый алгоритм STL
(2) передача функтора по указателю в пользовательскую функцию
(3) использование функциональности, унаследованной от другого класса
(4) при необходимости использования в функторе всех автоматические переменные из места передачи функтора в алгоритм
(5)
На этапе проектирования находятся компромиссы между следующими характеристиками системы:
(1) соответствие дизайна задаче vs. общности задачи
(2) доступность элементов системы vs. безопасность
(3) простота интерфейсов против возможности тонкой настройки
(4) гибкость настройки против расширяемости и переносимости
Какие особенности использования структур и классов?
(1) структуры часто используются для объектов с сложным поведением
(2) структуры используются, когда объект не имеет закрытых атрибутов
(3) нельзя смешивать при наследовании структуры и классы
(4) и классы и структуры одинаково могут использоваться в шаблонах
(5) структуры никогда не имеют конструкторов и деструкторов, в отличие от классов
Для разработки каких классов программ широко используется язык С?
(1) ядра операционных систем
(2) средства разработки программ
(3) UI приложения для работы с базами данных
(4) сервера баз данных
(5) веб-браузеры под Windows
Как правила выравнивания типов действуют при выделении памяти под массивы, многомерные массивы?
(1) правила выравнивания типов при выделении памяти под массив действуют на каждую строку массива
(2) правила выравнивания типов при выделении памяти под массив действуют на 0-й элемент массива
(3) правила выравнивания типов при выделении памяти под массив действуют на каждый элемент массива
(4) правилами выравнивания строк массива можно управлять посредством атрибута aligned
Какими средствами поддерживается в языке С++ обобщённое программирование?
(1) наследование
(2) лямбда функции
(3) шаблоны
(4) процедуры
Каковы преимущества использования конструктора с параметрами перед явной позиционной инициализацией объекта класса?
(1) поддержка инкапсуляции и абстрактных типов
(2) облегчение сопровождаемости кода и уменьшение вероятности ошибки
(3) эффективность с точки зрения затрат процессорного времени
(4) инициализируются как открытые, так и закрытые атрибуты класса
Какие утверждения о параметрах шаблонов верны?
(1) параметрами шаблона могут быть типы и константы
(2) параметры шаблона константы могут быть числовыми и строчными
(3) параметры шаблона могут иметь значения по умолчанию
(4) задание значений параметров шаблона происходит при конкретизации шаблона
(5) при конкретизации шаблона некоторые параметры можно оставлять неопределёнными
Какие основные элементы STL абстрагируют перемещение по коллекциям объектов?
(1) контейнеры STL
(2) обобщённые алгоритмы STL
(3) итераторы STL
(4) адаптеры STL
(5) функциональные объекты
//====================== 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 ==========================
]]>При вычислении каких переменных лямбда-функции в алгоритме count_if используются корректно?
(1) cnt1
(2) cnt2
(3) cnt3
(4) cnt4
(5) cnt5
Какие задачи решаются на самом начальном этапе проектирования системы?
(1) определение границ системы
(2) определение методов объектов системы
(3) моделирование предметной области
(4) определение количества атрибутов у объектов системы
(5) определение сигнатуры интерфейсов объектов
//====================== start of sample.cpp ==========================
class ARef
{
public:
ARef(A &a, int i) : _a(a), _ix(i) {}
ARef& operator= (T t) { return *this;}
operator T() {return _t;}
operator A() {return _a;}
A& getA() { return _a;}
bool operator == (A& a) {return _a == a;}
private:
A& _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 ==========================
]]>Какие из методов классов ARef и A из файла sample.cpp оказываются задействованы при операции t=a[j]?
(1) ARef::operator= (T t);
(2) ARef::operator T();
(3) ARef::operator A();
(4) ARef A::operator[] (int ix)
(5) A::operator ARef();
Какие утверждения о директивах препроцессора языка С верны?
(1) каждая директива начинается с знака кривой решётки
(2) действие каждой директивы распространяется до конца файла
(3) директивы должны быть написаны только большими латинскими буквами
(4) при современном уровне развития языка С, большинство директив могут быть безболезненно заменены конструкциями языка
Какой оптимальный вариант перебора данных для многомерного массива?
(1) упорядоченный перебор, не важно по столбцам или по строкам ускоряет быстродействие операции
(2) перебор строк двухмерного массива по столбцу выполняется эффективнее чем перебор столбцов по строке
(3) перебор столбцов по строке выполняется эффективнее чем перебор строк двухмерного массива по столбцу
(4) случайный доступ к элементам массива не отличается по эффективности от любого типа упорядоченного перебора
(5) .
//====================== 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 ==========================
]]>Доступ к каким из членов класса, описанных в файле sample.h (выше), является закрытым?
(1) A::i
(2) B::jj
(3) B::_str
(4) B::str_4_all
(5) My::f
//====================== start of sample.cpp ==========================
#include <vector>
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("unknown"){}
};
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, "Vasily", "Ivanov", 123456);
return 0;
}
//====================== end of sample.cpp ==========================
]]>Значения каких атрибутов каких объектов корректно инициализируются не нулевыми значениями?
(1) reader1.m_age
(2) reader1.m_name
(3) reader1.m_ticket_numbe
(4) reader2.m_ticket_number
(5) reaedr3.m_age
//====================== 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?
(1) template <class Element, unsigned long max_size> class Storage
(2) template <class Element> class Storage <Element, 0>
(3) template <unsigned long max_size> class Storage <int, max_size>
(4) template <> class Storage<char*, 0>
(5) template <> class Storage<char*, 100>
Какой из последовательных контейнеров требует самое большое время для доступа к элементам контейнера?
(1) вектор
(2) встроенный массив С++
(3) список
(4) дека
//====================== 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 ==========================
]]>Значения каких переменным лямбда функция lf1 может изменить?
(1) a
(2) b
(3) X
(4) Y
(5) Z
На какие будущие изменения проектируемой системы необходимо обратить внимание при её проектировании?
(1) поддержка новых функций
(2) поддержка новых платформ
(3) оптимизация реализации используемых алгоритмов
(4) развитие смежных технологий, с которыми системе приходиться взаимодействовать
По каким причинам может потребоваться перегрузка операторов new и delete - глобальных или класса?
(1) для классов, создающих мелкие объекты - для экономии памяти
(2) для организации быстрого доступа к элементам контейнера STL
(3) при большом количестве операций создания-удаления объектов - для уменьшения фрагментации памяти
(4) при реализации своего «сборщика мусора»
(5) для организации доступа к закрытым членам класса
Какие функции и особенности директив препроцессора #define - #undef указаны верно?
(1) #define используется для замены "магических чисел" на строковые константы
(2) #define использутеся для прерывания процесса компиляции если не выполняются некоторые условия
(3) #define и #undef вводят и отменяют заданное имя, которое может быть использовано при условной компиляции
(4) при использовании #define для задания строковых констант, эти строковые константы в коде всегда необходимо заключать в круглые скобки
(5) используемые аргументы макроопределения рекомендуется заключать в скобки
В чём преимущества многомерного массива перед вектором векторов?
(1) гарантирует смежное расположение всех элементов массива в памяти
(2) позволяет иметь разное количество элементов в каждой строке
(3) создавать и удалять массив проще чем вектор векторов
(4) уменьшает вероятность фрагментации памяти
//====================== 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 ==========================
]]>Какие присвоения и объявления в файле sample.cpp валидны?
(1) pa
(2) pb
(3) b
(4) C::m_b
(5) D::m_a
В каких случаях происходит по членная инициализация объекта класса?
(1) тогда, когда в классе не объявлено ни одного конструктора
(2) тогда, когда в классе объявлен только конструктор без параметров
(3) тогда, когда в классе есть только конструкторы с параметрами
(4) для объектов структур, у которых нет ни одного конструктора
(5) для объектов классов, у которых конструктор без параметров объявлен защищённым
//====================== 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 приводит:
(1) к рекурсивной конкретизации шаблона с параметрами 10, 1, 0
(2) к последовательной трёхкратной конкретизацией шаблона с параметрам 1
(3) к рекурсивной конкретизации шаблона с параметрами 11, 1, 0
(4) к рекурсивной конкретизации шаблона с параметрами 11, 1, 1
Какие утверждения насчёт ассоциативных контейнеров верны?
(1) ассоциативные контейнеры предоставляют быстрый доступ к элементам по ключу
(2) ассоциативные контейнеры - это контейнеры переменной длины
(3) в ассоциативных контейнерах все ключи должны быть уникальны
(4) для ассоциативных контейнеров гарантируется размещение соседних элементов в смежной оперативной памяти
Какие утверждения о boost верны?
(1) boost имеет большое комьюнити
(2) использование boost у себя одобрено всеми компаниями-производителями ПО без ограничений
(3) boost включает в себя набор из нескольких десятков библиотек
(4) это передний фронт языка С++
(5) использование разного функционала boost требует включения единого набора библиотек в проект
Какие утверждения про шаблоны объектно-ориентированного проектирования верны?
(1) шаблоны — это типовые решения для типовых архитектурных проблем
(2) каждый шаблон привязан к своей предметной области
(3) использованием шаблонов достигается само-документируемость архитектуры
(4) использованием шаблонов достигается значительное повышение быстродействия системы
В чём состоит идиома «Конверт/письмо»?
(1) разные конструкторы базового класса могут создавать объекты разных классов - наследников базового класса
(2) базовый класс содержит в себе ссылки на объекты унаследование классы - служит для них конвертом
(3) вызовы методов базового класса делегируются экземпляру унаследованного класса
(4) операторы new и delete переопределены для базового класса
(5) клиент обязан знать имена классов наследников
Какие утверждения про кэш память процессора верны?
(1) причиной появления кэш памяти процессора являются различия в производительности процессора и шины процессора, через которые данные из оперативной памяти доставляются в процессор
(2) некоторые приложения специально оптимизируют под использование кэша процессора
(3) кэш-память процессора обычно много уровневая
(4) обычно кэш память процессора строится на тех же физических принципах, что и обычная оперативная память
Каковы основные правила при присвоении одного указателя другому?
(1) базовые типы должны быть тождественны
(2) достаточно того что бы базовые типы были совместимы
(3) константный указатель можно присвоить только константному указателю
(4) указатель на константный объект можно присвоить только указателю на константный объект
(5) указателю на void можно присвоить любой как константный, так и не константный указатель
Какие операции можно делать с ссылками?
(1) обнулять
(2) снимать косвенность
(3) инициализировать
(4) выполнять операции с данным и методами объекта, на который указывает ссылка
(5) возвращать как результат выполнения функции
//====================== start of sample.cpp ==========================
#include <stdio.h>
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 "";}
};
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;}
};
int main()
{
Person p1("Vasily Ivanov");
Region r;
printf("Region number %u, driver %s", static_cast<unsigned short>(r), static_cast<const char*>(p1));
return 0;
}
//====================== end of sample.cpp ==========================
]]>Какие из имеющихся в файле sample.cpp конструкторов и операторов преобразования задействованы в операциях в функции main()?
(1) Person::Person(const char* name)
(2) Person::operator short ()
(3) Person::operator const char* ()
(4) Region(const char* region_nm = "")
(5) Region::operator long ()
(6) Region::operator const char* ()
Какие утверждения о идиоме SFINAE верны?
(1) сутью идиомы SFINAE является избежание ошибок компиляции при перегрузке функций путём отбрасывания неподходящих шаблонов из списка кандидатов на подходящую перегрузку
(2) идиома SFINAE поддерживается компилятором и препроцессором языка С++
(3) идиома SFINAE работает при автоматическом выводе типа шаблона по аргументам функции
(4) при SFINAE рассматривается не только заголовок, но и тело функции (метода)
Какие встроенные типы контейнера являются итераторами?
(1) iterator
(2) pointer
(3) reverse_iterator
(4) const_reference
(5) size_type
Какие из объектов шаблонов и макросов в рассмотренных библиотеках boost предоставляют безопасный обобщённый контейнер с возможностью хранения различных типов?
(1) BOOST_STATIC_ASSERT
(2) boost::variant
(3) boost::any
(4) boost::circular_buffer
Каковы основные особенности композиции?
(1) определяет реализацию одного объекта в терминах другого
(2) позволяет выполнять подмену реализации во время исполнения программы
(3) используется меньшее количество объектов, в отличие от наследования
(4) размер класса получается больше чем при наследовании
Какие цели могут быть достигнуты рефакторингом?
(1) повышение читаемости кода
(2) устранение использования небезопасных функций
(3) убрано дублирование кода
(4) улучшение композиции программного обеспечения
(5) устранение неопределённого поведения программы
К какой характеристике класса памяти относится следующее определение: "откуда, из каких точек мы можем обратиться к этой переменной по её имени"?
(1) время жизни
(2) область видимости
(3) связывание
(4) ни одно из вышеперечисленных
Каковы условия контракта, который заключается с компилятором использованием ключевого слова restrict при объявлении указателя?
(1) указатель является единственным способом доступа к области памяти в блоке кода
(2) компилятор будет использовать оптимистичную стратегию оптимизации при работе с памятью, на которую указывает этот указатель
(3) компилятор гарантирует что не допустит доступа ко этому объекту памяти через другой указатель
(4) компилятор попытается по возможности разместить указатель в регистре процессора
//====================== 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 ==========================
]]>Какие методы класса User объявлены корректно?
(1) get_name()
(2) get_age()
(3) get_balance()
(4) get_job_name()
(5) get_phone_number()
(6) get_phone_prefix()
Какие операции обычно может выполнять деструктор?
(1) закрытие файлов
(2) выделение памяти
(3) проверка пред-условий возможности удаления объекта
(4) освобождение примитивов синхронизации
(5) открытие сетевого соединения
//====================== 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?
(1) если А не указатель, то код не соберётся
(2) можно обратится к статическому атрибуту is_ptr.value и сравнить его с true
(3) можно проверить тип is_ptr: он может быть true_type или false_type
(4) если А не указатель, то при выполнении программы в месте создания is_ptr возникнет прерывание
Какие отличия списка от вектора?
(1) последовательный доступ к элементам
(2) быстрая вставка и удаление в начало контейнера
(3) медленная вставка и удаление в конец контейнера
(4) инвалидация итераторов не происходит при модификации контейнера
(5) отсутствие гарантий размещения данных в непрерывном куске памяти
Какие преимущества обеспечивает тип boost::variant по сравнению с union?
(1) контроль хранимого типа
(2) более экономное использование памяти
(3) поддержка стандартных функций boost
(4) большее разнообразие хранимых типов
(5) различимость хранимых типов
Каковы особенности базового шаблона «неизменяемый объект»?
(1) в модуле может быть только один по одному экземпляру каждого класса, поддерживающего этот шаблон
(2) через шаблон «неизменяемый объект» выполняется передача ответственности от одного объекта другому (за исполнение запросов клиента)
(3) класс, поддерживающий шаблон «неизменяемый объект» не должен иметь изменяемых атрибутов
(4) класс, поддерживающий шаблон «неизменяемый объект» не должен иметь методов, изменяющих состояние объекта
(5) шаблон «отложенной инициализации» не может быть использован для типа, поддерживающего шаблон «неизменяемый объект»
На поиск каких ошибок кодирования, являющихся типовыми, направлено ревью кода?
(1) использование префиксного оператора «++» вместо постфиксного
(2) неверный способ передачи параметров
(3) неверная обработка «пустых указателей»
(4) использование сортировки пузырьком вместо построения бинарного дерева
(5) неверная обработка краевых условий
Для каких объектов данных связывание отсутствует?
(1) для глобальных переменных, объявленных на уровне файла
(2) для объектов с ключевым слово static, объявленных на уровне файла
(3) для объектов внутри объявления функций
(4) для объектов внутри блока кода
Какие особенности динамических массивов указаны верно?
(1) размер динамического массивы может быть изменён во время его жизни
(2) размер динамического массивы определяется в момент начала исполнения блока кода, где этот массив объявлен
(3) использование массива переменной длины как формального параметра функции означает передачу данных по указателю
(4) инициализировать массив переменной длины при его объявлении возможно, как константами, так и переменными
Каких областей видимости нет в языке С, но есть в С++?
(1) функция
(2) блок кода
(3) class
(4) namespace
(5) файл
//====================== start of sample.cpp ==========================
#include <vector>
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<unsigned char>* mybuffer = new std::vector<unsigned char>(sizeof(Person) + sizeof(Region), 0);
Person* my_person = new (&(mybuffer->at(0))) Person();
my_person->~Person();
delete my_person;
Region* p_region = new (&(mybuffer->at(0))) Region();
p_region->~Region();
delete p_region;
delete mybuffer;
return 0;
}
//====================== end of sample.cpp ==========================
]]>Какие операции освобождений ресурсов в файле sample.cpp являются лишними или ошибочными?
(1) my_person->~Person();
(2) delete my_person;
(3) p_region->~Region();
(4) delete p_region;
(5) delete mybuffer
(6) нет ошибочных и лишних операций освобождения ресурсов
//====================== 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() будет использована верны?
(1) выполняется функция, которая требует наличия операции присваивания
(2) выполняется функция, реализующая максимально общее решение
(3) выполняется функция, реализующая наиболее эффективное решение
(4) третьим параметром функции copy_impl() является тип true_type
(5) типы параметров first и out должны поддерживать операция разыменования
Каким образом определяется эквивалентность ключей в ассоциативных контейнерах?
(1) используется специальная функция ключа is_equivalent()
(2) используется оператор равенства "=="
(3) используются операторы больше и меньше и если один ключ не меньше другого и наоборот, то ключи считаются эквивалентны
(4) используется только оператор меньше и если один ключ не меньше другого и наоборот, то ключи считаются эквивалентны
//====================== 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 ==========================
]]>Какие объекты можно присвоить объекту myvariant из примера в файле sample.cpp?
(1) x
(2) y
(3) a
(4) b
(5) c
(6) d
Про какого из поражающих шаблонов можно сказать: «шаблон уровня объекта, отделяющий конструирование сложного объекта от его реализации»?
(1) абстрактная фабрика
(2) строитель
(3) фабричный метод
(4) прототип
(5) класс с единственным экземпляром
Каким образом можно оценить «структурное качество» программы?
(1) анализ описания архитектуры
(2) чтение пользовательской документации
(3) статический анализ кода
(4) тестирование функциональных характеристик программы
(5) чтение кода программы
У каких классов памяти область видимости ограничена блоком кода?
(1) автоматический
(2) регистровый
(3) статический с внешним связыванием
(4) статический с внутренним связыванием
(5) статический без связывания
Какие утверждения относящиеся к упаковке структуры в памяти верны?
(1) при выравнивании элементов структуры в памяти возникают пропуски памяти
(2) пропуски в памяти, возникающие при размещении структуры в памяти являются непроизводительной затратой памяти
(3) пропуски в памяти, возникающие при размещении структуры в памяти приводят к задержкам при записи данных структуры в память
(4) пропуски в памяти, возникающие при размещении структуры в памяти могут привести к увеличению занимаемых структурой линий кэша процессора
//====================== 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<double*>(×[5]);
double *pmy_time10 = const_cast<double*> (×[10]);
Program *pmy_prog = static_cast<Program*>(&prg);
long long* pmy_thread3 = const_cast<long long*>(&prg.threads[3]);
return 0;
}
//====================== end of sample.cpp ==========================
]]>Присвоения значений каким переменным в файле sample.cpp корректны?
(1) my_idx
(2) my_time1
(3) pmy_time5
(4) pmy_time10
(5) pmy_porg
(6) pmy_thread3
//====================== start of sample.cpp ==========================
#include <stdio.h>
#include <stdlib.h>
#include <vector>
class ServiceOrganization;
class BuildingElement
{
static char* m_city;
std::vector<int> m_flats;
unsigned int m_square;
ServiceOrganization& m_organization;
FILE *m_document;
BuildingElement* m_pNext;
public:
BuildingElement();
BuildingElement(BuildingElement&& 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 ==========================
]]>Какие операции, выполняемые в конструкторе переноса в файле sample.cpp являются лишними?
(1) src.m_flats.clear();
(2) src.m_organization = ServiceOrganization();
(3) ::fclose(src.m_document);
(4) src.m_document = NULL;
(5) ::free(src.m_pNext);
(6) src.m_pNext = NULL;
Чем отличается обработка ошибок посредством прерываний от проверки кода возврата?
(1) носителем информации о нештатной ситуации являются объекты заранее продуманной иерархии классов исключений
(2) блок кода, обрабатывающий нештатную ситуация при возбуждении исключения может быть размещён на любом вышестоящем по стеку уровне
(3) игнорирование кода возврата не приводит к падению приложения
(4) обработка ошибок посредством прерываний делает код сложнее
(5) обработка ошибок посредством прерываний даёт выигрыш в быстродействии
Какие утверждения об отношениях сравнения, используемых в обобщённых алгоритмах STL верны?
(1) операции сравнения, используемые в обобщённых алгоритмах STL являются унарными предикатами
(2) отношения сравнения должны быть транзитивны
(3) позволяют установить эквивалентность
(4) объекты считаются эквивалентными если оператор равенства возвращает true
Какие операторы перегружаются для умных указателей (в частности для shard_ptr)?
(1) operator*()
(2) operator->()
(3) operator<()
(4) operator=()
(5) operator!=()
Какой из структурных шаблонов помогает разорвать связь между интерфейсом и реализацией интерфейса?
(1) адаптер
(2) мост
(3) компоновщик
(4) декоратор
При оценке каких показателей согласно модели SQuaRE, предполагается рассмотрение соблюдение правил кодирования?
(1) надёжность
(2) эффективность
(3) безопасность
(4) удобство сопровождения
(5) размер программы
Какие утверждения про операцию sizeof в языке C верны?
(1) вычисляется во время исполнения программы
(2) возвращает тип size_t
(3) возвращает объём выделенной под объект памяти с учётом выравнивания
(4) возможна как скобочная, так и без скобочная форма записи
(5) применяется только к именам типов
Какие утверждения насчёт оптимизации быстродействия работы с структурами верны?
(1) компоновка в отдельные структуры только данных, которые используется совместно, повышает быстродействие доступа к памяти с этими данными
(2) замена нескольких компактных структур на одну большую повышает быстродействие работы с памятью
(3) пересмотр всех используемых типов на возможность уменьшения размеров полей структуры может привести к повышению быстродействия
(4) оптимизация быстродействия путём реорганизации структур повышает читаемость и сопровождаемость кода
(5) порядок следования полей в структурах влияет на быстродействие доступа к полям структуры
//====================== 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 ==========================
]]>Какие из методов являются встроенными и объявлены корректно?
(1) конструктор
(2) деструктор по умолчанию
(3) get_country_code()
(4) get_city_code()
(5) get_city_name()
Каким образом предполагается решать проблему множественного наследования в языке С++?
(1) запрет множественного наследования
(2) активное использование шаблонов
(3) использование виртуального наследования
(4) замена наследования на владение объектом класса для одного из родительских классов
//====================== 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 ==========================
]]>Обработчики исключений какого типа записаны неправильно?
(1) A
(2) B
(3) C
(4) D
(5) E
(6) F
Какому классу итераторов эквивалентны указатели С++?
(1) итераторы входные
(2) итераторы выходные
(3) итераторы однонаправленные
(4) итераторы двунаправленные
(5) произвольного доступa
Каковы особенности умного указателя boost::shared_ptr?
(1) защищает объект от копирования
(2) поддерживает подсчёт ссылок на объект
(3) может использоваться в контейнерах STL
(4) возможность образования циклических ссылок
(5) поддержка операции сравнения, необходимой для хранения в ассоциативном контейнере
Какой из структурных шаблонов описывает разбиение системы на слои?
(1) адаптер
(2) фасад
(3) компоновщик
(4) декоратор
(5) заместитель
Какие свойства отличают несложный код?
(1) модульность кода
(2) краткость кода
(3) использование объектно-ориентированного подхода
(4) слабая связность модулей кода
(5) использование перехватчиков сигналов операционной системы для обеспечения отказоустойчивости программы
Каким образом будет инициализирован массив целых чисел, если объявлена его инициализация одним числом: int А[10] = {10};?
(1) все элементы массива будут инициализированы числом 10
(2) первый элемент массива будет инициализирован числом 10, а остальные будут иметь непредсказуемое значение
(3) первый элемент массива будет инициализирован числом 10, а остальные будут иметь значение 0
(4) указание меньшего количества инициализирующих значений чем размерность массива недопустимо и приведёт к ошибке компиляции
Каким образом может решаться проблема неоптимальных ветвлений кода?
(1) профилирование с целью узнать: какие условные ветвления кода выполняются чаще
(2) реорганизация кода таким образом, что бы в условном операторе стояло условие, которое выполняется чаще чем не выполняется
(3) использование функции __builtin_expect()
(4) использование GCC-атрибутов always_inline и noinline
//====================== 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 &threads_count; }
volatile long* get_threads_count()
{ return &threads_count; }
static double get_time_of_work()
{ return time_of_work; }
volatile long get_version()
{ return version; }
};
//====================== end of sample.cpp ==========================
]]>Какие методы в файле sample.cpp корректно обращаются к членам класса?
(1) get_name()
(2) getthreadscount()
(3) get_threads_count()
(4) get_time_of_work()
(5) get_version()
//====================== 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 ==========================
]]>Для какого из производных классов в файле sample.cpp наследование выполнено для наследования интерфейса?
(1) Trader
(2) Developer
(3) Boss
(4) HeadOfAll
Какие утверждения про безопасные функции и классы верны?
(1) метод класса безопасен тогда, когда список бросаемых им исключений соответствует списку исключений в спецификации метода
(2) класс безопасен тогда, когда безопасны все его методы
(3) функция безопасна тогда, когда все бросаемые внутри её исключения внутри этой функции и обрабатываются
(4) для написания безопасных классов необходимо запретить пользоваться исключениями
В чём основное отличие итератора вставки от других итераторов STL?
(1) итератор вставки поддерживает специальный метод вставки, которого нет у итератора произвольного доступа
(2) итератор произвольного доступа позволяет добавить элемент только в конец, а итератор вставки может вставить и в начало
(3) итератор вставки обеспечивает вставку данных с максимальным быстродействием
(4) разыменование оператора вставки ведёт к вставке элемента в контейнер
(5)
//====================== 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 ==========================
]]>Вызовы каких функций выполнены корректно и операции создания их параметров не содержат очевидных проблем?
(1) foo1
(2) foo2
(3) foo3
(4) foo4
(5) foo5
Какие возможности даёт использование поведенческий шаблон: команда?
(1) инкапсулировать обмен данными между клиентом и сервером в обмен объектам
(2) организацию очереди исполняемых запросов
(3) обеспечивает доступ к содержимому агрегата без раскрытия его представления
(4) организовать взаимодействие большого количества объектов между собой
//====================== ==========================
class A
{
int _i;
char* _name;
public:
A();
A(const A& a);
~A();
A& operator=(const A& a);
bool operator==(const A& a) const;
const char* getName() const;
};
class B
{
public:
B(int i, const char* name);
~B();
bool operator==(const B& 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& operator=(C c);
const char* getName() const;
int getIndex() const;
int setIndex();
private:
int _i;
char* _name;
};
class D
{
public:
D();
D(const D& d);
~D();
D& operator=(const C& d);
int _i;
char* _name;
};
//====================== ==========================
]]>Код какого из приведённых в фрагменте кода классов соответствуют сложившимся эмпирическим правилам организации исходного кода на С++ и канонической форме класса?
(1) ARef
(2) BRef
(3) CRef
(4) DRef
Какие из нижеперечисленных правил относятся к безопасному программированию?
(1) инициализировать переменные, а особенно указатели перед использованием
(2) проверять значения указателей перед разыменованием
(3) инициализировать значения указателей макроопределением NULL, а не просто нулём
(4) проверять значения, возвращаемые функциями
(5) проверять значения индексов массивов перед использованием
Каким способом можно пытаться принудить функцию к встраиванию в компиляторе GCC?
(1) достаточно объявить функцию как inline
(2) достаточно использовать атрибут (always_inline) компилятора
(3) необходимо одновременно объявить функцию как inline и использовать атрибут (always_inline) компилятора
(4) необходимо одновременно объявить функцию как inline и использовать атрибут (noinline) компилятора
//====================== start of sample.cpp ==========================
#include <iostream>
class Program;
class ProgDataGetter
{
public:
const char* prog_name(const Program& prg);
long get_version(const Program& 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& operator >> (std::iostream& io, Program& prg);
friend std::iostream& operator << (std::iostream& io, const Program& prg);
friend class VersionGetter;
friend const char* ProgDataGetter::prog_name(const Program&);
};
std::iostream& operator >> (std::iostream& io, Program& prg)
{ io >> prg.prog_name >> prg.threads_count; }
std::iostream& operator << (std::iostream& io, const Program& prg)
{ io << prg.prog_name << prg.modules[0].module_name << prg.modules[1].module_name; }
class VersionGetter
{
public:
long get_version(Program& prg)
{ return prg.version; }
};
const char* ProgDataGetter::prog_name(const Program& prg)
{ return prg.prog_name; }
long ProgDataGetter::get_version(const Program& prg)
{ return prg.version;}
//====================== end of sample.cpp ==========================
]]>Для каких функций и методов корректно организован доступ к членам класса Program файле sample.cpp?
(1) operator >> (std::iostream& io, Program& prg)
(2) operator << (std::iostream& io, const Program& prg)
(3) VersionGetter::get_version()
(4) ProgDataGetter::prog_name()
(5) ProgDataGetter::get_version()
//====================== 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 ==========================
]]>Тело конструктора какого класса будет исполнено последним перед вызовом тела конструктора Keyboard при создании класса типа Keyboard?
(1) Device
(2) ManualUserDev
(3) Input
(4) USBInput
Какие утверждения про корректное поведение при удалении объекта и освобождении ресурсов верны?
(1) деструкторам запрещено выбрасывать исключения наружу
(2) внутри деструктора запрещено использовать исключения
(3) операции, которые могут бросить исключения или завершиться неудачей рекомендуется убрать из деструктора в отдельную функцию
(4) исключения, бросаемые при удалении вложенных объектов класса необходимо пробрасывать наружу без обработки
//====================== start of sample.cpp ==========================
template <typename ForwardIterator, typename T>
void replace (
ForwardIterator first,
ForwardIterator last,
const T& x, const T& y)
{
while(first != last)
{
if (*first == x)
*first = y;
++first;
}
return first;
}
//====================== end of sample.cpp ==========================
]]>Каковы требования к итераторам, участвующим в алгоритме replace(), имплементация которого приведена выше, корректны?
(1) тип ForwardIterator должен поддерживать операцию разыменования
(2) объект типа Т должен поддерживать операцию сравнения "равно"
(3) объект типа Т должен поддерживать операцию сравнения "меньше"
(4) тип ForwardIterator должен поддерживать перезапись объекта, хранящегося в элементе контейнера, на который ссылается итератор
(5) тип ForwardIterator должен поддерживать вставку нового элемента в контейнер
Какая из библиотек Boost поддерживает анализ размерностей операндов вычислительных операций?
(1) Boost Interval Container Library
(2) Boost.Tribool
(3) Boost.Units
(4) Math Toolkit
(5) Meta State Machine
Какие возможности даёт использование поведенческий шаблон: наблюдатель?
(1) инкапсулировать обмен данными между клиентом и сервером в обмен объектам
(2) организация очереди исполняемых запросов
(3) обеспечивает доступ к содержимому агрегата без раскрытия его представления
(4) организовать взаимодействие большого количества объектов между собой
(5) построить широковещательные рассылки
В чём основные отличие «гибких» методологий, от методологий, основанных на "каскадной" модели жизненного цикла разработки ПО?
(1) гибкие методологии предусматривают итеративная модель жизненного цикла
(2) гибкие методологии предусматривают более короткие сроки разработки
(3) гибкие методологии предусматривают динамическое формирование требований
(4) гибкие методологии предусматривают непосредственное общение с заказчиком в процессе разработки ПО
(5) гибкие методологии предусматривают другой набор стадий процесса разработки ПО
Каким образом выполняется выравнивание динамически размещаемых объектов по уже известному размеру процессорного кэша первого уровня?
(1) используется атрибут aligned
(2) при выделении памяти функцией memalloc() выполняется такое выравнивание
(3) при выделении памяти функцией posix_memalign() выполняется такое выравнивание
(4) используется функция sysconf
/*---- start of main.c ----*/
#include <stdio.h>
const char* g_name = "programm";
char directory[8];
int main(int argc, char* argv[] )
{
int i = 1;
const char* right_name = "right";
for (; i
]]>В какой части памяти программы из выше приведённого файла main.c находится переменная right_name?
(1) область данных
(2) сегмент BBS
(3) куча
(4) программный стек
//====================== 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 = &my_lesson;
Lection my_lection;
long lection = my_lesson.math_lection_number;
short* phome_work = &(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 ==========================
]]>Присвоение данных класса каким переменным выполнено корректно (т.е. данные объявлены корректно и доступ к ним так же корректен) файле sample.cpp?
(1) lections
(2) phome_work
(3) proffesor
(4) gr_number
(5) my_task
(6) my_book
Какие утверждения про чисто виртуальные методы и абстрактные классы верны?
(1) у чисто виртуальный функции нет тела
(2) абстрактный класс является лучшим способом задать интерфейс объектов в С++
(3) потомок абстрактного класса обязательно должен перекрыть все виртуальные методы базового абстрактного класса
(4) прототипы функций класса наследника должны во всех случаях в точности повторять прототипы виртуальных методов базового класса
(5) описание интерфейсов с помощью абстрактных классов повышает производительность разрабатываемых программ
Почему лучше использовать исключения, унаследованные от стандартных исключений?
(1) классы исключения из стандартной библиотеки используются объектами и функциями стандартной библиотеки
(2) иерархию исключения стандартной библиотеки можно без больших усилий использовать в своих программах
(3) стандартные исключения могут быть использованы и обработаны в любой распространяемой библиотеке классов
(4) только исключения, унаследованные от классов стандартной библиотеки, могут быть безопасны
//====================== start of sample.cpp ==========================
bind2nd(greater<int>(), 100);
//====================== end of sample.cpp ==========================
]]>Какие утверждения про приведённый выше адаптер верны?
(1) это связывающий адаптер
(2) это отрицающий адаптер
(3) выполняется преобразование функционального объекта с двумя параметрами в функциональный объект с одним параметром
(4) результатом будет функциональный объект, возвращающий разницу между входным параметром типа int и значением 100
//====================== 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 ==========================
]]>Каким образом можно проверить требование CopyConstructable посредством шаблона стандартной библиотеки is_copy_constructible для типа my_string из файла sample.cpp?
(1) вызов метода проверки структуры is_copy_constructible вернёт true или false
(2) вызов метода проверки структуры is_copy_constructible бросит исключение в случае несоответствия требованиям
(3) в случае несоответствия стандарту для пользовательского типа при компиляции возникнет ошибка
(4) результат проверки можно узнать из атрибута is_copy_constructible<my_string>::value, он будет равен true или false
Какие утверждения о поведенческом шаблоне «посетитель» верны?
(1) шаблон «посетитель» эмулирует технику выбора вызываемой операции «двойную диспетчеризацию»
(2) обеспечивает организацию очереди исполняемых запросов
(3) бывает полезен, когда требуется выполнить операции, зависящие от типа элемента, в агрегате, содержащем объекты различных типов
(4) позволяет добавить новые методы обработки объектов, не трогая код самого объекта
(5) позволяет организовать взаимодействие большого количества объектов между собой без увеличения сложности системы
Какие утверждения относительно функции free() верны?
(1) функция free() обнуляет переданный по указателю фрагмент памяти, беря размер из служебной информации фрагмента
(2) функция free() помечает ранее выделенный фрагмент как свободный
(3) вызов функции free() c нулевым указателем ведёт повреждению логической карты памяти и краху программы
(4) функция free() использует полученный указатель для доступа к расположенному в начале фрагмента блоку служебной информации, размещённому ранее функцией malloc()
//====================== 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& rinp = keyboard;
Input* pinp = &:keyboard;
ManualUserDev& rmy_mdev = dynamic_cast<ManualUserDev&>(rinp);
ManualUserDev* pmy_mdev = dynamic_cast<ManualUserDev*>(pinp);
Keyboard& rmy_keyboard = dynamic_cast<Keyboard&>(rinp);
Keyboard* pmy_keyboard = dynamic_cast<Keyboard*>(pinp);
return 0;
}
//====================== end of sample.cpp ==========================
]]>При инициализации какой переменной в файле sample.cpp будет брошено исключение?
(1) rmy_mdev
(2) pmy_mdev
(3) rmy_keyboard
(4) pmy_keyboard
В чём заключается архитектурные свойства STL - взаимозаменяемость компонентов и унификация интерфейса?
(1) одни и те же функции для разных типов контейнеров будут выполняться с одной и той же производительностью
(2) различные контейнеры STL имеют похожую по смыслу сигнатуру основных методов
(3) различные контейнеры STL имеют одну и ту же сигнатуру основных методов и могут быть использованы в одних и тех же алгоритмах
(4) если созданный пользовательский шаблон контейнера поддерживает набор необходимых интерфейсов, то он может быть использован в обобщённых алгоритмах STL
Каковы преимущества использования лямбда функций?
(1) краткость кода
(2) эффективность скомпилированного кода
(3) повторное использование кода
(4) возможность работы в функции с всеми автоматическими переменными, доступными в месте объявления лямда-функции
В ходе разработки дизайна должны быть обязательно выполнены следующие шаги:
(1) определение максимально простого дизайна
(2) идентифицированы объекты
(3) определена степень детализации
(4) определён набор конфигурируемых параметров
(5) определены интерфейсы объектов
(6) определены реализации объектов
Какие из нижеприведённых идиом являются объектно-ориентированными идиомами?
(1) неявным параметром всех нестатических методов класса является this
(2) связывание инициализации класса с его созданием
(3) использование бесконечных циклов
(4) автоматическое создание и удаление объектов в динамической и автоматической памяти
(5) копирование строки оператором цикла с пустым телом (копирование в условии цикла)
Какие утверждения насчёт использования языка С верны?
(1) язык С используется широко в Open Source проектах
(2) язык С используется широко в высокопроизводительных проприетарных проектах, типа Oracle
(3) язык С используется широко в высокопроизводительных проектах компании mail.ru
(4) язык С используется широко при написании компиляторов С++
Какие утверждения относительно инициализации многомерных массивов верны?
(1) для инициализации многомерных массивов может быть использован синтаксис инициализации одномерного массива
(2) для инициализации двухмерного массива может быть использован синтаксис построчной инициализации
(3) возможна инициализация двухмерного массива по столбцам
(4) возможна неполная инициализации строк, при этом оставшиеся элементы строки инициализируются нулями
(5) если массив инициализирован построчно, но в некоторых строках не инициализирован ни одни элемент, то значения элементов таких строки неопределённо
Какими средствами поддерживается в языке С++ функциональное программирование?
(1) наследование
(2) лямбда функции
(3) шаблоны
(4) процедуры
//====================== 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, "Main", "DefaultCity"};
Library *p_lib = new Library;
Library empty_lib;
Person any_person(25, "Djon","S");
Person *pother_person = new Person;
return 0;
}
//====================== end of sample.cpp ==========================
]]>Инициализация каких объектов в файле sample.cpp выполняется корректно конструктором по умолчанию?
(1) p_lib
(2) empty_lib
(3) any_person
(4) pother_person
//====================== 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?
(1) 2
(2) 3
(3) 4
(4) 5
(5) 6
Какие основные элементы STL решают вопросы обработки данных, размещённых в стандартных контейнерах STL?
(1) контейнеры STL
(2) обобщённые алгоритмы STL
(3) итераторы STL
(4) адаптеры STL
(5) функциональные объекты
Какие из объявлений лямбда функций ниже выполнены корректно?
(1) auto lf1 = [] (int x) {return x+1;};
(2) auto lf2 = [] -> double (int x) {return x+1;};
(3) auto lf3 = [] (int x) -> double {return x+1;};
(4) auto lf4 = double [] (int x) {return x+1;};
Какие вопросы решаются при определении интерфейсов объектов системы?
(1) какими запросами будут обмениваться объекты
(2) будет использоваться композиция или агрегирование
(3) определение иерархии наследования используемых классов
(4) определение сигнатуры интерфейсов объектов
(5) определение границ системы
Какие из приведённых ниже атрибутов класса являются необходимыми при реализации идиомы «подсчёт ссылок»?
(1) счётчик ссылок
(2) физическое представление хранимого объекта
(3) ссылка на хранимый объект
(4) пул объектов памяти
Какие функции выполняют директивы препроцессора языка С?
(1) включают в текст программы другие файлы
(2) вводят в исходный код символические константы
(3) позволяют выполнять условную компиляцию
(4) возбуждают ошибки времени исполнения программы
Как и почему расположение в памяти объектов данных влияет на производительность?
(1) если данные, с которыми работают соседние инструкции кода умещаются в кэше процессора, то не требуется, затратное по процессорному времени, считывание данных из оперативной памяти
(2) по схемотехническим причинам считывание соседних ячеек памяти в строке выполняется гораздо быстрее чем соседних ячеек в столбце
(3) случайный доступ к ячейкам памяти выполняется быстрее, так как не создаёт нагрузки на строку или столбец оперативной памяти
(4) считывание ячеек памяти, расположенных в одном столбце, то есть с интервалом в длину строки оперативной памяти, выполняется наиболее быстро
//====================== 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 ==========================
]]>Доступ к каким из членов класса, описанных в файле sample.h (выше), является открытым?
(1) A::i
(2) B::jj
(3) B::_str
(4) B::str_4_all
(5) My::f
//====================== start of sample.cpp ==========================
int main()
{
Reader readers1[] = {"", ""};
std::vector readers2;
Reader reaedr3 = {(22, "Vasily", "Ivanov", 123456), (45, "Alex", "V", 993421) };
return 0;
}
//====================== end of sample.cpp ==========================
]]>Какие конструкторы должны быть определены для типа Reader, что бы инициализации массивов объектов этого типа и объявления контейнеров, приведённые в файле sample.cpp были успешными?
(1) Reader()
(2) Reader(unsigned long)
(3) Reader(const char*)
(4) Reader(unsigned long, const char*, const char*, unsigned long)
(5) можно явно не определять ни одни конструктор
//====================== 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?
(1) my_iter
(2) backup_input
(3) my_input_process<std::vector<short>>()
(4) clear_all<std::vector<short>, 25>(nullptr);
(5) clear_all<std::list<short>, 100>(nullptr);
Какой из последовательных контейнеров обеспечивает наилучшее время вставки элемента?
(1) вектор
(2) встроенный массив С++
(3) список
(4) дека
//====================== 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 ==========================
]]>Какие из приведённых в примере лямбда функций могут изменить значения переменных а и b?
(1) lf1
(2) lf2
(3) lf3
(4) lf4
(5) lf5
На что необходимо обратить внимание при проектировании системы что бы избежать её переделки через некоторое время?
(1) предпочитать наследование композиции
(2) при проектировании в первую очередь заботится о максимальной оптимизации реализации алгоритмов обработки и методов классов
(3) пытаться увидеть изменения, которые необходимо будете сделать в системе через полгода или год
(4) инкапсулировать допускающие изменения элементы дизайна и поведения
Какие утверждения про реализацию перегруженных операторах new и delete класса верны?
(1) выделяемую и хранимую свободную память лучше представлять, как массивы 4 или 8 байтовых чисел
(2) обычно хранится список или другой контейнер с указателями на свободные блоки памяти
(3) реализация оператора delete обязательно должна вызвать функцию free() для передаваемого в оператор блока памяти
(4) реализация оператора new может как использовать системные вызовы выделения памяти, так и отдавать хранимые свободные блоки памяти
Какие директивы препроцессора необходимы при организации условной компиляции программ на языке С?
(1) #define
(2) #undef
(3) #include
(4) #ifdef
(5) #error
Какие из приведённых ниже операторов присвоения для элементов массива double m[8][4] являются правильными?
(1) m[2][3] = 3;
(2) *(m[2] + 3) = 121;
(3) m[2] = 14;
(4) **m = 35;
(5) *(*(m+2) + 3) = 11;
//====================== start of sample.cpp ==========================
class User {};
class Bank {} my_bank;
class User my_user;
class Bank *pMyBank = &my_bank;
class Bank& rBank = &my_bank;
User *const &prUser = &my_user;
User& secondUser = &my_user;
//====================== end of sample.cpp ==========================
]]>Какие присвоения и объявления в файле sample.cpp валидны?
(1) secondUser
(2) prUser
(3) rBank
(4) mMyBank
(5) my_user
(6) my_bank
//====================== 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<Library< main_library;
};
//====================== end of sample.cpp ==========================
]]>Для какого из классов в фрагменте файла sample.cpp необходима реализация своего оператора копирования?
(1) Person
(2) Library
(3) Program
(4) Region
(5) нет необходимости ни для одного класса
//====================== 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?
(1) x0
(2) x1
(3) x2
(4) x3
(5) x4
Контейнеры отличаются друг от друга:
(1) временем выполнения одних и тех же операций
(2) интерфейсом основных операций
(3) действительностью итераторов после модификации контейнера - инвалидацией итераторов - когда происходит операции изменения контейнера
(4) расход памяти на хранение данных
Какие преимущества даёт использование boost?
(1) уменьшение времени компиляции проекта
(2) решены наиболее часто встречающиеся при разработке ПО проблемы
(3) компактность полного набора библиотек boost
(4) использование в проекте качественный эффективный код
(5) возможность ознакомиться с техниками обобщённого программирования
Какие из шаблонов относятся к уровню шаблонов объектно-ориентированного проектирования?
(1) сортировка пузырьком
(2) сервисно-ориентированная архитектура
(3) посетитель
(4) абстрактная фабрика
Какие утверждения насчёт реализации идиомы «Конверт/письмо» верны?
(1) создание объекта возможно только через конструктор базового класса
(2) требуется предотвращение рекурсивного вызова конструктора, путём объявления специального конструктора базового класса, не вызывающего никаких других конструкторов
(3) при необходимости возможно использование счётчика ссылок на объект - «письмо»
(4) классы наследники и базовый класс находятся в отношении агрегации
Какими аспектами характеризуются различные классы памяти?
(1) уровнем вложенности блока кода, внутри которого объявлена переменная
(2) время жизни объектов
(3) область видимости
(4) тип связывания
Какие присвоения для const int ct; const unsigned int* pt; long const* cpt; допустимы?
(1) const int const* p1 = &ct
(2) int *p3 = &ct;
(3) int const* p12 = pt;
(4) int * p13 = pt;
(5) const int const* p21 = cpt;
На что распространяется константность константного объекта класса?
(1) нельзя изменять данные в конструкторе класса
(2) нельзя вызывать деструктор класса
(3) нельзя вызывать методы, которые изменяют данные класса
(4) нельзя изменять открытые данные класса
(5) нельзя использовать константный объект как параметр в конструкторе копирования
(6) можно изменить содержимое областей памяти, на которые указывают члены константного класса, но это не рекомендуется
//====================== 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 "";}
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 ==========================
]]>Какие операторы преобразования класса Person не являются корректными с точки зрения архитектуры?
(1) Person::operator short ();
(2) Person::operator const char* ();
(3) Person::operator Region* ();
(4) Region::operator long ();
(5) Region::operator const char* ();
(6) Region::operator Person ();
Библиотека boost::type_traits позволяет:
(1) определять наличие у класса требуемых методов
(2) задавать различные специализации шаблонов в зависимости от того: это пользовательский класс или базовый тип
(3) отличать указатель на объект от типа во время компиляции
(4) выдавать ошибки компиляции при несоответствии типа функции, в которой объект этого типа используется
Какова сложность создания копии контейнера вектор?
(1) O(1)
(2) O(ln(N))
(3) O(N)
(4) O(N**2
Какие из объектов шаблонов и макросов в рассмотренных библиотеках boost предоставляют безопасный обобщённый класс хранилище единичных значений любых различных типов?
(1) BOOST_STATIC_ASSERT
(2) boost::variant
(3) boost::any
(4) boost::circular_buffer
При каких способах композиции и наследования время жизни инкапсулируемого объекта не зависит от времени жизни инкапсулирующего объекта?
(1) инкапсуляция экземпляра
(2) инкапсуляция указателя
(3) инкапсуляция ссылки
(4) наследование
Какие результаты могут быть достигнуты при статическом анализе кода?
(1) повышение читаемости кода
(2) улучшение композиции программного обеспечения
(3) нахождение ошибок переполнения буфера
(4) устранение неопределённого поведения программы
(5) подготовка предложений по рефакторингу
Какие утверждения о иерархии блоков кода верны?
(1) тело цикла является под-блоком блока цикл
(2) заголовок цикла является под-блоком блока цикл
(3) тело функции является под-блоком блока функция
(4) заголовок функции является под-блоком блока цикл
Почему в объявлении POSIX функции memmove() и memcmp() для параметров не используется ключевое слово restrict, а для memcpy используется?
(1) для функций memmove() и memcmp() нельзя гарантировать что передаваемые в функцию через указатели участки памяти не имеют пересечения
(2) для функций memmove() и memcmp() внутри функции возможна модификация всех передаваемых областей памяти
(3) не на всех платформах функции memmove() и memcmp() могут быть оптимизированы
(4) указатели в функциях memmove() и memcmp() не могут быть константными
//====================== 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->age; }
double get_balance() const
{ return (*this)->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 ==========================
]]>В каких методах обращения к членам объекта класса user типа User корректны?
(1) get_name()
(2) get_age()
(3) get_balance()
(4) get_country_code()
(5) get_city_code()
(6) get_city_name()
Как в языке С++ поддерживается идиома RAII?
(1) идиома поддерживается наличием в классе конструкторов и деструкторов
(2) поддерживается генерацией исключений при ошибках
(3) поддержка основана гарантированном вызове деструкторов автоматических переменных при выходе из зоны видимости
(4) умные указатели стандартной библиотеки поддерживают идиому RAII
(5) операторы приведения к простым типам поддерживают идиому RAII
//====================== 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 верны?
(1) обе переменных принадлежат одной и той же иерархии классов
(2) типы обеих переменных получены конкретизацией шаблона integral_constant
(3) обе переменных содержат атрибуты true_value и false_value типа bool
(4) шаблонная функция, которая возвращает типы true_type или false_type в зависимости от параметров шаблона может использоваться для конкретизации другого шаблона
По каким причинам для списка не подходят алгоритмы сортировки, реализованные как стандартные алгоритмы?
(1) итератор списка не поддерживает всех необходимых для стандартного алгоритма методов
(2) список может иметь достаточно большое время доступа к элементам в середине списка
(3) для сравнения элементов списка требуется оператор проверки эквивалентности элементов списка
(4) сигнатура метода вставки в список отличается от сигнатуры методов вставки других стандартных контейнеров
Какие операции можно выполнять с объектом boost::any?
(1) специализировать шаблон для хранения конкретных пользовательских типов
(2) создавать пустой объект
(3) пытаться преобразовать к любому типу посредством boost::any_cast
(4) получать тип хранимого значения
(5) выполнять преобразование хранимого типа в другой без извлечения из контейнера
Каковы особенности базового шаблона «интерфейсный класс»?
(1) назначение шаблона - определение абстрактного типа данных в целях повторного использования
(2) использование шаблона позволяет динамическую замену конкретных классов, реализующих заданный интерфейс
(3) интерфейсный класс должен описывать поведение объекта путём предоставления методов
(4) интерфейсный класс не должен иметь изменяемых атрибутов
На что следует обратить внимание при оптимизации программ по производительности?
(1) унификация используемых алгоритмов поиска
(2) программное кэширование результатов «тяжёлых» операций
(3) использование отложенной инициализации больших объектов
(4) использование группового режима выполнения операций
чем статические объекты памяти отличаются от автоматических объектов памяти?
(1) статические объекты всегда видны, как минимум в пределах файла, где они объявлены
(2) статические объекты неявно инициализируются нулями
(3) автоматические объекты неявно инициализируются нулями
(4) автоматические объекты видны в пределах блока кода
В чём ограничены массивы переменной длины?
(1) нельзя объявить глобальный массив переменной длины
(2) нельзя объявить массив переменной длины в прототипе функции
(3) нельзя заранее инициализировать динамический массив
(4) нельзя разместить массив переменной длины в области статической памяти
(5) нельзя использовать автоматические переменные для задания размерности массива
//====================== 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 ==========================
]]>Какие объявления и обращения к членам класса и объекта prog, типа Program в файле sample.cpp корректны?
(1) инициализация поля version
(2) инициализация поля build_num
(3) prog.country
(4) prog->name
(5) Program::date
Какие операции выполняются в конструкторе?
(1) выделение памяти под объект создаваемого класса
(2) инициализация членов класса, заданных в списке инициализации
(3) инициализация членов класса базового типа, не заданных в списке инициализации
(4) инициализация членов класса пользовательского типа, не заданных в списке инициализации
(5) выполнение тела конструктора
//====================== 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() верны?
(1) выполняется функция, которая требует наличия операции присваивания
(2) выполняется функция, реализующая частную реализацию
(3) выполняется функция, реализующая наиболее эффективное решение
(4) третьим параметром функции copy_impl() является тип false_type
(5) типы параметров first и out должны поддерживать операция разыменования
Какие данные нельзя менять в ассоциативном контейнере?
(1) в множестве и мультимножестве нельзя модифицировать хранимые объекты
(2) в отображении и мульти-отображении нельзя менять ни хранимый объект ни его ключ
(3) в отображении и мульти-отображении нельзя хранимый объект, а его ключ менять можно
(4) в отображении и мульти-отображении нельзя ключ, а хранимый объект менять можно
//====================== 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 ==========================
]]>Какие значения останутся в циклическом буфере circ в примере в файле sample.cpp?
(1) 1
(2) 2
(3) 3
(4) 4
(5) 5
Для каких порождающих шаблонов инстанциируемые классы определяются динамически?
(1) абстрактная фабрика
(2) строитель
(3) фабричный метод
(4) прототип
(5) класс с единственным экземпляром
Какие утверждения про модели качества программ верны?
(1) они моделируют функционирование программы
(2) они описывают характеристики программы с точки зрения различных заинтересованных сторон
(3) характеристики программы с точки зрения различных заинтересованных сторон описываются через наборы более детальных свойств программы
(4) в соответствии с некоторыми моделями качество программ может расти без внесения в неё изменений
(5) согласно моделям качества программ, свойства программ, описывающие качество программы, не поддаются количественной оценке
К чему приведёт объявление переменной регистровой?
(1) компилятор только такую переменную может разместить в регистре процессора
(2) адрес переменной будет размещён в регистре процессора
(3) компилятор примет к сведению пожелание и возможно разместит такую переменную в регистре процессора
(4) данный объект памяти никогда не будет за кэширован процессором
Что влияет на наличие лакун в памяти при описании структуры?
(1) архитектура процессора
(2) оптимизирующие действия компилятора
(3) порядок следования элементов структуры
(4) общий размер структуры
Какие ключевые слова языка С++ могут быть использованы, если необходимо изменить атрибут класса в константном методе класса?
(1) volatile
(2) const
(3) mutable
(4) const_cast
(5) static_cast
Чем отличается оператор присваивания от оператора присваивания с переносом?
(1) используются умные указатели на передаваемые ресурсы объекта класса
(2) в качестве входного параметра используется ссылка на право-допустимое значение
(3) передаваемый в качестве параметра объект должен быть уничтожен в коде оператора
(4) передаваемые в класс-приёмник ресурсы объекта-источника, должны быть обнулены в объекте-источнике
Какие утверждения о блоках try и catch верны?
(1) любое исключение, брошенное из блока try будет поймано в нижележащем блоке catch
(2) исключение, брошенное вне блока try функции может быть поймано только в блоках catch вызывающей функции
(3) друг за другом могут следовать несколько блоков try подряд
(4) друг за другом могут следовать несколько блоков catch подряд
(5) исключение, брошенное вне блока try функции может быть поймано только в блоках catch вызывающей функции
(6) блоки try могут быть вложенными
Какие данные на вход обычно принимают обобщённые алгоритмы?
(1) предикатную функцию
(2) функцию выделения памяти
(3) итераторы контейнера, данные которого обрабатываются
(4) итераторы контейнера, куда копируются данные
Каковы минимальные требования к объектам, указатель на которые могут быть храниться в умных указателях?
(1) наличие конструктора по умолчанию
(2) конструктор не может кидать исключения
(3) деструктор не может кидать исключения
(4) delete не должен кидать исключений
(5) деструктор должен быть виртуальным
Какой из структурных шаблонов помогает организовать единообразное хранение объектов в древовидных структурах?
(1) адаптер
(2) мост
(3) компоновщик
(4) декоратор
(5) фасад
При оценке каких показателей согласно модели SQuaRE, предполагается рассмотрение корректности обработки ошибок?
(1) надёжность
(2) эффективность
(3) безопасность
(4) удобство сопровождения
(5) размер программы
Какие операции адресной арифметики имеют смысл?
(1) сумма указателя и натурального числа
(2) разница указателя и натурального числа
(3) разница двух указателей
(4) сумма двух указателей
Каким образом порядок полей в структуре влияет на производительность памяти при работе с структурой (и массивом структур)?
(1) порядок элементов в структуре может минимизировать размер структуры, и уменьшить количество занятых структурой линий кэш-памяти процессора
(2) размещение длинных массивов в начале структуры ускоряет считывание данных из памяти
(3) обход элементов структуры в том же порядке что они обходятся процессором ускоряет доступ к этим элементам
(4) размещение наиболее востребованных элементов в начале структуры ускоряет доступ к этим элементам
//====================== 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& get_my_program();
int main()
{
const Program& 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& prg2 = const_cast<Program& >(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 ==========================
]]>При присвоении значений каким переменным в файле sample.cpp корректно используются корректно определённые методы?
(1) prg_name1
(2) my_thr_count1
(3) result1
(4) my_thr_count2
(5) result2
(6) result3
Какие утверждения насчёт полиморфизма верны?
(1) полиморфизм это отношения между базовым и производным классом, имеющими общий открытый интерфейс
(2) полиморфизм это отношения, позволяющие компилятору возможность работы с производным классом по ссылке на базовый класс
(3) полиморфизм позволяет использовать объект базового класса как объект производного класса
(4) ссылка на объект одного производного класса может быть использована для адресации объекта другого производного класса, унаследованного от того же базового класса
(5) полиморфизм реализуется через отложенное разрешение вызова методов класса
//====================== 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?
(1) 1
(2) 2
(3) 4
(4) 6
//====================== start of sample.h ==========================
#include <algorithm>
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(&B[0], &B[N/2], 0, 42);
std::replace(C, (C+N+1), 'D', 'T');
std::copy(&A[0], &A[N-1], &D[0]);
std::copy(A, (A+N), D);
return 0;
}
//====================== end of sample.h ==========================
]]>В каких из вызовов обобщённых алгоритмов встроенные массивы С++ использованы без ошибок?
(1) std::replace(&B[0], &B[N/2], 0, 42);
(2) std::replace(C, (C+N+1), 'D', 'T');
(3) std::copy(&A[0], &A[N-1], &D[0]);
(4) std::copy(A, (A+N), D);
Каковы особенности умного указателя boost::weak_ptr?
(1) поддерживает автоматическое удаление объекта
(2) решает проблему создания циклических ссылок
(3) поддерживает ограниченное множество операций
(4) требует имплементации пользователем функций подсчёта ссылок на пользовательский объект
Какой из структурных шаблонов обеспечивает контроль доступа к объекту путём реализации proxy-объекта?
(1) адаптер
(2) фасад
(3) компоновщик
(4) декоратор
(5) заместитель
Какие факторы способствуют накоплению технического долга?
(1) агрессивные сроки разработки продукта
(2) недостаточное использование моделей качества
(3) нехватка опыта в используемых технологиях у разработчиков
(4) недостаток времени на проектирование архитектуры продукта
(5) недостаточная производительность оборудования, на котором работает программа
(6) большая длительность проекта
Какими способами можно передать массив в функцию?
(1) указатель на первый элемент массива и количество элементов в массиве
(2) первый элемент массива по значению и количество элементов в массиве
(3) первый элемент массива и последний элементы массива по значению
(4) указатели на первый элемент массива и элемент массива, следующий за последним
Какие утверждения о функции __builtin_expect() верны?
(1) это функция POSIX
(2) функция решает на основании собранной статистики, какое ветвление кода необходимо загружать в кэш-память команд
(3) это функция информирует компилятор, какое условие будет выполнено с наибольшей вероятностью
(4) используется когда проблематично реорганизовывать код оптимальным образом из-за ухудшения читаемости и сопровждаемости
(5) функция ухудшает читаемость и сопровождаемость кода
//====================== start of sample.cpp ==========================
class Program
{
char* prog_name;
public:
long threads_count;
double time_of_work;
long version;
};
const Program& get_my_program();
int main()
{
Program& prg = const_cast(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 = &Program::version;
long my_version = (&prg)->*pversion;
char* Program::*pmy_name = &Program::prog_name;
char* my_name = prg.*pmy_name;
return 0;
}
//====================== end of sample.cpp ==========================
]]>Какие присвоения значений членов класса переменным будут успешны в файле sample.cpp?
(1) my_threads_1
(2) my_threads_2
(3) my_version
(4) my_name
Методы и атрибуты базового класса с каким модификатором доступа доступны классам потомкам?
(1) public
(2) private
(3) protected
(4) по умолчанию (без указания модификатора доступа)
//====================== 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 выполнена корректно?
(1) state()
(2) read()
(3) write()
(4) open()
(5) close()
Какие утверждения о назначении потоковых итераторов верны?
(1) входной потоковый итератор предназначен для чтения объектов из входного потока
(2) выходной потоковый итератор предназначен для записи объектов в выходной поток
(3) выходной итератор, имеющий специальное значение служит маркером конца потока
(4) входной итератор, имеющий специальное значение служит маркером конца потока
//====================== 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 ==========================
]]>Вызовы каких функций выполнены корректно и операции создания их параметров не содержат очевидных проблем?
(1) foo1
(2) foo2
(3) foo3
(4) foo4
(5) foo5
Какие возможности даёт использование поведенческий шаблон: итератор?
(1) инкапсулировать обмен данными между клиентом и сервером в обмен объектам
(2) организацию очереди исполняемых запросов
(3) обеспечивает доступ к содержимому агрегата без раскрытия его представления
(4) организовать взаимодействие большого количества объектов между собой
//====================== start of sample.hpp ==========================
class ARef
{
public:
/* Сonstructory */
ARef(A& a, int i) : _a(a), _ix(i) {}
/* operator= */
ARef& operator= (T t) { return *this;}
private:
A& _a; // Reference to A object
int _ix; // index in container
};
class BRef
{
public:
BRef(B &b, int i) : _b(b), _ix(i) {}
BRef& operator= (T t) { return *this;}
private:
B& _b;
int _ix;
};
/*
* Class CRef имплементирует шаблон проектирования X
* хранит в себе ссылку на коллекцию типа A, которая является коллекцией
* объектов типа T и предоставляет к ним доступ
*/
class CRef
{
public:
CRef(C &c, int i) : _c(c), _ix(i) {}
CRef& operator= (T t) { return *this;}
private:
C& _c; /* та коллекция объектов, доступ к которой и предоставляется*/
int _ix; /* индекс текущего объекта в контейнере */
};
/*
* Class DRef
*/
class DRef
{
public:
// конструктор инициализирует объект
DRef(D &d, int i) : m_d(d), _ix(i) {}
// оператор возвращает ссылку на себя
DRef& operator= (T t) { return *this;}
private:
D& m_d; // хранимый объект
int _ix; // индекс
};
//====================== end of sample.hpp ==========================
]]>Комментарии какого из классов в файле sample.hpp являются необходимыми и достаточными?
(1) ARef
(2) BRef
(3) CRef
(4) DRef
Результаты каких функций POSIX необходимо проверять?
(1) scanf() - количество байт, которые удалось разобрать
(2) printf() - количество байт, которые удалось поместить в выходной поток
(3) free() – высвобожденное количество байт
(4) malloc() - указатель на выделенную память
Какую информацию можно получить с помощью утилиты pfunct?
(1) получить информацию о потерях быстродействия при доступе к памяти
(2) сколько функций из запрошенных на встраивание не удалось встроить
(3) размер функций
(4) сколько линий кэш-памяти первого уровня займёт каждая функция
(5) количество безусловных переходов на метку
Что необходимо сделать для реализации потокового ввода-вывода для своего класса?
(1) получить доступ к коду стандартной библиотеки ввода-вывода и внести туда соответствующие изменения
(2) перегрузить глобальные функции операций >> и << для своего класса
(3) реализовать move конструктор для своего класса
(4) объявить перегруженные функции операций >> и << как friends для своего класса, если в классе есть закрытые данные, которые необходимо выводить в поток
(5) для обеспечения файлового ввода-вывода необходимо дополнительно перегрузить операции >> и << для типов потока ifstream и ofstream
//====================== 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 ==========================
]]>В каком порядке вызываются деструкторы при удалении объекта Keyboard из файла sample.cpp?
(1) самым первым вызывается деструктор Key
(2) деструктор ManualUserDev вызывается после деструктора USBDev
(3) деструктор USBDev вызывается раньше, чем деструктор Input
(4) деструктор USBInput вызывается раньше, чем деструктор Key
Нейтральный код (функция или метод класса) должны:
(1) при попадании в блок catch исключения, брошенного вложенным объектом, повторно бросать это исключение
(2) не допускать что бы наружу бросались любые исключения
(3) пробрасывать наружу исключения, брошенные из вложенных объектов
(4) обрабатывать исключения, бросаемые кодом самой функции или метода
(5) обрабатывать исключения, бросаемые вложенными объектами
//====================== start of sample.cpp ==========================
template <typename T>
class multiplies: public binary_function<T,T,T>
{
public:
T operator() (const T& x, const T& y) const {
return x * y;
}
};
//====================== end of sample.cpp ==========================
]]>Какие утверждения про приведённый выше код функтора multiplies верны?
(1) содержащегося кода "operator()" недостаточно, должны быть реализованы ещё некоторые операторы
(2) наследование от шаблона binary_function позволяет получить типы для "саморефлексии"
(3) код операции умножения может быть заменён на любые другие арифметические или логические операции
(4) приведённый функтор может быть использован для передачи выполняемой операции в функции алгоритмов
Какая из библиотек Boost поддерживает работу со статистическими распределениями, бесконечными рядами и специальными математическими функциями?
(1) Geometry
(2) Ratio
(3) Boost.Units
(4) Math Toolkit
(5) Meta State Machine
Какие преимущества обеспечивает модель проталкивания данных от субъекта наблюдателю перед моделью вытягивания данных при реализации шаблона наблюдатель?
(1) высокая степень повторного использования
(2) минимальный объём посылаемой наблюдателю информации
(3) высокая эффективность модели
(4) малая степень информированности субъекта о наблюдателе
В чём основные отличия процессов, основанных на "каскадной" модели жизненного цикла разработки ПО от итеративного процесса разработки?
(1) итеративный процесс разработки предусматривает другой набор стадий процесса разработки ПО
(2) итеративный процесс разработки предусматривает многократное повторение всех этапов жизненного цикла производства ПО
(3) итеративный процесс разработки предусматривает непосредственное общение с заказчиком в процессе разработки ПО
(4) итеративный процесс разработки предусматривает одновременные работы, относящиеся к разным стадиям разработки ПО
Какие утверждения о размере процессорного кэша первого уровня верны?
(1) он может быть получен вызовом системной функции sysconf()
(2) выравнивание статически и динамически размещаемых объектов по его размеру повышает быстродействие
(3) функция malloc() учитывает его размер при выделении памяти
(4) выравнивание динамически размещаемых объектов по его размеру уменьшает фрагментацию памяти
/*---- start of main.c ----*/
#include <stdio.h>
const char* g_name = "programm";
char directory[8];
int main(int argc, char* argv[] )
{
int i = 1;
const char* right_name = "right";
for (; i<argc; ++i)
{
if (0 == strcmp(argv[i], right_name))
return 0;
}
return 1;
}
/*---- end of main.c ----*/
]]>В какой части памяти программы из вышеприведённого файла main.c находится переменная argc?
(1) область данных
(2) сегмент BBS
(3) куча
(4) программный стек
//====================== 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 = &(my_semaphor.yellow);
bool power_on = my_semaphor.power_on;
int new_version = my_semaphor.is_new_version;
return 0;
}
//====================== end of sample.cpp ==========================
]]>Какие присвоения битовых полей корректны (и соответственно описания этих полей) файле sample.cpp?
(1) is_red
(2) pyellow
(3) power_on
(4) new_version
//====================== 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 ==========================
]]>Для которых из классов в файле sample.cpp в конструкторе может потребоваться явно вызвать конструкторы базовых классов?
(1) Keyboard
(2) ManualUserDev
(3) USBDevice
(4) USBInput
(5) ни для каких
Какой главный вопрос относительно исключений стандартной библиотеки необходимо решить при разработке своего программного продукта?
(1) как будут использоваться атрибуты классов-исключений стандартной библиотеки
(2) какие исключения стандартной библиотеки будут использоваться
(3) какие исключения в каких случаях будут использоваться
(4) будет ли корневой класс иерархии исключений иметь отношение к исключениям стандартной библиотеки (унаследован или использован без наследования)
Чем отличаются неупорядоченные ассоциативные контейнеры, добавленные в стандарте С++ 11 от уже имеющихся ассоциативных контейнеров?
(1) амортизированное константное время выполнения основных операций
(2) неупорядоченный ассоциативный контейнер может быть инициализирован встроенным массивом без копирования элементов массива и выделения памяти
(3) как параметр шаблона требуются функтор для проверки равенства ключей
(4) как параметр шаблона требуются функтор для вычисления хеш-функции
(5) перемещение по неупорядоченному ассоциативному контейнеру возможно только в одном направлении
Какие типы и методы должен поддерживать контейнер, соответствующий требованию Container?
(1) forward итераторы
(2) итераторы произвольного доступа
(3) конструкторы по умолчанию и копирования
(4) конструктор переноса
(5) операции сравнения
Какие проблемы архитектуры позволяет решить следование закону Деметра?
(1) достижение максимальной скорости выполнения при ограничениях используемых ресурсов
(2) достижение высокой устойчивости и надёжности системы
(3) достижение наименьшей связности объектов и стабильности кода при изменениях объектов
(4) достижение максимальной простоты архитектуры системы
Что описывает стандарт POSIX?
(1) работу с threads
(2) взаимодействие POSIX совместимой OS с устройствами ввода-вывода
(3) работу с сигналами
(4) информацию о всех POSIX совместимых функциях
(5) правила работы POSIX совместимой OS с стеком протоколов TCP/IP
Какие утверждения о структуре type_info верны?
(1) объекты типа type_info можно присваивать друг другу и сравнивать друг с другом
(2) возвращается операцией typeid
(3) реализация структуры type_info стандартизована
(4) содержит идентификатор класса
Какие утверждения про различные виды обобщённых алгоритмов верны?
(1) различные обобщённые алгоритмы сортировки STL отличаются друг от друга максимальной и средней сложностью
(2) различные обобщённые алгоритмы сортировки STL могут отличаются друг от друга потребляемой для выполнения сортировки памятью
(3) реализуемые обобщёнными алгоритмами операции над множествами выполняются над объектами, находящимися в любых контейнерах STL
(4) обобщённые алгоритмы на числах могут работать только с контейнерами, хранящими встроенные числовые типы
При оценке каких показателей согласно модели SQuaRE, предполагается анализ связности и переносимости кода?
(1) надёжность
(2) эффективность
(3) безопасность
(4) удобство сопровождения
(5) размер программы
Какие утверждения о типе ptrdiff_t верны?
(1) это переносимый тип, может быть разного размера на разных платформах
(2) предназначен для оптимизации производительности программ на языке С
(3) это результат операции вычитания указателей
(4) это без знаковый тип
Какие утверждения насчёт позднего связывания верны?
(1) реализуется через механизм виртуальных методов класса
(2) является особенностью объектного подхода
(3) заключается в том, что решение о том метод какого класса будет вызван принимается в момент компиляции программы
(4) позднее связывание является путём реализации полиморфизма
Каким классам итераторов доступны операции записи объекта?
(1) итераторы входные
(2) итераторы выходные
(3) итераторы однонаправленные
(4) итераторы двунаправленные
(5) произвольного доступa
Каковы особенности умного указателя boost::intrusive_ptr?
(1) поддерживает автоматическое удаление объекта
(2) решает проблему создания циклических ссылок
(3) требует имплементации пользователем функций подсчёта ссылок на пользовательский объект
(4) предназначен для работы с объектами, имеющими встроенный механизм подсчёта ссылок
Какие проблемы подразумеваются под понятием технический долг?
(1) использование неподходящей технологии
(2) отсутствие поддержки продуктом некоторых операционных систем
(3) недостаток регрессионных тестов
(4) не соответствующий изменившейся предметной области дизайн кода
(5) не реализованная, но необходимая пользователям, функциональность продукта
(6) реализованная функциональность продукта, которая не будет использоваться
//====================== 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& get_my_program();
typedef double (Program::*my_getter)();
int main()
{
long Program::*pversion = &Program::version;
char* Program::*pmy_name = &Program::prog_name;
long (Program::*f_threads_count)() = &Program::get_threads_count;
Program& prg = const_cast<Program&>(get_my_program());
long my_version = (prg)->*pversion;
char* my_name = prg.*pmy_name;
long my_threads_count = (prg.f_threads_count)();
my_getter getter = &Program::get_time_of_work;
double my_time_of_work = (prg.*getter)();
return 0;
}
//====================== end of sample.cpp ==========================
]]>Какие присвоения значений членов класса переменным будут успешны в файле sample.cpp?
(1) my_version
(2) my_name
(3) my_threads_count
(4) my_time_of_work
//====================== 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 ==========================
]]>Какие атрибуты и методы базового класса SimpleComputer в файле sample.cpp остались не перекрыты в унаследованном классе LaptopComputer?
(1) m_memory
(2) m_processor
(3) m_input
(4) GetPerformance()
(5) Start()
Какие из объектов шаблонов и макросов в рассмотренных библиотеках boost предоставляют STL совместимый контейнер с перезаписью элементов при заполнении?
(1) BOOST_STATIC_ASSERT
(2) boost::variant
(3) boost::any
(4) boost::circular_buffer
Каковы особенности агрегирования по сравнению с осведомлённостью?
(1) сильная связанность
(2) время жизни агрегируемого объекта зависит от времени жизни агрегирующего объекта
(3) инкапсуляция выполняется только по ссылке или указателю
(4) применяется реже чем осведомлённость
Какие утверждения о области видимости верны?
(1) существуют следующие области видимости в языке С: прототип функции, файл, блок
(2) блоки видимости образуют иерархическую структуру
(3) блоки в языке С всегда имеют имя
(4) блоки образуются парой фигурных скобок
Какие утверждения относительно идиомы RAII верны?
(1) идиома RAII охватывает стадию выделения ресурсов и стадию освобождения ресурсов
(2) это идиома относится только к языкам Java и С++
(3) суть идиомы в выделении ресурсов при создании объектов и освобождении ресурсов при уничтожении объектов
(4) идиома RAII описывает отложенную инициализацию объектов для повышения быстродействия программы
(5) идиома не привязана к конструкторам и деструкторам
Какие утверждения о контейнере boost::circular_buffer верны?
(1) может быть использован для организации программного кэша
(2) является STL совместимым контейнером
(3) обеспечивает логарифмическое время вставки в конец
(4) позволяет выделять память для контейнера только один раз
(5) гарантирует непрерывность используемого участка памяти
На что следует обратить внимание при оптимизации программ по размеру объектного кода и памяти данных?
(1) унификация используемых алгоритмов поиска
(2) программное кэширование результатов «тяжёлых» операций
(3) наличие необязательных уровней косвенности
(4) эффективная работа с кэш-памятью процессора
Какими выражениями из нижеперечисленных может быть инициализирована статическая переменная типа int?
(1) sizeof(double)
(2) (25 * 3 * 1000)
(3) strlen("qwert")
(4) strcmp("222","333")
(5) sizeof(char*)
//====================== start of sample.cpp ==========================
#include <vector>
class ServiceOrganization;
class Building
{
static char* m_city;
const unsigned int m_high_size;
std::vector<int> m_flats;
unsigned int m_square;
ServiceOrganization& m_organization;
public:
Building();
};
int main()
{
Building house;
return 0;
}
//====================== end of sample.cpp ==========================
]]>Какие члены класса Building из файла sample.cpp обязательно должны быть инициализированы в списке инициализации?
(1) m_city
(2) m_high_size
(3) m_flats
(4) m_square
(5) m_organization
Какие вопросы решаются при определении реализации объектов системы?
(1) какими запросами будут обмениваться объекты
(2) будет использоваться композиция или агрегирование
(3) определение иерархии наследования используемых классов
(4) определение границ системы
Какие из приведённых ниже действий являются необходимыми при реализации идиомы «подсчёт ссылок»?
(1) увеличение значения счётчика ссылок при копировании объекта и уменьшение при удалении объекта
(2) присвоение счётчику ссылок начального значения при создании хранимого объекта
(3) создание пула памяти
(4) реализация оператора приведения к типу хранимого объекта
Какая группа шаблонов отвечает за организацию сочленения объектов и классов?
(1) порождающие шаблоны
(2) базовые шаблоны
(3) структурные шаблоны
(4) поведенческие шаблоны
Какие недостатоки шаблона «абстрактная фабрика»?
(1) добавление нового типа создаваемых объектов ведёт к переделке всех реализаций фабрики
(2) необходимость вызова 2-х и более методов для создания объекта
(3) невозможно избежать возникновения иерархии создающих объектов, параллельной иерархии создаваемых объектов
(4) ограничивает масштабируемость системы
К каким последствиям приведёт использование ключевого слова extern при описании переменной, находящейся внутри тела функции?
(1) такая переменная обязательно должна быть инициализирована в это строке
(2) будет использоваться глобальная переменная с таким именем, определённая в другом месте этого файла или в другом файле
(3) компилятор разместит такую переменную в регистре процессора
(4) эта строка обходится компилятором, потому что память под эту переменную уже выделена
В каких из приведённых ниже выражений нельзя обойтись без указателя this?
(1) return this->name;
(2) return (*this);
(3) if((*this).name == obj_name){}
(4) if(this == obj){}
Какие методы входят в минимально-необходимый состав, который должен быть имплементирован при использовании поведенческого шаблона итератор?
(1) переход в начало
(2) переход в конец
(3) переход на следующий элемент
(4) проверка конца агрегата (контейнера)
(5) получение дистанции между 2-мя элементами
(6) получение доступа к текущему элементу
Какие особенности кода класса являются признаком необходимости использования поведенческих шаблонов: состояние, стратегия?
(1) появления большого класса с большим количеством методов
(2) однотипные ветвления кода с похожими условиями
(3) вырожденный конструктор
(4) большое количество взаимодействий с другими объектами
Какие утверждения насчёт конструкторов и деструкторов верны?
(1) класс может иметь один или более конструкторов
(2) класс может иметь один или более деструкторов
(3) конструктор часто имеет лист инициализации и пустое тело метода
(4) простые классы могут не иметь ни одного конструктора или ни одного деструктора
(5) конструктор копирования иногда можно явно не определять
Какие из приведённых принципов относятся к S.O.L.I.D.?
(1) любой класс должен иметь одну и только одну зону ответственности
(2) программные элементы должны быть открыты для расширения, но закрыты для изменения
(3) множество мелких интерфейсов лучше, чем единственный общий
(4) любой метод класса имеет право вызывать только свои методы, методы входных параметров и методы своих объектов-атрибутов и объектов-атрибутов входных параметров
Какие утверждения про производительность работы объектно-ориентированных программ на С++ верны?
(1) отмена механизма виртуализации бывает необходима по соображениям повышения эффективности
(2) вызов виртуальной функции значительно дороже чем вызов функции по указателю
(3) глубина иерархии наследования не сказывается на производительность создания объектов при использовании встроенных конструкторов
(4) глубина иерархии наследования не увеличивает затраты времени на доступ к унаследованным членам классов
(5) глубина иерархии наследования ограничивает доступ к унаследованным членам классов
Какие преимущества даёт инкапсуляция?
(1) не требуется понимать, как реализовано поведение пользовательского типа, что бы использовать его
(2) изменение интерфейса класса не ведёт к необходимости изменения реализации
(3) изменение реализации класса не требует изменения кода пользовательской стороны
(4) разные пользовательские типы могут иметь одно и то же поведение для методов с совпадающим названием
//====================== start of sample.cpp ==========================
class MyAClass
{
public:
const MyAClass& getMe() const
{
return *this;
}
};
MyAClass *myAFactory1 = new MyAClass();
MyAClass myAFactory2;
MyAClass *myA1 = myAFactory1->getMe();
MyAClass myA2 = myAFactory1->getMe();
MyAClass const &myA3 = myAFactory1->getMe();
MyAClass &myA4 = myAFactory1->getMe();
MyAClass const &myA5 = myAFactory2.getMe().getMe();
//====================== end of sample.cpp ==========================
]]>Какие присвоения и объявления в файле sample.cpp валидны?
(1) myAFactory1
(2) myAFactory2
(3) myA1
(4) myA2
(5) myA3
(6) myA4
(7) myA5