Какие выражения не содержат синтаксических ошибок

(1) латинские буквы

(2) русские буквы

(3) цифры от 0 до 9

(1) результат операции сложения целых чисел — целый

(2) результат любых операций над целыми числами — целый

(3) результат операций сравнения целых чисел — целый

(4) результат стандартных тригонометрических функций с аргументами целого типа — действительный

(1) структура программы задается на этапе составления алгоритма

(2) программа составляется только из базовых конструкций: следования, ветвления и цикла, которые могут вкладываться друг в друга

(3) в программе могут использоваться только определенные структуры данных

(4) программа состоит из подпрограмм, организованных в определенную структуру

(1) глобальные переменные можно использовать в функциях

(2) глобальные переменные располагаются в сегменте данных

(3) компилятор инициализирует нулями глобальные и локальные переменные

(4) функция может возвращать значение любого типа

(1) множественное наследование и полиморфизм.

(2) абстрактные типы данных и сохранение состояний.

(3) перегрузка операций и обработка исключений.

(4) инкапсуляция, наследование, полиморфизм.

(1) объект в C++ может иметь сколько угодно предков

(2) объект в C++ может иметь сколько угодно потомков

(3) объект в C++ может иметь только одного предка

(4) объект в C++ может иметь только одного потомка

(1) русские буквы

(2) символы +, -, *, /

(3) cимволы @, $ и пробел

(4) символы :, ;

(1) результат операции сложения действительного и целого числа — действительный

(2) в выражении можно использовать операнды булевского типа

(3) результат стандартных функций sin и cos с аргументом целого типа — целый

(4) результат операций сравнения действительных чисел — целый

(1) выражение булевского типа

(2) переменная целого типа

(3) константа false

(1) для локальных переменных выделяется место в стеке

(2) компилятор инициализирует нулями локальные переменные

(3) для параметров, передаваемых по адресу, в стек заносится только их адрес

(4) функция может возвращать через список параметров более одного значения

(1) возможность называть одним и тем же именем разные подпрограммы

(2) объединение в одном классе данных и методов их обработки

(3) создание иерархии объектов

(4) сокрытие деталей реализации

Какое из следующих утверждений является НЕПРАВИЛЬНЫМ?

class Base{};
class Derived: public Base{};

(1) Base является суперклассом для Derived.

(2) Derived является потомком Base.

(3) Derived является дочерним классом Base.

(4) Base является потомком Derived.

(1) украинские и греческие буквы

(2) символы 0, 1, 2, 3, 4

(3) числа

(4) символы {, }, (, )

(1) []

(2) ,

(3) ->

(4) =

(5) ^

(1) любой оператор, кроме оператора перехода

(2) любой простой или составной оператор

(3) не больше двух операторов

(4) составной оператор

(1) только переменной типа int с именем а

(2) выражением целого типа

(3) переменной целого типа

(4) выражением любого типа

(1) инкапсуляция

(2) наследование

(3) полиморфизм

(4) абстрагирование

Какой уровень доступа к функции «setx» в классе «derived» в приведенном примере?

class basex
{
int x;
public:
void setx(int y) {x = y;}
};
class derived : basex {};

(1) protected

(2) global

(3) public

(4) local

(5) private

(1) выражения

(2) строковые константы

(3) операторы

(4) идентификаторы

(1) *

(2) /

(3) ?:

(4) %

(5) ^

(1) f(a,a,b);

(2) f(a,x,'b');

(3) f(a,d-x/2,b);

(4) f(2,d,b);

(1) данные и информацию о них

(2) данные и методы

(3) массивы данных

(4) массивы методов

(1) вы можете создавать указатели на абстрактный класс.

(2) вы можете создавать объекты абстрактного класса.

(3) абстрактный класс имеет как минимум одну чисто виртуальную функцию.

(4) абстрактный класс может иметь потомков.

(1) двоичные числа

(2) строковые константы

(3) ключевые слова

(4) знаки операций

(1) f(a,b,c);

(2) f(a,x,c);

(3) f(x,c,28);

(4) f(a,28,x);

(1) с директивой private

(2) с директивой public

(3) без директив

(4) с директивой local

(5) с директивой global

(1) f("Test", 2.0);

(2) f<int>("Test", 2.0);

(3) f<int, char*, double>("Test", 2.0);

(4) f<int, char*>("Test", 2.0);

(1) ключевые слова

(2) константы

(3) операторы присваивания

(1) P(1,k+1,m);

(2) P(a,k,'c');

(3) P(a,d,c);

(4) P(a,a,d[2]);

(1) до другой директивы

(2) до директивы public

(3) до конца файла

(4) до начала описания следующего поля

(1) 259

(2) 00

(3) ‘ф’

(4) 1.2_e1

(5) 0x010E

Что будет выведено на экран в результате работы программы?

#include <stdio.h>
int a, b, c, d;
void f( int a, int& c, int& d)
{
int b;
a = 5; c = 7; b = 9;
}
int main()
{
a = 1; c = 1; b = 1;
f(b,a,c);
printf («%d|%d|%d»,a,c,b);
return 0;
}

(1) 1|1|1

(2) 7|1|1

(3) 7|7|1

(1) уменьшить количество возможных ошибок

(2) сократить текст программы

(3) упростить отладку программы

(4) уменьшить объем программы в оперативной памяти

(1) *

(2) 0755

(3) -126

(4) 0XFFG0

(5) ‘x07’

(1) -0.18*a/r-0.2*t

(2) (-0.18)*a)/(r-0.2*t)

(3) cos/^2*x+0,2

(4) (-0.18)*a)(r-0.2*t))

(1) int f(int& i);

(2) int f1(int i);

(3) int 1f(int& i);

(4) *int f(int i);

В каком месте приведенного ниже класса следует инициализировать переменную I?

class Foo {
const int I;
static void Init(int x);
void Setup(int x = 0) const;
public:
Foo(int x = 0);
};

(1) в списке инициализации конструктора.

(2) внутри константного метода Setup.

(3) в теле конструктора.

(4) внутри статического метода Init.

(5) внутри функции ‘main’.

(1) 00

(2) 0xEFG1

(3) -7.12e-13

(4) ‘Ж’

(5) 0001

(1) sin(abs(0.6(e*3))

(2) 0XCC00*.34E-4/_do/k-2

(3) ((cos(3*a+1.*abs(x))))

(4) a*exp(t)(2t)

(1) float f_2(long a[]);

(2) int f(long* array, const int n);

(3) float f(int& i);

(4) long f(i, long& j);

(1) константный метод объявляется с ключевым словом const после списка параметров.

(2) константный метод может изменять значения полей класса.

(3) константный метод может вызывать любые методы класса.

(4) константный метод может вызываться только для константных объектов.

(5) константный метод может изменять значения константных полей класса.

(1) #0.7

(2) ‘Ю’

(3) «aa»

(4) 7.2.e+3

(5) -1e-1

(1) (a == 2) || true

(2) (a == 1) && true

(3) (a == 2) && true

(4) (a == 1) && false

Что будет выведено на экран в результате работы программы?

#include <stdio.h>
void f(char& a, char d)
{
a = d; d = a;

}
int main()
{
char a[] = «глаз»;
f(a[0],a[3]);
puts(a);
return 0;
}

(1) злаа

(2) злаг

(3) злаз

(1) константный метод объявляется с ключевым словом const перед именем метода.

(2) константный метод может вызываться для любых (не только константных) объектов.

(3) константный метод объявляется с ключевым словом const после списка параметров.

(4) константный метод может вызывать любые методы класса.

(5) в константный метод не передается указатель this.

(1) unsigned char

(2) unsigned short int

(3) signed short int

(4) signed long int

(5) double

(1) целого типа — вещественной переменной

(2) вещественного типа — целой переменной

(3) символьного типа — целой переменной

(4) целого типа — булевской переменной

Что будет выведено на экран в результате работы программы?

#include <stdio.h>
void f(char* a, char* const b)
{
a[0] = b[0]; b[1] = a[1];
}
int main()
{
char a[]=»abcd»;
char b[]= «opr»;
f(a,b);
printf («%s%s», a, b);
return 0;
}

(1) obcdorb

(2) oobdcr

(3) obcdobr

(1) операция ->

(2) операция .

(3) операция ,

(4) операция ::

(5) операция .*

(1) 13

(2) 213

(3) -13

(4) -213

(5) 1213

(1) целой переменной — целое выражение

(2) целой переменной — вещественное выражение

(3) целой константе — булевскую константу

(4) целой переменной — булевскую константу

(1) структура может включать в себя только простейшие типы данных (int, char и т.д.).

(2) структура не может иметь конструкторов и деструкторов.

(3) структура не может быть наследником класса.

(4) класс не может быть наследником структуры.

(5) поля структуры открыты по умолчанию.

(1) 13

(2) 213

(3) -13

(4) -213

(5) 32000

(1) имена переменных любого типа

(2) имена переменных символьного типа

(3) имена переменных целого типа

(4) константы строкового типа

(1) поля класса могут быть описаны с модификатором static

(2) поля класса могут быть описаны с модификатором const

(3) поля класса могут иметь тип самого класса

(4) поля класса не могут быть указателями на сам класс

(1) по крайней мере одного пробела

(2) пробела или запятой

(3) нажатия клавиш TAB или ENTER

(4) клавиш курсора

(1) внутри локального класса можно использовать стандартные типы

(2) внутри локального класса нельзя использовать статические (static) переменные

(3) внутри локального класса нельзя использовать внешние (extern) переменные

(4) внутри локального класса нельзя использовать внешние функции

(5) локальный класс не может иметь статических элементов

Что будет выведено на экран в результате работы программы (учитывая формат вывода)?

#include
main()
{
int i;
float t;
i = 2; t= 2;
printf(«%4.1f%2d%d», t, i, i);
}

(1) 222

(2) 2.0 22

(3) 2.00 2.0 2

(1) внутри локального класса нельзя использовать стандартные типы

(2) внутри локального класса можно использовать статические (static) переменные

(3) внутри локального класса можно использовать внешние (extern) переменные

(4) внутри локального класса нельзя использовать структурные типы

(5) внутри локального класса можно использовать автоматические переменные из области, в которой он описан

(1) printf ("*%4f %d %4.2f*", x, k, y);

(2) printf ("*%4f %4d %4.2f*", x, k, y);

(3) printf ("*%f %d %4f*", x, k, y);

(1) конструкторы глобальных объектов вызываются до вызова функции main.

(2) локальные объекты создаются, как только становится активной область их действия.

(3) возможно получение указателя на конструктор.

(4) конструктор запускается при создании временного объекта.

(1) имена переменных

(2) ключевые слова

(3) константы символьного типа

(4) операторы

Что будет выведено на экран в результате работы программы?

#include <stdio.h>
main()
{
const char a[] = «abcra»;
int i; char k;
k = ‘c’;
for (i = 1; i < 5; i++) {
if (a[i] < k) k = a[i];
printf(«%c»,k);
}
}

(1) bbab

(2) bbaa

(3) bbba

(1) конструктор не возвращает значение.

(2) конструктор возвращает значение типа void.

(3) конструкторы наследуются.

(4) в конструкторах нельзя задавать значения параметров по умолчанию.

(1) char* const pc

(2) char* pc

(3) const char* const pc

(4) невозможно определить указатель-константу.

(5) const char* pc

(1) конструктор по умолчанию.

(2) конструктор копирования.

(3) конструктор с параметром-объектом.

(4) в этом случае никакой конструктор не вызывается.

(1) int *x = 0x200;

(2) int *x( &0x200 );

(3) int *x = *0x200;

(4) int *x = &0x200;

(5) int *x; *x = 0x200;

(1) дружественная функция объявляется внутри класса, к элементам которого ей нужен доступ, с ключевым словом friend.

(2) в качестве параметра дружественной функции должен передаваться объект класса.

(3) одна функция может быть дружественной сразу нескольким классами.

(4) на дружественную функцию распространяется действие спецификаторов доступа.

Какое значение получит «p[0]» в данном примере?

int a[2][3]={{1,2,3},{7,8,9}};
int *p=&a[0][0];
p+=4;

(1) 1

(2) 4

(3) 7

(4) 8

(5) значение не определено

(1) при перегрузке операций не сохраняется количество аргументов используемые в стандартных типах данных.

(2) при перегрузке операций сохраняются приоритеты операций, используемые в стандартных типах данных.

(3) при перегрузке операций сохраняются правила ассоциации, используемые в стандартных типах данных.

(4) при перегрузке операции внутри класса первый операнд может быть любого типа.

(1) операция :

(2) операция .

(3) операция ,

(4) операция ::

(5) операция *

(1) <

(2) >

(3) —

(4) .*

(5) +

(1) присваивания

(2) разадресации

(3) выбора

(4) сравнения на равенство и неравенство

(1) * =

(2) — =

(3) + =

(4) = =

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

#include <stdio.h>
main()
{ int a[3][4];
int i, j, k;
for (i = 0; i < 3; i++)
for (j = 0; j < 4; j++) scanf(«%d», &a[i][j]);
k = -1;
for (i = 0; i < 4; i++) {
for (j = 0; j < 3; j++)
if (a[j][i] == 0) k = i;
}
printf(«%d»,k);
}

(1) номер первого из столбцов массива, содержащих хотя бы один элемент, равный 0

(2) номер последнего из столбцов массива, содержащих хотя бы один элемент, равный 0

(3) количество положительных элементов массива в каждом столбце

(4) номер первой из строк массива, содержащих хотя бы один элемент, равный 0

(5) номер последней из строк массива, содержащих хотя бы один элемент, равный 0

(1) ! =

(2) * =

(3) < =

(4) — =

(1) доступ в объединениях по умолчанию public

(2) в объединениях нельзя явным образом использовать спецификаторы доступа

(3) объединение может иметь конструктор и другие методы

(4) объединение может иметь статические методы

(5) объединение не может участвовать в иерархии классов

(1) деструктор не имеет параметров.

(2) класс может иметь несколько деструкторов с различными именами.

(3) деструктор не имеет возвращаемого значения.

(4) деструктор не может быть объявлен как const.

(5) деструктор может быть объявлен как static.

(1) переменная — член

(2) локальная переменная

(3) переменная класса

(4) внешняя переменная

В чем, кроме имени, различие между методами «f1()» и «f2()» в приведенном ниже коде?

struct Foo
{
int f1() {
return 0;
}
int f2();
};
int Foo::f2() {
return 0;
};

(1) f1() — это встроенная функция.

(2) f1() — это статическая функция.

(3) f2() — это встроенная функция.

(4) f2() — это статическая функция.

(5) f2() - private.

(1) русские буквы

(2) символ подчеркивания

(3) цифры от 0 до 9

(4) знаки + и —

(1) результат операции деления над целыми числами — целый

(2) результат любых операций над целыми числами — целый

(3) результат операций сравнения целых чисел — булевский

(4) результат стандартных тригонометрических функций с аргументами целого типа — целый

(1) они соответствуют структурам данных, используемым в программе

(2) они записываются одинаково на всех языках, поддерживающих структурную технологию программирования

(3) они имеют только один вход и один выход

(4) они состоят из одинаковых блоков.

(1) глобальные переменные нужно передавать в функцию через список параметров

(2) место под формальные параметры выделяется на стадии выполнения программы

(3) компилятор инициализирует нулями глобальные переменные

(4) функция может возвращать значение стандартного типа

(1) более читабельные программы

(2) более быстродействующие программы

(3) программы, допускающие более простую модификацию

(4) более короткие программы

(1) protected

(2) public

(3) virtual protected

(4) private

(5) virtual

(1) символы +, =, *

(2) латинские буквы

(3) русские буквы

(4) символы !, ?, *

(1) операндам булевского типа

(2) операндам целого типа

(3) операндам действительного типа

(1) переменная булевского типа

(2) выражение целого типа

(3) пустой оператор

(4) константа true

(1) константой типа int

(2) переменной типа int

(3) выражением типа int

(4) только переменной типа int с именем а

(1) возможность использования в новых программах ранее созданных объектов

(2) увеличение быстродействия программы

(3) простота использования

(4) легкость внесения изменений в программу

Какие из следующих утверждений являются НЕПРАВИЛЬНЫМИ?

class Base{};
class Derived: private Base{};

(1) Base является суперклассом для Derived.

(2) Derived является открытым потомком Base.

(3) Derived является дочерним классом Base.

(4) Base является потомком Derived.

(1) буквы национальных алфавитов

(2) имена переменных

(3) шестнадцатеричные числа

(4) символы +, -, [, ]

(1) []

(2) sizeof

(3) ->

(4) =

(5) ^

(1) любой оператор

(2) любой оператор, кроме оператора перехода

(3) произвольное количество операторов

(4) составной оператор

(1) аргумент может быть только константой

(2) У функции нет параметров

(3) аргумент может быть только переменной

(4) аргумент может быть выражением любого типа

(1) инкапсуляция

(2) абстрагирование

(3) наследование

(4) полиморфизм

Какой уровень доступа имеет переменная «x» из класса «derived» в приведенном примере?

class basex
{
int x;
public:
void setx(int y) {x = y;}
};
class derived : public basex {};

(1) protected

(2) private

(3) global

(4) public

(5) local

(1) выражения

(2) числа

(3) операторы

(4) имена

(1) f(a,b,x);

(2) f(c,b,d);

(3) f(a,x,c);

(4) f(a,c,b);

(1) только данные

(2) только методы

(3) данные и методы

(1) дружественность не наследуется.

(2) друзья класса не имеют доступа к закрытым членам класса.

(3) объявление дружественности двунаправленное.

(4) друзья класса имеют доступ к данным всех его потомков.

(1) скобки

(2) числа

(3) выражения

(4) имена

(1) P(a,b,c);

(2) P(3,b,x);

(3) P(a,c,d-x/2);

(4) P(a,b+5,d-a);

(1) да

(2) нет

(3) могут, если они имеют одинаковый смысл

(4) могут, если их предварительно описать

(1) f("Test", 2.0);

(2) f<int>("Test", 2.0);

(3) f<int, char*, double>(2, 2.5);

(4) f<int, char*>(2, 2);

(1) восьмеричные числа

(2) шестнадцатеричные числа

(3) десятичные числа с плавающей точкой

(4) комментарии

(1) P(a,b,c);

(2) P(c%d,sin(d)/3.14,e);

(3) P(d,a-b,e);

(4) P(c,c,e);

(1) из других объектов в том же файле

(2) только из других файлов

(3) из методов этого объекта

(4) из методов других объектов

(5) из методов объектов-наследников

(1) ‘b’

(2) 0xFFG0

(3) 7.2e3

(4) 0.008E-123

Что будет выведено на экран в результате работы программы?

#include <stdio.h>
int a, b, c, d;
void f( int& a, int& c, int& d)
{
int b;
a = 5; c = 7; b = 9;
}
int main()
{
a = 1; c = 1; b = 1;
f(a, b, c);
printf («%d|%d|%d»,a,c,b);
return 0;
}

(1) 9|5|7

(2) 5|1|7

(3) 1|9|7

(1) с директивой private

(2) с директивой public

(3) без директив

(4) с директивой local

(5) с директивой global

(1) ‘x07’

(2) 0.0000000001

(3) 7.2*e3

(4) -126

(1) cos(3*a+1*abs(x)))

(2) Sin/^2*x+0,2

(3) 0xEEEE*1.34E-2/i/2

(4) cos(3a+1*abs(x))

(1) int __f(int& i_1_);

(2) int * f(int **i);

(3) int 1f(int& i);

(4) *int f(int i);

Что неверно при инициализации ‘y’ в приведенном ниже коде?

class SomeClass
{
int x;
public:
SomeClass (int xx) : x(xx) {};
};
SomeClass x (10);
SomeClass y(x);

(1) это неверно, потому что SomeClass не содержит public конструктора копирования.

(2) это неверно, потому что SomeClass не содержит виртуального деструктора.

(3) это неверно, потому что SomeClass не содержит конструктора по умолчанию.

(4) здесь нет ничего неверного. С инициализацией ‘y’ все в порядке.

(5) это неверно, потому что SomeClass не содержит конструктора копирования.

(1) 36

(2) ‘1’

(3) 0x$1

(4) ’12’

(5) 5,65

(1) (1 < 3) && (2 = = 1)

(2) (1 < 3) || (2 = = 1)

(3) (! (1 > 3)) && (1 < 3)

(4) ! ((1 < 3) && (2 = = 1))

(5) (1 > 3) || ! (1 > 3)

Что будет выведено на экран в результате работы фрагмента программы

for (int ii = 0; ii < 3; ++ ii)
{
switch (ii)
{
case 0: cout << «ZERO»;
case 1: cout << «ONE»; continue;
case 2: cout << «TWO»; break;
}
cout << endl;
}

(1) ZEROONEONETWO

(2) ZEROONETWO

(3) ZERO ONETWO

(4) ZEROONE TWO

(5) ZERO ONE TWO

Что будет выведено на экран в результате работы программы?

#include <stdio.h>
void f(char a, char& d)
{
a = ‘в’; d = ‘с’;
}
int main()
{
char a[]=»глаз»;
f(a[0],a[3]);
puts(a);
return 0;
}

(1) глас

(2) слаг

(3) глаз

(1) константный метод объявляется с ключевым словом const после указания типа возвращаемого значения.

(2) константный метод может вызывать только константные методы.

(3) конструктор является примером константного метода.

(4) деструктор является примером константного метода.

(5) константный метод может вызываться из любых (не только константных) методов.

(1) unsigned char

(2) unsigned short int

(3) signed char

(4) signed short int

(5) float

(1) (a == 1) || ! false

(2) (a == 1) || (a = = 2)

(3) ! (a == 2) || true

(4) (a == 1) && false

Что будет выведено на экран в результате работы программы?

#include <stdio.h>
void f(char a, char d)
{
a = d; d = a;
}
int main()
{
char a[] = «глаз»;
f(a[0],a[3]);
puts(a);
return 0;
}

(1) влаг

(2) влаз

(3) глаз

(1) константный метод объявляется с ключевым словом const перед списком параметров.

(2) константный метод не может изменять значения полей класса.

(3) константный метод не может вызывать любые другие методы класса.

(4) константный метод может вызываться для любых (не только константных) объектов.

(5) в константный метод неявно передается указатель this.

(1) long double

(2) unsigned long int

(3) signed long int

(4) unsigned short int

(5) float

(1) целого типа — вещественной переменной

(2) целого типа — символьной переменной

(3) булевского типа — целой константе

(4) целого типа — булевской переменной

Что будет выведено на экран в результате работы программы?

#include <stdio.h>
void f(char* a, char* b)
{
a[1] = b[1]; b[2] = a[2];
}
int main()
{
char a[]=»abcd»;
char b[]= «opr»;
f(a,b);
printf («%s%s», a, b);
return 0;
}

(1) apcdopc

(2) apcdopp

(3) doapca

Что можно сказать о приведенном примере?>

#include <iostream.h>
class A{
int x;
public:
A(int y){x = y;}
};
int main(){
A a(3);
cout << a.x << endl;
return 0;
}

(1) программа будет работать нормально.

(2) при компиляции программы возникнет ошибка.

(3) программа будет компилироваться, но не будет компоноваться.

(4) при выполнении программы возникнет ошибка.

(1) 213

(2) -13

(3) -213

(4) 35000

(5) -1.2

(1) вещественной переменной — целое выражение

(2) целую переменную — вещественной переменной

(3) целой константе — целую константу

(4) булевской переменной — булевскую константу

(1) структура может включать в себя только простейшие типы данных (int, char и т.д.).

(2) структура не может иметь конструкторов и деструкторов.

(3) структура не может быть наследником класса.

(4) поля класса закрыты по умолчанию.

(5) класс не может быть наследником структуры.

(1) 6

(2) 226

(3) -6

(4) -226

(5) 257

(1) одного пробела

(2) произвольного количества пробелов

(3) запятой

(4) нажатия клавиши ENTER

(1) поля класса могут быть описаны с модификатором extern

(2) поля класса могут быть описаны с модификатором auto

(3) поля класса не могут иметь тип самого класса

(4) поля класса могут быть указателями на сам класс

(1) только из алфавита языка C++

(2) из первой половины кодовой таблицы

(3) только символов английского алфавита, цифр и символа подчеркивания

(4) от -128 до 127

Что будет выведено на экран в результате работы программы (учитывая формат вывода)?

int k;
float y;
int main()
{
k = 4; y = 2;
printf («%4.2f%2d», y, k);
return 0;
}

(1) 2 4

(2) 2.00 4

(3) 4.00 2

(1) локальный класс не может иметь статических элементов

(2) методы локального класса могут быть описаны вне класса

(3) методы локального класса могут быть описаны только внутри класса

(4) внутри локального класса нельзя использовать элементы перечислений из области, в которой он описан

(5) внутри локального класса можно использовать только стандартные типы данных

Что будет выведено на экран в результате работы программы (учитывая формат вывода)?

#include <stdio.h>
main()
{
int k;
float x;
k = 2; x = 3;
printf(«[%4.2f%d]», x, k);
}

(1) [3.002]

(2) 32

(3) 32.0

Что будет выведено на экран в результате работы программы?

#include <stdio.h>
main()
{
const char a[] = «abcrcaab»;
int i;
for (i = 0; i < 8; i++)
if (a[i] < ‘c’) printf(«%c»,a[i]);
}

(1) abaab

(2) abbaa

(3) baaba

(1) внутри локального класса можно использовать внешние функции

(2) внутри локального класса нельзя использовать стандартные типы

(3) внутри локального класса можно использовать статические (static) переменные

(4) внутри локального класса можно использовать внешние (extern) переменные

(5) внутри локального класса можно использовать типы данных из области, в которой он описан

(1) printf (x=%f k=%d y=%5.2f , x, k, y);

(2) printf ("%5f %f", x*k, y);

(3) printf ("* %12f, %d4 %4f*", x*y, k, y);

(4) printf ("*, x, k * y, *'");

(1) локальные объекты создаются до вызова функции main.

(2) класс может иметь только один конструктор.

(3) класс может иметь несколько конструкторов.

(4) конструкторы глобальных объектов вызываются при компиляции программы.

(1) имена переменных и констант

(2) зарезервированные слова

(3) выражения

(4) операторы

(1) конструкторы наследуются.

(2) конструкторы нельзя описывать с модификатором const.

(3) конструкторы нельзя описывать с модификатором virtual.

(4) конструкторы нельзя описывать с модификатором static.

(1) char* const pc

(2) char* pc

(3) const char* const pc

(4) невозможно определить указатель на константу.

(5) const char* pc

(1) конструктор по умолчанию.

(2) конструктор копирования.

(3) конструктор с параметром-объектом.

(4) в этом случае никакой конструктор не вызывается.

Какое значение получит p[0] в данном примере?

int a[2][3]={{1,2,3},{7,8,9}};
int *p=&a[0][0];
p+=3;

(1) 1

(2) 4

(3) 7

(4) 8

(5) значение не определено

(1) дружественная функция объявляется внутри класса, к элементам которого ей нужен доступ, с ключевым словом friend.

(2) в качестве параметра ей должна передаваться ссылка на объект класса.

(3) дружественной функции передается указатель this.

(4) дружественная функция может быть обычной функцией.

(5) дружественная функция может быть методом другого, ранее определенного класса.

(1) для стандартных типов данных переопределять операции нельзя.

(2) функции-операции могут иметь аргументы по умолчанию.

(3) любые функции-операции не наследуются.

(4) функции-операции не могут определяться как static.

(1) операция ->

(2) операция .

(3) операция ,

(4) операция ::

(5) операция .*

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

#include <stdio.h>
main(){
int a[3][4];
int i, j, k;
for (i = 0; i < 3; i++)
for (j = 0; j < 4; j++) scanf(«%d»,&a[i][j]);
for (i = 0; i < 3; i++)
{
k = 0;
for (j = 0; j < 4; j++)
if (a[i][j] > 0) ++k;
}
printf(«%d»,k);
}

(1) количество положительных элементов массива

(2) количество положительных элементов массива в каждой строке

(3) количество положительных элементов массива в последней строке

(4) количество положительных элементов массива в последнем столбце

(5) количество положительных элементов массива в первой строке

(1) /

(2) —

(3) +=

(4) <=

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

#include <stdio.h>
main()
{ int a[3][4];
int i, j, k;
for (i = 0; i < 3; i++)
for (j = 0; j < 4; j++) scanf(«%d», &a[i][j]);
k = -1;
for (i = 0; i < 4; i++) {
for (j = 0; j < 3; j++)
if (a[j][i] == 0) { k = i; break; }
}
printf(«%d»,k);
}

(1) номер первого из столбцов массива, содержащих хотя бы один элемент, равный 0

(2) номер последнего из столбцов массива, содержащих хотя бы один элемент, равный 0

(3) количество положительных элементов массива в каждом столбце

(4) номер первой из строк массива, содержащих хотя бы один элемент, равный 0

(5) номер последней из строк массива, содержащих хотя бы один элемент, равный 0

(1) доступ в объединениях по умолчанию private

(2) в объединениях можно использовать спецификаторы доступа

(3) объединение не может иметь конструктор и другие методы

(4) объединение может иметь статические методы

(5) объединение не может участвовать в иерархии классов

(1) деструктор наследуется.

(2) деструктор может быть виртуальным.

(3) деструктор может быть вызван из программы.

(4) класс может иметь несколько деструкторов с различными именами.

(5) деструктор может иметь только один параметр.

(1) Overriding (переопределение)

(2) Overloading (перегрузка)

(3) Inheritance (наследование)

(4) Еncapsulation (инкапсуляция)

Для приведенного ниже кода при вызове функции Func программа аварийно завершается. В чем причина ошибки?

class Foo
{
char *buf;
public:
Foo(char *b = «default») {
buf = new char[strlen(b) + 1];
strcpy(buf, b);
}
~Foo() {
delete[] buf;
}
};
Foo Func(Foo f) {
return f;
}

(1) значение конструктора по умолчанию имеет тип char*.

(2) функция должна возвращать Foo& (ссылку).

(3) требуется переопределить операцию =.

(4) выделяется недостаточный объем памяти.

(5) в классе отсутствует конструктор копирования.

(1) русские буквы

(2) прописные латинские буквы

(3) цифры от 0 до 9

(4) символы (, ?, %

(1) результат арифметических операций над действительными числами — действительный

(2) в одном выражении можно использовать операнды действительного и целого типов

(3) результат операций сравнения действительных чисел — действительный

(1) написание программы, состоящей из базовых конструкций структурного программирования

(2) уменьшение ошибок при отладке программ и упрощение их модификации

(3) использование самых простых структур данных

(4) уменьшение объема программы

(1) локальные переменные существуют только во время выполнения функции

(2) для параметров, передаваемых по значению, в стеке создается их копия

(3) компилятор инициализирует нулями локальные переменные

(4) функция может возвращать значение стандартного типа

(1) к уменьшению количества повторяющихся фрагментов

(2) к увеличению ее быстродействия

(3) к облегчению ее отладки

(4) к увеличению количества классов

(1) protected

(2) public

(3) virtual protected

(4) private

(5) virtual

(1) прописные латинские буквы

(2) строчные латинские буквы

(3) цифры

(4) символы <, >, =, !

(1) операндам типа bool

(2) операндам типа int

(3) операндам типа float

(4) операндам типа char

(1) любой оператор

(2) любой оператор, кроме оператора перехода

(3) условный оператор

(4) произвольное количество операторов

(1) константой типа int

(2) переменной типа int

(3) выражением типа int

(4) выражением любого типа

(1) большой объем информации, необходимый для грамотного применения ООП

(2) локализация свойств и поведения объекта о одном месте

(3) возможное уменьшение быстродействия программы за счет виртуальных методов

(4) избыточный код программы

Какие из следующих утверждений являются НЕПРАВИЛЬНЫМИ?

class Base{};
class Derived: protected Base{};

(1) Base является закрытым потомком Derived.

(2) Base является суперклассом для Derived.

(3) Derived является дочерним классом Base.

(4) Derived является закрытым потомком Base.

(1) лексемы

(2) латинские буквы

(3) директивы препроцессора

(4) символы !, ?, *

(1) +=

(2) = =

(3) - =

(4) *=

(5) %=

(1) любой оператор, кроме оператора перехода

(2) вложенный условный оператор

(3) произвольное количество операторов

(4) простой или составной оператор

(1) переменной типа int

(2) выражением типа int

(3) выражением типа, совместимого с int

(4) константой типа int

Какой уровень доступа имеет переменная «x» из класса «derived» в приведенном примере?

class basex
{
public:
int x;
};
class derived : basex {};

(1) protected

(2) private

(3) global

(4) public

(5) local

(1) знаки операций

(2) разделители

(3) двоичные числа

(4) имена

(1) f(a,b,c);

(2) f(d+a,c,x);

(3) f(x,'c',d);

(4) f(a,b,a+1);

(1) абстрактному типу данных

(2) экземпляру

(3) интерфейсу

(4) подклассу

(1) абстрактный класс не может иметь потомков.

(2) класс является абстрактным, если в нем есть виртуальные функции.

(3) класс является абстрактным, если в нем есть чисто виртуальные функции.

(4) допускается объявление переменной-указателя на абстрактный класс.

(1) разделители

(2) целые константы

(3) комментарии

(4) идентификаторы

(1) P(3200,'a',c/2*d);

(2) P(a,c,d-1);

(3) P(c,a[4],d);

(4) P(d,a[2],c);

(1) имя типа объекта

(2) имя экземпляра объекта

(3) имя поля объекта

(4) имя объекта-предка

(5) ничего не указывается

(1) параметром шаблона может быть стандартный тип данных

(2) шаблоны методов не могут быть виртуальными.

(3) у класса-шаблона могут быть друзья.

(4) шаблоны не могут являться базовыми для обычных классов.

(5) в классе-шаблоне нельзя объявлять статические поля

(1) двоичные числа

(2) идентификаторы

(3) разделители

(4) выражения

Что будет выведено на экран в результате работы программы?

#include <stdio.h>
int a, b, c, d;
void f( int a, int& c, int& d)
{
int b;
a = 5; c = 7; b = 9;
}
int main()
{
a = 1; c = 1; b = 1;
f(a,c,b);
printf («%d|%d|%d»,a,c,b);
return 0;
}

(1) 7|7|1

(2) 1|7|1

(3) 7|1|1

(1) public

(2) private

(3) local

(4) global

(5) protected

(1) ‘Ж’

(2) ‘1’

(3) 1.’2 e1′

(4) «вася»

(1) sin(abs(0.6e3*y/_do))

(2) sin(do*(0.6e3*y))

(3) 0XEF01*1.34E-2/i7/_12

Что будет выведено на экран в результате работы программы?

#include <stdio.h>
int a, b, c, d;
void f( int& a, int c, int& d)
{
int b;
a = 5; c = 7; b = 9;
}
int main()
{
a = 1; c = 1; b = 1;
f(a,b,c);
printf («%d|%d|%d»,a,c,b);
return 0;
}

(1) 5|1|1

(2) 1|1|5

(3) 5|5|1

(1) -7

(2) 00

(3) «wццц»

(4) 1.2 e1

(5) 0x0

(1) (a*abs(x)+/(0,6*k)

(2) a-0.1*0x0A1

(3) sin(t)/sin(t2)

(4) sin(t)/sin(2t)

(1) float f(long* array, const int n);

(2) int f(long a[10]);

(3) float f(long i, long j);

(4) &int f(int i);

(1) class bad {static int I;}; int bad::I=99;

(2) class bad {static I;}; int bad:I=99;

(3) class bad {int I=99;}; int bad::I=99;

(4) class bad {static int I = 99;};

(5) class bad {static int I=99;}; int I::bad=99;

(1) &

(2) # 2

(3) 26.4

(4) 0xA0

(5) 3,59e0,2

(1) (a < 3) || (a = = 5)

(2) ! ((a < 3) && true)

(3) (a < 3) && (a = = 2)

(4) (a = = 1) || (a = = 2)

Что будет выведено на экран в результате работы программы?

for (int ii = 0; ii < 3; ++ ii)
{
switch (ii)
{
case 0: cout << «ZERO»; break;
case 1: cout << «ONE»;
case 2: cout << «TWO»; continue;
}
cout << endl;
}

(1) ZEROONEONETWO

(2) ZEROONETWO

(3) ZERO ONETWO

(4) ZEROONETWOTWO

(5) ZERO ONE TWO

Что будет выведено на экран в результате работы программы?

#include <stdio.h>
void f(char& a, char d)
{
a = ‘в’; d = ‘д’;
}
int main()
{
char a[] = «глаз»;
f(a[0],a[3]);
puts(a);
return 0;
}

(1) вгаз

(2) глаз

(3) влаз

(1) константный метод объявляется с ключевым словом const перед указанием типа возвращаемого значения.

(2) константный метод не может изменять значения полей класса.

(3) константный метод может вызываться для любых (не только константных) объектов.

(4) константный метод не может вызывать константные методы класса.

(5) константный метод может изменять значения константных полей класса.

(1) unsigned char

(2) unsigned short int

(3) signed char

(4) signed short int

(5) float

(1) (a == 1) || ! (a == 1)

(2) (a == 1) || false

(3) (a > 1) || (a == 5)

(4) ! (a == 2) || true

Что будет выведено на экран в результате работы программы?

#include <stdio.h>
void f(char* a, char* b)
{
a = b; b = a;
}
int main()
{
char a[]=»abcde»;
char b[]= «opr»;
f(a,b);
puts(a);
return 0;
}

(1) acbde

(2) abcde

(3) abdec

(1) операция ->

(2) операция .

(3) операция ,

(4) операция ::

(5) операция .*

(1) unsigned char

(2) unsigned short int

(3) signed char

(4) signed short int

(5) float

(1) целой переменной можно присвоить целую константу

(2) целой переменной можно присвоить вещественную константу

(3) целой константе можно присвоить целую переменную

(4) целой константе можно присвоить вещественную переменную

Что будет выведено на экран в результате работы программы?

#include <stdio.h>
void f(char* a, char* b)
{
char* c;
c = a; a = b; b = c;
}
int main()
{
char a[]=»abc»;
char b[]= «pr»;
f(a,b);
printf («%s%s», a, b);
return 0;
}

(1) arbcp

(2) arbcc

(3) abcpr

Что можно сказать о приведенном примере?

#include <iostream.h>
class A{
int x;
public:
A(int y){x = y;}
};
int main()
{
A a;
cin >> a.x;
return 0;
}

(1) программа будет работать нормально.

(2) при компиляции программы возникнет ошибка.

(3) программа будет компилироваться, но не будет компоноваться.

(4) при выполнении программы возникнет ошибка.

(1) 13

(2) 213

(3) -13

(4) -213

(5) 32000

(1) на одной строке

(2) в столбик

(3) произвольно

(1) поля класса могут быть описаны с модификатором static

(2) поля класса могут быть описаны с модификатором auto

(3) поля класса могут быть описаны с модификатором register

(4) поля класса могут быть описаны с модификатором extern

(1) символов c кодами от 0 до 32

(2) символов английского алфавита и цифр

(3) от -128 до 127

Что будет выведено на экран в результате работы программы (учитывая формат вывода)?

#include
main()
{
int i;
float t;
i = 1;
t = 5;
printf(«%3.1f%d%2d», t, i, i);
}

(1) 1.01 5

(2) 51 1

(3) 5.01 1

(1) внутри локального класса можно использовать внешние функции

(2) внутри локального класса можно использовать элементы перечислений из области, в которой он описан

(3) локальный класс может иметь статические элементы

(4) методы локального класса не могут быть описаны вне класса

(1) только одного пробела

(2) произвольного количества пробелов

(3) нажатия клавиши TAB

(4) клавиш со стрелками

(1) поля класса могут быть описаны с модификатором extern

(2) поля класса могут быть описаны с модификатором register

(3) поля класса не могут быть ссылками на сам класс

(4) поля класса могут быть указателями на сам класс

(1) printf ("%4.2f %d",y, k);

(2) printf ("%f %f", x, k);

(3) printf ("%d %f", x, k);

(4) printf ("%f %f", x, k * y);

(1) потому что иначе при передаче параметра по значению конструктор будет вызываться рекурсивно.

(2) потому что функция-член класса может иметь в качестве параметра только ссылку.

(3) потому что переменная, передаваемая по ссылке, может быть изменена.

(4) потому что использование ссылки дает более эффективный код.

(1) printf ("|%4d|%6.2f|%6.2f|",d,x,y);

(2) printf ("|%4d|%6.2f|%6.2f|",x,y,d);

(3) printf ("|%4d|%6.2f|%6.2f|",d,x,x*x);

(4) printf ("|%4.2d|%6.2f|%6.2f|",d,x,y);

(1) конструктор возвращает значение типа void.

(2) класс может иметь несколько конструкторов с разными параметрами для разных видов инициализации.

(3) конструктор не может иметь параметров.

(4) нельзя получить указатель на конструктор.

(1) K — общее количество позиций, отводимое под переменную А

(2) K — количество позиций, отводимое под целую часть переменной А

(3) K и M должны быть целыми

(4) K и M могут быть действительными

(1) класс может иметь несколько конструкторов с разными параметрами для разных видов инициализации.

(2) конструктор, вызываемый без параметров, называется конструктором по умолчанию.

(3) параметры конструктора могут иметь любой тип, кроме этого же класса.

(4) конструктор не может выбросить исключение.

(1) char* const pc

(2) char* pc

(3) const char* const pc

(4) невозможно определить указатель-константу на константу.

(5) const char* pc

(1) при передаче объекта в функцию по ссылке

(2) описании нового объекта с инициализацией другим объектом

(3) передаче объекта в функцию по значению

(4) возврате адреса объекта из функции

Какое значение получит «p[0]» в данном примере?

int a[2][3]={{1,2,3},{7,8,9}};
int *p=&a[0][0];
p+=2;

(1) 1

(2) 3

(3) 7

(4) 8

(5) значение не определено

(1) вы можете определить дружественную функцию и дружественный класс.

(2) если класс А является дружественным для класса B, то класс A имеет доступ ко всем закрытым полям и методам класса В.

(3) если класс А является дружественным для класса B и класс С — потомок B, то класс A является дружественным для C.

(4) если класс А является дружественным для класса B, это не означает, что класс B является дружественным для A.

(1) .*

(2) .

(3) ::

(4) ?:

(5) ->*

(1) присваивания

(2) взятия адреса

(3) вывода на экран

(4) отношения

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

#include <stdio.h>
main()
{ int a[3][4];
int i, j, k;
for (i = 0; i < 3; i++)
for (j = 0; j < 4; j++) scanf(«%d», &a[i][j]);
for (i = 0; i < 4; i++) {
k = 0;
for (j = 0; j < 3; j++)
if (a[j][i] > 0) ++k;
}
printf(«%d»,k);
}

(1) количество положительных элементов массива

(2) количество положительных элементов массива в каждой строке

(3) количество положительных элементов массива в каждом столбце

(4) количество положительных элементов массива в последней строке

(5) количество положительных элементов массива в последнем столбце

(1) ! =

(2) * =

(3) + =

(4) — =

(1) доступ в объединениях по умолчанию public

(2) в объединениях можно явным образом использовать спецификаторы доступа

(3) объединение не может участвовать в иерархии классов

(4) элементами объединения не могут быть объекты, содержащие конструкторы и деструкторы

(5) объединение может иметь конструктор и другие методы, только не статические

(6) в анонимном объединении нельзя описывать методы

При компиляции следующего примера возникает ошибка. Чтобы ее исправить, необходимо …

class Foo{
int x;
public: Foo(int i){}
};
class Bar: virtual Foo{
public: Bar(){}
};
Bar b;

(1) добавить конструктор класса «Bar» который получает параметр типа int

(2) добавить вызов «Foo()» к конструктору класса «Bar»

(3) добавить вызов «Foo(0)» к конструктору класса «Bar»

(4) добавить виртуальный деструктор для класса «Bar»

(5) добавить конструктор копирования для класса «Foo»

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

class myclass
{
int a;
public:
myclass(int x);
};
myclass::myclass(int x) { a = x;}
int main()
{
myclass ob(120);
myclass *p;
return 0;
}

(1) *p = myclass *ob;

(2) *p = *ob;

(3) p = &ob;

(4) p = *ob;

(5) p = ob;

Выберите правильный вызов функции-члена класса С через указатель «pmfn»

class Class1
{
public:
void func();
};
void (Class1::*pmfn)() = &Class1::func;
Class1 *c;

(1) c->pmfn();

(2) (c.*pmfn)();

(3) c.*pmfn();

(4) c->*pmfn();

(5) (c->*pmfn)();

(1) М — количество позиций, отводимое под дробную часть переменной А