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


Download 2.19 Mb.
Pdf ko'rish
bet1/2
Sana30.09.2023
Hajmi2.19 Mb.
#1690117
  1   2
Bog'liq
Dasturlash II(@Chats DT 1)



====
тип
Какой оператор следует использовать для определения типа объекта во время выполнения?
++++
#идентификатор_типа
====
Отобразите строку, содержащую член класса, определенный в классе type_info.
++++
тип
====
#bool оператор != (const type_info &ob);
тупейд
====
логический оператор <=(const type_info &ob);
====
Какой заголовочный файл нужно добавить для определения типа объекта во время выполнения программы?
тип
логический оператор >=(const type_info &ob);
====
++++
====
====
#типинфо
константное имя символа();
====
====
тип
====
====
идентификатор типа
Machine Translated by Google


====
>
Отобразите строку, содержащую член класса, определенный в классе type_info.
++++
логический оператор >= (const type_info &ob);
====
,
====
логический оператор <(const type_info &ob);
====
оператор dynamic_cast...
оператор >(const type_info &ob);
====
# используется во всей программе для приведения полиморфных типов к одному типу
====
Как переопределяются операции сравнения в классе type_info?
#const char *имя();
Используется для явного переопределения модификаторов const и/или volatile.
====
== и <
====
++++
# == и != .
используется для преобразования любых стандартных типов
====
====
все операции сравнения
====
====
ни один из них
Machine Translated by Google


====
# используется для преобразования любых стандартных типов
позволяет преобразовать любой целочисленный тип в любой тип указателя и наоборот
====
оператор const_cast...
++++
позволяет преобразовать любой целочисленный тип в любой тип указателя и наоборот
====
используется во всей программе для приведения полиморфных типов к одному типу
====
оператор переинтерпретировать_каст...
Используется для явного переопределения модификаторов #const и/или volatile.
====
используется во всей программе для приведения полиморфных типов к одному типу
++++
позволяет преобразовать любой целочисленный тип в любой тип указателя и наоборот
используется для преобразования любых стандартных типов
Используется для явного переопределения модификаторов const и/или volatile.
====
====
====
++++
оператор static_cast...
используется для преобразования любых стандартных типов
====
====
используется во всей программе для приведения полиморфных типов к одному типу
====
====
Используется для явного переопределения модификаторов const и/или volatile.
Machine Translated by Google


====
имя класса { . . . }
#позволяет преобразовать любой целочисленный тип в любой тип указателя и наоборот
====
пространство имен - это...
++++
использование пространства имен std;
# — это пространство имен, которое решает проблему использования одних и тех же идентификаторов в одной и той же программе.
====
Какой оператор используется для ссылки на классы и методы в созданном пространстве имен?
это стандартное пространство имен, которое решает проблему использования команд ввода/вывода.
====
#::
++++
— это анонимное пространство имен, которое решает проблему использования анонимных типов.
— это общее пространство имен, которое решает проблему использования всех команд языка программирования C++.
->
====
====
====
++++
Пространство имен Общая структура создания пространства имен приведена в ответе.
;
====
====
#namespace <имя> { . . . }
====
=====
template void func (T a) {cout<Machine Translated by Google


#10
Определяем, что будет выведено на экран в результате компиляции:
====
====
++++
====
использование пространства имен std;
12
#include <иопоток>
====
пространство имен A {void fun (float i) { cout <пространство имен A {void fun (int i) { cout <====
====
>
№14
интервал основной () {целый я = 12; B::весело(я); вернуть 0;}
====
++++
#include <иопоток>
Определяем, что будет выведено на экран в результате компиляции:
пространство имен A {void fun (int i) { cout <10
====
использование пространства имен std;
int main () { float i = 12; А::весело(я); вернуть 0; }
12
пространство имен B {void fun (int j) { cout <14
ошибка компиляции
Machine Translated by Google


14
++++
====
интервал основной () {целый я = 12; весело (я); вернуть 0; }
++++
№14
#include <иопоток>
#10
#include <иопоток>
10
пространство имен A { void fun (int i) { cout <пространство имен A { void fun (int i) { cout <12
используя пространство имен А;
ошибка компиляции
====
используя пространство имен А;
====
ошибка компиляции
Определяем, что будет выведено на экран в результате компиляции:
Определяем, что будет выведено на экран в результате компиляции:
использование пространства имен std;
====
====
использование пространства имен std;
пространство имен B { void fun (int i) { cout <====
пространство имен B { void fun (int i) { cout <интервал основной () {целый я = 12; B::весело(я); вернуть 0; }
====
Machine Translated by Google


const_cast
====
====
пространство имен B { void fun (int i) { cout <====
интервал основной () {целый я = 12; C:: весело (я); вернуть 0; }
++++
переинтерпретировать_cast
++++
14
====
#include <иопоток>
#10
====
12
пространство имен C=A::B;
пространство имен A { void fun (int i) { cout <====
12
ошибка компиляции
ошибка компиляции
Какой оператор преобразования типа в тип используется для преобразования полиморфных типов?
====
====
Определяем, что будет выведено на экран в результате компиляции:
#динамический_каст
====
использование пространства имен std;
static_cast
====
Machine Translated by Google


переинтерпретировать_cast
====
++++
static_cast(имя_типа)<значение>
====
Покажите структуру операции dynamic_cast:
++++
const_cast
====
#dynamic_cast(objectPointer) или dynamic_cast(objectVariable)
====
====
dynamic_cast(objectPointer) или dynamic_cast(objectVariable)
====
Покажите структуру оператора static_cast:
++++
====
====
dynamic_cast(objectPointer) или dynamic_cast(objectVariable)
dynamic_cast (указатель объекта) <тип *>
#static_cast(значение)
Какой оператор используется для явного изменения типов статистических данных?
====
====
static_cast<значение>(type_name)
#static_cast
====
static_cast(value)
dynamic_cast
====
Machine Translated by Google


====
#управляет памятью, выделенной его элементам, и предоставляет функции для доступа к ним напрямую или
через итераторы.
====
====
#Последовательный и ассоциативный (упорядоченный и неупорядоченный)
это набор функций для выполнения операций над массивами
====
предоставляет функции для замены значений своих элементов и обращения к ним напрямую
====
====
Массив, последовательный и неупорядоченный ассоциативный
представляет собой набор переменных и функций, которые позволяют программистам легко реализовывать
структуры данных
++++
это общая библиотека, решающая проблему использования всех команд языка программирования C++
====
====
++++
Контейнерная библиотека — это…
управляет памятью, выделенной для его элементов, но не делает прямых ссылок на них
====
предоставляет функции для вычисления суммы значений его элементов
====
Контейнер — это…
++++
Найдите ответ, в котором правильно указаны основные категории классов контейнеров?
#это универсальный набор шаблонов классов и алгоритмов, которые позволяют программистам легко
реализовывать структуры данных
====
Machine Translated by Google


====
массив шаблонов <класс T>;
Адаптер и серийный номер
====
Deque, вектор, список, forward_list
====
template struct array;
====
Найдите ответ, в котором перечислены типы последовательных контейнеров?
++++
шаблон <класс T> массив {T a={}};
#vector, array, deque, forward_list, список
====
Функция для удаления произвольного элемента из контейнера?
====
массив, список, forward_list, карта, неупорядоченная_карта
вектор, массив, набор, карта
#стереть()
====
====
++++
====
множество, неупорядоченное_множество, мультимножество, неупорядоченное_мультимножество
вставлять()
====
++++
показать шаблон класса массива:
====
====
#template struct array;
Machine Translated by Google


====
[]
прозрачный()
====
удалить()
====
передний
====
функция для удаления последнего элемента из векторного контейнера?
++++
назад
#pop_back()
====
Какая функция обеспечивает доступ к указанному элементу в векторном контейнере (с проверкой индекса)
====
стереть()
отталкивать()

====
====
++++
====
прозрачный()
[]
====
++++
Какая функция обеспечивает доступ к указанному элементу в контейнере массива (с проверкой индекса)
====
====

Machine Translated by Google


====
#[]
передний
====
назад
====
передний
Какая функция обеспечивает доступ к элементу, указанному в контейнере deque (с проверкой индекса)
++++
назад

====
Какая функция обеспечивает доступ к указанному элементу в контейнере массива (не выполняет
проверку индекса)
====
передний
[]
в
====
====
++++
====
назад
#[]
====
++++
Какая функция обеспечивает доступ к элементу, указанному в контейнере deque (не выполняет
проверку индекса)
====
====
в
Machine Translated by Google


в
====
====
#[]
====
передний
====
++++
назад
====
====
Какая функция обеспечивает доступ к первому элементу векторного контейнера
++++
передний
====
====
====
в
[]
назад
#передний
====
====
Какая функция обеспечивает доступ к элементу, указанному в векторном контейнере (не выполняет
проверку индекса)
назад
++++
в
Какая функция обеспечивает доступ к первому элементу в контейнере массива
====
Machine Translated by Google


====
в
[]
====
#передний
====
[]
назад
====
#передний
Какая функция обеспечивает доступ к первому элементу списка (в контейнере списка).
++++
назад
====
[]
в
Какая функция обеспечивает доступ к первому элементу двойной очереди (в контейнере deque).
====
====
====
====
#передний
в
++++
====
назад
====
++++
Какая функция обеспечивает доступ к первому элементу одностороннего связанного списка (в
контейнере forward_list).
Machine Translated by Google


Какая функция обеспечивает доступ к последнему элементу списка (в контейнере списка).
====
====
в
====
[]
====
в
====
передний
====
++++
#назад
====
[]
====
====
++++
Какая функция обеспечивает доступ к последнему элементу в контейнере массива
в
#передний
[]
====
====
назад
передний
====
Какая функция обеспечивает доступ к последнему элементу векторного контейнера
#назад
++++
Machine Translated by Google


Какая функция проверяет, является ли контейнер массива пустым или нет?
====
====
в
====
[]
====
====
передний
====
++++
#назад
====
[]
====
====
++++
Какая функция обеспечивает доступ к последнему элементу в контейнере двойной очереди (deque)
в
передний
[]
====
====
#назад
передний
====
Какая функция обеспечивает доступ к последнему элементу одностороннего связанного списка (в контейнере forward_list).
#назад
++++
Machine Translated by Google


++++
Какая функция проверяет, пуст контейнер списка или нет?
#пустой
====
прозрачный
=====
#пустой
====
полный
====
прозрачный
считать
====
полный
=====
#пустой
Какая функция проверяет, является ли векторный контейнер пустым или нет?
считать
++++
====
====
=====
прозрачный
Какая функция проверяет, пуст контейнер forward_list или нет?
====
====
полный
++++
====
считать
Machine Translated by Google


++++
Какая функция возвращает количество элементов в контейнере deque?
#пустой
====
прозрачный
=====
#размер
====
полный
====
макс_размер
считать
====
полный
=====
#пустой
Какая функция проверяет, пуст контейнер deque или нет?
считать
++++
====
====
====
прозрачный
Какая функция возвращает количество элементов в контейнере массива?
====
====
полный
++++
====
считать
Machine Translated by Google


++++
Какая функция возвращает количество элементов в контейнере списка?
#размер
====
макс_размер
====
#размер
====
полный
====
макс_размер
считать
====
полный
====
#размер
Какая функция возвращает количество элементов в векторном контейнере?
считать
++++
====
====
====
макс_размер
Какая функция возвращает количество элементов в контейнере forward_list?
====
====
полный
++++
====
считать
Machine Translated by Google


++++
Какая функция позволяет добавить новый элемент в начало списка в контейнере списка?
#размер
====
макс_размер
====
#push_front
====
полный
====
отталкивать
считать
====
поп_фронт
====
#push_front
Какая функция позволяет добавить новый элемент в начало списка в контейнере forward_list?
pop_back
++++
====
====
====
отталкивать
Какая функция позволяет добавить новый элемент в конец массива векторного контейнера?
====
====
поп_фронт
++++
====
pop_back
Machine Translated by Google


++++
Какая функция обеспечивает открытие первого элемента в контейнере двойной очереди (deque)
push_front
====
#отталкивать
====
push_front
====
поп_фронт
====
отталкивать
pop_back
====
#поп_фронт
====
push_front
Какая функция позволяет добавить новый элемент в конец списка в контейнере списка?
pop_back
++++
====
====
====
#отталкивать
Какая функция обеспечивает открытие первого элемента списка в контейнере списка
====
====
поп_фронт
++++
====
pop_back
Machine Translated by Google


++++
Ассоциативные контейнеры…
push_front
====
отталкивать
====
# реализует упорядоченную структуру данных с возможностью быстрого поиска
#поп_фронт
====
это набор функций для выполнения операций над массивами
pop_back
====
представляет собой набор переменных и функций, которые позволяют программистам легко реализовывать
структуры данных
====
push_front
Какая функция обеспечивает открытие последнего элемента массива в векторном контейнере
предоставляет функции для замены значений своих элементов и обращения к ним напрямую.
++++
====
====
====
отталкивать
Найдите ответ, который показывает типы упорядоченных ассоциативных контейнеров?
====
====
поп_фронт
++++
====
#pop_back
Machine Translated by Google


Набор пар ключ-значение, отсортированный по ключу, ключи не будут уникальными
++++
====
наборный контейнер - это...
====
Коллекция уникальных ключей, отсортированных по #key
====
Мультимножественный контейнер — это…
====
набор пар ключ-значение, разделенных на ключи, ключи уникальны
====
====
коллекция отсортирована по ключам, ключи не будут уникальными
====
#set, карта, мультисет, мультикарта
====
++++
====
Набор пар ключ-значение, отсортированный по ключу, ключи не будут уникальными
Контейнер карты — это…
вектор, массив, двухсторонняя очередь, список пересылок, список
Набор пар ключ-значение, разделенных #keys, ключи уникальны.
====
++++
массив, список, forward_list, карта, неупорядоченная_карта
набор уникальных ключей, отсортированных по ключу
====
множество, неупорядоченное_множество, мультимножество, неупорядоченное_мультимножество
коллекция отсортирована по ключам, ключи не будут уникальными
====
Machine Translated by Google


c_bound
++++
====
Мультикартовый контейнер — это…
====
Набор пар ключ-значение, упорядоченный по #key, ключи не будут уникальными.
====
====
набор пар ключ-значение, разделенных на ключи, ключи уникальны
====
====
набор уникальных ключей, отсортированных по ключу
====
Коллекция отсортирована по #keys, ключи не будут уникальными
====
++++
====
коллекция отсортирована по ключам, ключи не будут уникальными
Какая функция возвращает итератор, указывающий на первый элемент массива с ключом, большим или равным
указанному ключу?
Набор пар ключ-значение, отсортированный по ключу, ключи не будут уникальными
#нижняя граница
====
++++
набор пар ключ-значение, разделенных на ключи, ключи уникальны
верхняя граница
====
набор уникальных ключей, отсортированных по ключу
emplace_hint
====
Machine Translated by Google


====
count_value(значение)
Что такое сортировка в контейнере карты?
++++
#ключ
====
Найдите разницу между набором и мультинабором контейнеров.
ценить
====
В контейнере #set ключи считаются уникальными, а в мультинаборном контейнере ключи могут дублироваться.
Элемент
====
set container и multiset container не исключают друг друга.
====
Метод, который возвращает количество элементов в коллекции, чьи ключи совпадают с ключом, заданным параметром
в ассоциативных контейнерах, представляет собой...
Сортировка не производится
методы в контейнере набора нельзя использовать в контейнере мультимножества.
====
++++
====
====
#количество(значение)
ключи считаются уникальными в контейнере с несколькими наборами, а ключи в контейнере с наборами могут дублироваться.
====
====
размер (значение)
====
====
вставить (значение)
Machine Translated by Google


====
ул. вставить (я% 4);
++++
====
установить ст;
====
cout<++++
ул. вставить (я% 4);
====
0 1 2 3
cout<Что выводится на экран в результате фрагмента программы
0 1 2 3 4 5 6 7 8 9
Что выводится на экран в результате фрагмента программы
0 1 2 3 4 5 6 7 8 9
#0 1 2 3
#0 0 1 1 1 2 2 3 3
для (целое я = 1; я <10; я ++;)
для (авто это: ст)
для (целое я = 1; я <10; я ++;)
====
1 2 3
1 2 3 0 1 2 3 0 1
для (авто это: ст)
====
1 2 3 0 1 2 3 0 1
====
====
мультимножество ст;
Machine Translated by Google


зап.секунда='А'+я;
Б
Что выводится на экран в результате фрагмента программы
}
пара zap;
====
Что выводится на экран в результате фрагмента программы
}
для (я=0; я<10; я++)
====
пара zap;
зап.первый=я;
====
для (я=0; я<10; я++)
карта ул;
cout<<"\nst[1]="<ст.вставка (зап);
зап.первый=я%4;
====
++++
инт я; символ с;
multimap st;
#ст[1]=Б
ст.вставка (зап);
{
инт я; символ с;
выдает ошибку компиляции
зап.секунда='А'+я;
{
ст[1]=А
Machine Translated by Google


0 1 2 3 0 1 2 3 1 2
ст.вставка (зап);
cout<<"\nst[1]="<++++
ст[1]=В
multimap st;
for(auto it=st.begin(); it!=st.end(); it++)
0 1 2 3 4 5 6 7 8 9
# ошибка компиляции
инт я; символ с;
====
ст[1]=А
{
====
====
Что выводится на экран в результате фрагмента программы
Б
====
зап.секунда='А'+я;
}
====
cout<первый<<" ";
пара zap;
====
====
# 0 0 0 1 1 1 2 2 3 3
для (я=0; я<10; я++)
====
выдает ошибку компиляции
зап.первый=я%4;
Machine Translated by Google


{
#AEIBFJ S GDH
++++
ст.вставка (зап);
multimap st;
for(auto it=st.begin(); it!=st.end(); it++)
ABCDEFGHIJ
зап.секунда='А'+я;
инт я; символ с;
====
Что выводится на экран в результате фрагмента программы
{
====
пара zap;
Что выводится на экран в результате фрагмента программы
}
зап.секунда='А'+я;
для (я=0; я<10; я++)
====
====
пара zap;
++++
cout<секунда<<" ";
зап.первый=я;
для (я=0; я<10; я++)
карта ул;
0 0 0 1 1 1 2 2 3 3
зап.первый=я%4;
инт я; символ с;
выдает ошибку компиляции
Machine Translated by Google


выдает ошибку компиляции
{
ст.вставка (зап);
AEIBFJ S GDH
for(auto it=st.begin(); it!=st.end(); it++)
#ABCDEFGHIJ
зап.секунда='А'+я;
====
Что выводится на экран в результате фрагмента программы
}
====
пара zap;
====
}
====
====
====
для (i=9; i>=0;i--)
зап.первый=я%4;
cout<секунда<<" ";
ст.вставка (зап);
++++
====
0 1 2 3 4 5 6 7 8 9
cout<<"\nst[1]="<карта ул;
выдает ошибку компиляции
ст[1]=В
инт я; символ с;
Machine Translated by Google


++++
cout<секунда<<" ";
ст[1]=А
для (i=9; i>=0;i--)
#st[1]=J
зап.первый=я%4;
#JFB
multimap st;
Что выводится на экран в результате фрагмента программы
ст.вставка (зап);
выдает ошибку компиляции
пара zap;
itb=st.lower_bound(1);
азбука
====
{
инт я; символ с;
JIH
for (it=itb; it!=ite; it++)
====
++++
====
зап.секунда='А'+я;
Что выводится на экран в результате фрагмента программы
multimap st;
====
}
multimap :: iterator it,itb,ite;
====
ite=st.upper_bound(1);
Machine Translated by Google


[0,N] - где N - количество элементов
азбука
пара zap;
itb=st.lower_bound(1);
инт я; символ с;
for (it=itb; it!=ite; it++)
JBF
{
====
Функция count контейнера set возвращает количество элементов в наборе, соответствующих заданному ключу.
зап.секунда='А'+я;
====
====
multimap :: iterator it,itb,ite;
ite=st.upper_bound(1);
}
====
====
====
для (я=0; я<10; я++)
++++
cout<секунда<<" ";
====
зап.первый=я%4;
Уникальное значение
#БДЖ
ст.вставка (зап);
#0 или 1
выдает ошибку компиляции
Machine Translated by Google


находить
++++
в мультинаборном контейнере функция count возвращает количество элементов в наборе, соответствующих заданному
ключу. Уникальное значение
нижняя граница
====
++++
====
Функция, возвращающая итератор, указывающий на первый элемент, ключи которого соответствуют ключу, заданному параметром
в ассоциативных контейнерах.
====
0 или 1
Функция (в ассоциативных контейнерах) возвращает диапазон (массив итераторов элементов), соответствующий заданному
ключу - это...
====
====
[1,N] - где N количество элементов
====
#находить
#[0,N] - где N количество элементов
[1,N] - где N количество элементов
====
====
равный_диапазон
====
1
====
считать
====
++++
1
Machine Translated by Google


Говорят, что стек такой, что последний элемент, попавший в стек, обслуживается первым и удаляется из стека. Найдите пропущенное
слово?
====
нижняя граница
возвращает максимальное значение из набора данных
====
====
++++
c_bound
++++
Какая функция возвращает итератор, указывающий на первый элемент в наборе, ключ которого больше указанного
ключа?
возвращает максимальный объем памяти, необходимый для контейнера
++++
====
#равный_диапазон
====
Какова функция функции max_size() в мультикартовом контейнере?
нижняя граница
#верхняя граница
====
====
# возвращает максимально возможное количество элементов
====
считать
====
возвращает максимальное значение из набора ключей
====
====
emplace_hint
Machine Translated by Google


++++
Какой ответ правильно показывает значение стека слов?
Сорт
====
Общий
# Состав
====
====
Союз
====
#Гарам
====
Воспоминание
Состав
ФИФО
====
Частный
Какой тип службы является стековой службой?
++++
====
=====
====
#ЛИФО
Какая функция удаляет элемент с конца стека?
====
ФОФО
====
====
++++
Уникальный
Machine Translated by Google


++++
Какая строка правильно представляет собой расширение FIFO?
фронт.поп()
====
найти вход найти выход
#поп()
====
====
толкать()
====
#первым прибыл, первым обслужен
====
удалить()
последний ввод первый вывод
ЛИФО
====
первый вход найти выход
Какой тип обслуживания стоит в очереди?
++++
====
====
====
#ФИФО
покажите строку, где правильно процитирована двойная очередь?
====
ФОФО
====
====
++++
Уникальный
Machine Translated by Google


Истинный
Каков результат выполнения следующей части программы?
что
====
mystack.push(1);
#дек
====
#ЛОЖЬ
двушка
Ошибка компиляции
====
cout << "Правда"; }
====
список
cout << "Ложь"; }
всплывающий хвост ()
====
====
Покажите строку, где правильно указана функция добавления элемента из конца двойной очереди?
++++
стек мой стек;
если (мой стек.пусто()) {
====
хвост ()
====
====
====
#отталкивать()
еще {
вернуть 0;
++++
поп.назад()
Machine Translated by Google


#5
++++
====
cout << количество;
целая сумма = 0;
++++
1
6
целая сумма = 0;
#20
mystack.push(1); mystack.push(8); mystack.push(3);
18
mystack.push(1); mystack.push(8); mystack.push(3);
====
====
1
====
в то время как (!mystack.empty()) { сумма = сумма + mystack.top(); mystack.pop(); }
2
Каков результат выполнения следующей части программы?
стек мой стек;
Каков результат выполнения следующей части программы?
====
====
стек мой стек;
====
mystack.push(6); mystack.push(2); cout << mystack.size();
8
mystack.push(6); mystack.push(2);
====
Machine Translated by Google


1
++++
====
' '
очередь моя очередь;
++++
2 1 0
#2
очередь моя очередь;
0
№ 0 1 2
моя очередь.поп(); моя очередь.поп();
2 0 1
в то время как (!myqueue.empty()) { cout <<
' '
Ошибка компиляции
====
0
====
моя очередь.поп(); }
0 2 1
Каков результат выполнения следующей части программы?
моя очередь.push(0); моя очередь.push(1); myqueue.push(2);
Каков результат выполнения следующей части программы?
====
====
====
моя очередь.push(0); моя очередь.push(1); myqueue.push(2);
====
в то время как (!myqueue.empty()) { cout <<
====
<< myqueue.front(); моя очередь.поп(); }
<< myqueue.front();
====
++++
Machine Translated by Google


====
====
myqueue.push(9); myqueue.push(4);
====
#3
в то время как (!myqueue.empty()) { myqueue.pop(); С++; }
4
++++
cout << с;
====
7
====
Каков результат выполнения следующей части программы?
====
Каков результат выполнения следующей части программы?
31
#5
интервал с = 0;
очередь моя очередь;
myqueue.push(3); myqueue.push(4); моя очередь.push(1);
myqueue.push(7); cout << myqueue.front();
очередь моя очередь; myqueue.push(5);
====
====
4
myqueue.push(13); моя очередь.push(0);
13
1
Machine Translated by Google


cout << myqueue.front() - myqueue.back(); }
====
++++
cout << myqueue.back() - myqueue.front(); }
++++
очередь моя очередь;
cout << "0";
myqueue.push(5); myqueue.push(4); myqueue.push(3);
4
очередь моя очередь;
#7
если (myqueue.front() > myqueue.back()) {
myqueue.push(5); myqueue.push(4); myqueue.push(3);
в противном случае
Каков результат выполнения следующей части программы?
если (myqueue.front() < myqueue.back()) {
иначе если (myqueue.front() < myqueue.back()) {
1
0
Каков результат выполнения следующей части программы?
myqueue.push(8); myqueue.push(7); myqueue.push(6);
====
иначе если (myqueue.front() == myqueue.back()) {
myqueue.push(2); моя очередь.push(1);
====
myqueue.push(8); myqueue.push(7); myqueue.push(6);
myqueue.push(2); моя очередь.push(1);
cout << myqueue.front() - myqueue.back(); }
====
Machine Translated by Google


====
# являются объектами произвольного типа, на которые можно ссылаться (вызывать) как на функции.
====
====
#functors() — это перегруженный класс.
#0
====
являются шаблонными функциями
====
====
являются шаблонными функциями
1
cout << myqueue.back() - myqueue.front(); }
7
====
====
++++
иначе cout << "0";
это функции, которые возвращают только истинные или ложные значения
====
это функции, которые возвращает объект
====
Определить функторы
++++
Определить функторы
4
====
Machine Translated by Google


++++
Как называется набор данных (контейнер), построенный по принципу LILO (последний ввод — последний вывод:
последний ввод — последний вывод)?
приоритет_очереди
====
Как называется набор данных (контейнер), построенный по принципу LIFO?
====
#очередь
====
это функции, которые возвращают только истинные или ложные значения
====
очередь
куча
дека
====
====
#куча
====
это функции, которые возвращает объект
====
дека
====
++++
приоритет_очереди
Machine Translated by Google


очередь
====
====
очередь
#куча
====
куча
====
дека
++++
приоритет_очереди
====
====
++++
Какой адаптер контейнера определяет только операции push_back, pop_back и pop_front?
дека
====
#priority_queue
====
Как называется набор данных (контейнер), построенный по принципу, что в качестве бринчи
выступает элемент с большим весом?
++++
Какие элементы адаптера расположены в контейнере в порядке убывания?
очередь
====
Machine Translated by Google


++++
отталкивать()
====
====
Проверяет, что предикат p не возвращает true для любого элемента в диапазоне [first, last).
#priority_queue
====
#поп.назад()
++++
====
Заданная функция f применяется к каждому элементу в диапазоне [первый, последний).
Покажите строку, где правильно указана функция удаления элемента из конца двойной очереди?
====
всплывающий хвост ()
++++
====
====
куча
Покажите строку, в которой правильно указана функция функции all_of в поле алгоритма
====
# Проверяет, возвращает ли предикат p значение true для всех элементов в диапазоне [first, last).
====
хвост ()
====
Проверяет, возвращает ли предикат p значение true хотя бы для одного элемента в диапазоне [first, last).
дека
====
Machine Translated by Google


Проверяет, что предикат p не возвращает true для любого элемента в диапазоне [first, last).
====
# Проверяет, возвращает ли предикат p значение true хотя бы для одного элемента в диапазоне [first, last).
Проверяет, возвращает ли предикат p значение true для всех элементов в диапазоне [first, last).
====
====
Проверяет, возвращает ли предикат p значение true хотя бы для одного элемента в диапазоне [first, last).
====
Проверяет, что предикат p не возвращает true для любого элемента в диапазоне [first, last).
Проверяет, возвращает ли предикат p значение true хотя бы для одного элемента в диапазоне [first, last).
====
====
Покажите строку, в которой правильно указана функция функции any_of в поле алгоритма
++++
# Проверяет, что предикат p не возвращает true ни для одного элемента в диапазоне [first, last).
Заданная функция f применяется к каждому элементу в диапазоне [первый, последний).
Покажите строку, в которой правильно указана функция none_of в поле алгоритма
====
====
Заданная функция f применяется к каждому элементу в диапазоне [первый, последний).
++++
Проверяет, возвращает ли предикат p значение true для всех элементов в диапазоне [first, last).
====
Покажите строку, в которой правильно указана функция функции for_each в поле алгоритма
====
====
Проверяет, возвращает ли предикат p значение true для всех элементов в диапазоне [first, last).
Machine Translated by Google


В поле алгоритма покажите строку, в которой правильно отображается функция count_if(InputIt first, InputIt last,
UnaryPredicate p).
====
#[first, last) возвращает количество элементов в диапазоне, значение которых равно значению.
====
Возвращает количество элементов в диапазоне [первый, последний) со значением, равным значению.
====
Возвращает количество элементов в диапазоне [first, last), которые возвращают true для предиката p.
====
Возвращает первую пару несопоставленных элементов в двух диапазонах, один из которых начинается с [first1, last1), а
другой начинается с first2.
====
====
====
#Данная функция f применяется к каждому элементу в диапазоне [first, last).
#[first, last) возвращает количество элементов в диапазоне, в котором предикат p возвращает значение true.
====
Возвращает первую пару несопоставленных элементов в двух диапазонах, один из которых начинается с [first1, last1), а
другой начинается с first2.
++++
Ищет в диапазоне [first, last) любые элементы в диапазоне [s_first, s_last].
====
Ищет в диапазоне [first, last) любые элементы в диапазоне [s_first, s_last].
Покажите строку, в которой правильно отображается функция count(InputIt first, InputIt last, const T &value) в поле алгоритма
++++
Machine Translated by Google


Возвращает количество элементов в диапазоне [первый, последний) со значением, равным значению.
====
Возвращает количество элементов в диапазоне [first, last), которые возвращают true для предиката p.
====
Возвращает количество элементов в диапазоне [first, last), которые возвращают true для предиката p.
====
# Возвращает первую пару несопоставленных элементов в двух диапазонах, один из которых начинается с [first1, last1), а
другой — с first2.
++++
Ищет в диапазоне [first, last) любые элементы в диапазоне [s_first, s_last].
====
====
++++
показать строку, в которой правильно указана функция несоответствия (InputIt1 first1, InputIt1 last1, InputIt2 first2) в поле
алгоритма
Возвращает первую пару несопоставленных элементов в двух диапазонах, один из которых начинается с [first1, last1), а
другой начинается с first2.
====
# Ищет в диапазоне [first, last) любые элементы в диапазоне [s_first, s_last].
====
показать строку, в которой правильно указана функция find_first_of(InputIt first, InputIt last,ForwardIt s_first, ForwardIt
s_last) в поле алгоритма
++++
показать строку, в которой правильно указана функция find(InputIt first, InputIt last, const T& value ) в поле алгоритма
Возвращает количество элементов в диапазоне [первый, последний) со значением, равным значению.
====
Machine Translated by Google


Предикат p в диапазоне [first, last) находит первый элемент, возвращающий значение true.
====
====
Предикат q в диапазоне [first, last) находит первый элемент, возвращающий false.
====
Предикат q в диапазоне [first, last) находит первый элемент, возвращающий false.
====
Элементы [s_first, s_last) ищут последнее вхождение последовательности [s_first, s_last] в диапазоне [first, last).
====
показать строку, в которой правильно отображается функция find_end(ForwardIt1 first, ForwardIt1 last,ForwardIt2 s_first,
ForwardIt2 s_last) в поле алгоритма
====
++++
====
# Находит первый элемент в диапазоне [first, last), значение которого равно value .
Элементы #[s_first, s_last) ищут последнее вхождение последовательности [s_first, s_last] в диапазоне [first, last).
++++
В поле алгоритма покажите строку, в которой правильно указана функция find_if(InputIt first, InputIt last, UnaryPredicate
p).
====
[first, last) находит первый элемент в диапазоне, значение которого равно значению.
====
[first, last) находит первый элемент в диапазоне, значение которого равно значению.
Предикат p в диапазоне [first, last) находит первый элемент, возвращающий значение true.
====
Machine Translated by Google


====
Элементы [s_first, s_last) ищут последнее вхождение последовательности [s_first, s_last] в диапазоне [first, last).
#[first, last) ищет два одинаковых соседних элемента в диапазоне.
++++
Элементы [s_first, s_last) ищут последнее вхождение последовательности [s_first, s_last] в диапазоне [first, last).
++++
В поле алгоритма покажите строку, в которой правильно указана функция find_if_not(InputIt first, InputIt last,UnaryPredicate
q).
====
#[first, last) находит первый элемент в диапазоне, в котором предикат p возвращает значение true.
====
Покажите строку в поле алгоритма, где функция смежных_находок (ForwardIt first, ForwardIt last) указана правильно.
[first, last) находит первый элемент в диапазоне, значение которого равно значению.
Предикат p в диапазоне [first, last) находит первый элемент, возвращающий значение true.
====
====
[first, last) находит первый элемент в диапазоне, значение которого равно значению.
====
Предикат q в диапазоне [first, last) находит первый элемент, возвращающий false.
====
Предикат p в диапазоне [first, last) находит первый элемент, возвращающий значение true.
====
====
#[first, last) находит первый элемент в диапазоне, где предикат q возвращает false.
Machine Translated by Google


Покажите строку в поле алгоритма, где правильно отображается функция copy_if(InputIt first,
InputIt last, OutputIt d_first, UnaryPredicate pred ).
====
#[first, last) копирует элементы диапазона в диапазон, начинающийся с d_first.
====
[first, last) копирует элементы диапазона в диапазон, начинающийся с d_first.
====
только предикат возвращает элементы, которые возвращают true.
====
[first, last) ищет два одинаковых соседних элемента в диапазоне.
====
====
====
Элементы [s_first, s_last) ищут последнее вхождение последовательности [s_first, s_last] в диапазоне [first,
last).
#только предикат pred копирует элементы, которые возвращают элементы, возвращающие true .
====
[first, last) ищет два одинаковых соседних элемента в диапазоне.
++++
[first, last) копирует диапазон, оканчивающийся на d_last Объекты копируются в обратном порядке,
но их относительный порядок сохраняется.
====
[first, last) копирует диапазон, оканчивающийся на d_last. Объекты перемещаются в обратном
порядке, но их относительный порядок сохраняется.
показать строку, в которой правильно указана функция копирования (InputIt first, InputIt last, OutputIt
d_first) в поле алгоритма
++++
Machine Translated by Google


====
[first, last) копирует элементы диапазона в диапазон, начинающийся с d_first.
Покажите строку в поле алгоритма, где правильно отображается функция move_backward( BidirIt1 first, BidirIt1
last, BidirIt2 d_last )
====
#Перемещает элементы из диапазона [first, last) в другой диапазон, начинающийся с d_first
====
только предикат возвращает элементы, которые возвращают true.
====
++++
====
Перемещает массив элементов в обратном порядке в новое место
[first, last) ищет два одинаковых соседних элемента в диапазоне.
#[first, last) копирует диапазон, оканчивающийся на d_last Объекты копируются в обратном порядке, но их
относительный порядок сохраняется.
алгоритм copy_backward (сначала BidirectionalIterator1, потом BidirectionalIterator1,
====
Присваивает определенное значение массиву элементов
====
Покажите строку, где правильно указана функция BidirectionalIterator2 d_last )
++++
Если count > 0 , присваивает указанное значение первым элементам count в диапазоне, начиная с d_first. В
противном случае он ничего не делает.
++++
====
Покажите строку в поле алгоритма, где правильно отображается функция перемещения (InputIt first, InputIt last,
OutputIt d_first).
Machine Translated by Google


Перемещает массив элементов в обратном порядке в новое место
====
====
Присваивает определенное значение массиву элементов
====
#Присваивает определенное значение массиву элементов
====
Если count > 0 , присваивает указанное значение первым элементам count в диапазоне, начиная с d_first. В
противном случае он ничего не делает.
====
покажите строку, в которой правильно указана функция функции fill( ForwardIt first, ForwardIt last, const T& value ) в
поле алгоритма
====
++++
====
Перемещает элементы из диапазона [first, last) в другой диапазон, начиная с d_first
Если count > 0 , присваивает указанное значение первым элементам count в диапазоне, начиная с d_first. В
противном случае он ничего не делает.
++++
Покажите строку в поле алгоритма, где правильно отображается функция fill_n (сначала OutputIt, Size count, const
T& value )
====
Перемещает элементы[first, last) из диапазона в другой диапазон, начиная с d_first
====
Перемещает элементы из диапазона [first, last) в другой диапазон, начиная с d_first
#Перемещает массив элементов в обратном порядке в новое место
====
Machine Translated by Google


value удаляет все элементы, равные значению, из диапазона [first, last).
#Если count> 0, присваивает указанное значение первым элементам count в диапазоне, начиная с d_first.
====
value удаляет все элементы, равные значению, из диапазона [first, last).
В противном случае он ничего не делает.
====
Предикат p удаляет из диапазона [первый, последний] все элементы, которые являются истинными.
++++
====
Окно алгоритма показывает строку, в которой функция generate (ForwardIt first, ForwardIt last, Generator g) отображается
правильно.
Перемещает массив элементов в обратном порядке в новое место
#[first, last) устанавливает для каждого элемента в диапазоне значение, сгенерированное данным объектом функции g
++++
====
====
====
Окно алгоритма показывает строку, в которой функция функции generate_n (сначала OutputIt, количество размеров,
генератор g) отображается правильно.
====
[first, last) устанавливает для каждого элемента в диапазоне значение, сгенерированное данным объектом функции g
Присваивает определенное значение массиву элементов
если count > 0, принимает значения, сгенерированные указанным объектом функции, начиная с первых элементов count в
диапазоне. В противном случае он ничего не делает.
====
#if count> 0, принимает значения, сгенерированные указанным объектом функции, начиная с первых элементов count в
диапазоне. В противном случае он ничего не делает.
====
====
Machine Translated by Google


====
[first, last) устанавливает для каждого элемента в диапазоне значение, сгенерированное данным объектом функции g
====
[first, last) устанавливает для каждого элемента в диапазоне значение, сгенерированное данным объектом функции g
====
если count > 0, принимает значения, сгенерированные указанным объектом функции, начиная с первых элементов count
в диапазоне. В противном случае он ничего не делает.
====
Предикат p удаляет из диапазона [первый, последний] все элементы, которые являются истинными.
====
если count > 0, принимает значения, сгенерированные указанным объектом функции, начиная с первых элементов count
в диапазоне. В противном случае он ничего не делает.
#value Удаляет все элементы, равные значению, из диапазона [первый, последний).
Предикат p удаляет из диапазона [первый, последний] все элементы, которые являются истинными.
++++
====
value удаляет все элементы, равные значению, из диапазона [first, last).
====
покажите строку, в которой функция удаления функции (ForwardIt first, ForwardIt last, const T& value) в поле алгоритма
отображается правильно
++++
# из диапазона [first, last) всех элементов, для которых предикат p истинен
удаляет
====
показать строку в поле алгоритма, где правильно указана функция remove_if(ForwardIt first, ForwardIt last, UnaryPredicate
p)
Machine Translated by Google


Предикат #p копирует элементы, кроме истинных, из диапазона [first, last) в диапазон,
начинающийся с d_first
====
Предикат p копирует элементы, кроме истинных, из диапазона [first, last) в диапазон, начинающийся
с d_first.
====
Копирует элементы из диапазона [first, last), кроме элементов, равных значению, в диапазон,
начинающийся с d_first
====
old_value заменяет все элементы в диапазоне [first, last) на new_value.
++++
Предикат p истинен и заменяет все элементы в диапазоне [first, last) на new_value.
====
====
++++
покажите строку, в которой правильно отображается функция remove_copy(InputIt first, InputIt
last, OutputIt d_first,const T& value ) в поле алгоритма
old_value заменяет все элементы в диапазоне [first, last) на new_value.
====
Предикат p истинен и заменяет все элементы в диапазоне [first, last) на new_value.
====
В поле алгоритма покажите строку, в которой правильно отображается функция remove_copy_if(InputIt
first, InputIt last, OutputIt d_first, UnaryPredicate p).
++++
# Копирует все элементы, кроме тех, которые равны значению value из диапазона [first, last) в
диапазон, начинающийся с d_first
====
Machine Translated by Google


====
Предикат p копирует элементы, кроме истинных, из диапазона [first, last) в диапазон, начинающийся
с d_first.
====
Предикат p копирует элементы, кроме истинных, из диапазона [first, last) в диапазон, начинающийся
с d_first.
====
# заменяет все элементы в диапазоне [первый, последний), равные old_value, на new_value.
====
показать строку, в которой корректно отображается функция замены (ForwardIt first, ForwardIt last, const
T& old_value, const T& new_value) в окне алгоритма
++++
old_value заменяет все элементы в диапазоне [first, last) на new_value.
Предикат p истинен и заменяет все элементы в диапазоне [first, last) на new_value.
показать строку, в которой правильно отображается функция replace_if(ForwardIt first,
ForwardIt last, UnaryPredicate p, const T& new_value) в поле алгоритма
====
====
Предикат #p = true заменяет все элементы в диапазоне [первый, последний) на новое_значение.
++++
Копирует элементы из диапазона [first, last), кроме элементов, равных значению, в диапазон,
начинающийся с d_first
====
поменять местами ( T& a, T& b ) бонус коробки алгоритма; Покажите строку, в которой функция функции указана правильно
====
====
Копирует элементы из диапазона [first, last), кроме элементов, равных значению, в диапазон,
начинающийся с d_first
Machine Translated by Google


====
Перестановка объектов с диапазоном [first1, last1] начинается с first2. Количество элементов в этих двух
диапазонах должно быть одинаковым.
поменять местами массивы a и b
====
Перестановка объектов с диапазоном [first1, last1] начинается с first2. Количество элементов в этих двух
диапазонах должно быть одинаковым.
====
Обменивает значения элементов, на которые указывают два итератора.
++++
# меняет местами значения a и b.
====
Обменивает значения элементов, на которые указывают два итератора.
Покажите строку, где правильно указана функция swap( T2 (&a)[N], T2 (&b)[N]) в поле алгоритма
меняет местами значения a и b.
====
++++
Окно алгоритма показывает строку, в которой правильно указана функция swap_ranges (ForwardIt1 first1,
ForwardIt1 last1, ForwardIt2 first2).
====
поменять местами массивы a и b.
====
меняет местами значения a и b.
====
====
# поменять местами массивы a и b
Machine Translated by Google


Перестановка объектов с диапазоном [first1, last1] начинается с first2. Количество элементов в этих двух диапазонах
должно быть одинаковым.
Обменивает значения элементов, на которые указывают два итератора.
[first, last) меняет местами элементы в диапазоне так, что n_first является первым, а n_first-1 — последним в новом диапазоне.
====
++++
====
#Меняет местами значения элементов, на которые указывают два итератора.
iter_swap в бонусной коробке алгоритма (ForwardIt1 a, ForwardIt2 b)
Все последовательно повторяющиеся элементы из диапазона [first, last).
Покажите строку, в которой функция функции указана правильно
====
меняет местами значения a и b.
++++
====
====
#Заменить объекты диапазоном [first1, last1].
обратный алгоритм в бонусе коробки ( BidirIt первый, BidirIt последний )
Покажите строку, в которой функция функции указана правильно
====
начинается с первого2. Количество элементов в этих двух диапазонах должно быть одинаковым.
поменять местами массивы a и b
# Обратный порядок элементов в диапазоне [first, last).
====
====
====
Machine Translated by Google


Объединяет два отсортированных диапазона [first1, last1) и [first2, last2], записывая элементы в новый диапазон,
начиная с d_first.
показать строку, в которой правильно показана функция поворота (ForwardIt first, ForwardIt n_first, ForwardIt last) в поле
алгоритма
#Все последовательно повторяющиеся элементы из диапазона [first, last).
====
++++
уникальный в алгоритме kutubonus( ForwardIt первый, ForwardIt последний)
Обратный порядок элементов в диапазоне [первый, последний).
====
удаляет и возвращает итератор от последнего элемента нового диапазона к следующему элементу.
====
Покажите строку, в которой функция функции указана правильно
#[first, last) меняет местами элементы в диапазоне так, чтобы n_first был первым, а n_first-1 — последним в новом
диапазоне.
Все последовательно повторяющиеся элементы из диапазона [first, last).
====
====
Обратный порядок элементов в диапазоне [первый, последний).
====
Объединяет два отсортированных диапазона [first1, last1) и [first2, last2], записывая элементы в новый диапазон,
начиная с d_first.
удаляет и возвращает итератор от последнего элемента нового диапазона к следующему элементу.
[first, last) меняет местами элементы в диапазоне так, что n_first является первым, а n_first-1 — последним в новом
диапазоне.
====
++++
====
Machine Translated by Google


====
показать строку, в которой правильно указана функция merge( InputIt1 first1, InputIt1 last1, InputIt2 first2,
InputIt2 last2, OutputIt d_first) в поле алгоритма
вычисляет симметричную разницу между двумя наборами
====
====
# объединяет два отсортированных диапазона [first1, last1) и [first2, last2], записывая элементы в новый диапазон,
начиная с d_first.
++++
Обратный порядок элементов в диапазоне [первый, последний).
====
удаляет и возвращает итератор от последнего элемента нового диапазона к следующему элементу.
тогда n_first будет первым в новом диапазоне, а n_first-1 будет последним.
Покажите строку, в которой правильно указана функция функции set_difference в поле алгоритма
[first, last) заменяет элементы в диапазоне,
====
====
====
#вычисляет разницу между двумя наборами
====
Объединяет два отсортированных диапазона [first1, last1) и [first2, last2], записывая элементы в новый диапазон,
начиная с d_first.
Все последовательно повторяющиеся элементы из диапазона [first, last).
вычисляет пересечение двух множеств
====
++++
удаляет и возвращает итератор от последнего элемента нового диапазона к следующему элементу.
Machine Translated by Google


====
вычисляет разницу между двумя наборами
Покажите строку, в которой правильно указана функция set_union в поле алгоритма
====
вычисляет разницу между двумя наборами
====
#вычисляет пересечение двух множеств
====
вычисляет объединение двух множеств
====
вычисляет пересечение двух множеств
вычисляет симметричную разницу между двумя наборами
вычисляет объединение двух множеств
++++
====
#вычисляет симметричную разницу между двумя наборами
====
Покажите строку, в которой правильно указана функция функции set_intersection в поле алгоритма
++++
вычисляет объединение двух множеств
++++
====
Покажите строку, в которой правильно отображается функция set_symmetric_difference в поле алгоритма.
Machine Translated by Google


возвращает наименьший элемент в диапазоне
====
====
#возвращает наименьший элемент в диапазоне
вычисляет симметричную разницу между двумя наборами
====
возвращает наименьший и наибольший элементы в диапазоне
====
====
возвращает наименьший и наибольший элементы в диапазоне
#вычисляет объединение двух множеств
====
Покажите строку, в которой правильно указана функция функции max_element в поле алгоритма
====
++++
====
вычисляет разницу между двумя наборами
два набора определяют, идентичны ли элементы
+++++
Покажите строку, в которой правильно указана функция функции min_element в поле алгоритма
====
# возвращает самый большой элемент в диапазоне
====
возвращает самый большой элемент в диапазоне
вычисляет пересечение двух множеств
====
Machine Translated by Google


Укажите строку, в которой правильно указана функция равной функции в поле алгоритма
====
++++
Покажите строку, в которой правильно указана функция функции накопления в поле алгоритма
возвращает самый большой элемент в диапазоне
====
возвращает самый большой элемент в диапазоне
====
возвращает наименьший элемент в диапазоне
====
#возвращает самый маленький и самый большой элементы в диапазоне
====
====
====
два набора определяют, идентичны ли элементы
возвращает наименьший элемент в диапазоне
====
возвращает наименьший и наибольший элементы в диапазоне
+++++
два набора определяют, идентичны ли элементы
====
#определяет, являются ли два набора элементов одинаковыми
Покажите строку, в которой функция функции minmax_element в поле алгоритма указана правильно
+++++
Machine Translated by Google


#вычисляет скалярное произведение элементов двух диапазонов
====
====
вычисляет скалярное произведение элементов двух диапазонов
вычисляет разницу между соседними элементами в диапазоне
====
вычисляет разницу между соседними элементами в диапазоне
====
====
#вычисляет различия между соседними элементами в диапазоне
вычисляет частичную сумму диапазона элементов
====
Покажите строку, в которой правильно указана функция функции inner_product в поле алгоритма
====
++++
====
#diapason вычисляет сумму элементов
вычисляет частичную сумму диапазона элементов
++++
Покажите строку в поле алгоритма, где правильно указана функция смежной_разности
====
диапазон вычисляет сумму элементов
====
диапазон вычисляет сумму элементов
вычисляет скалярное произведение элементов двух диапазонов
====
Machine Translated by Google


Какая функция ищет первое вхождение заданного значения в контейнере?
====
++++
Каковы средства ссылки на элементы контейнера?
диапазон вычисляет сумму элементов
====
#находить()
====
вычисляет скалярное произведение элементов двух диапазонов
====
вычисляет разницу между соседними элементами в диапазоне
====
====
====
вычисляет частичную сумму диапазона элементов
найти_если()
====
считать()
++++
Вычисляет частичную сумму диапазона #elements
====
count_if()
Покажите строку, в которой правильно указана функция функции partial_sum в поле алгоритма
++++
Machine Translated by Google


конец()
====
====
начинать()
список
====
iterator_begin()
====
====
операция ()
====
Какая функция возвращает итератор, указывающий на первый элемент контейнера (если контейнер содержит
какие-либо элементы)?
====
++++
====
#итератор
iterator_end()
++++
Какая функция возвращает итератор, указывающий на пробел после последнего элемента контейнера?
====
#начинать()
====
#конец()
вектор
====
Machine Translated by Google


++++
Какой оператор позволяет получить значение элемента, на который указывает итератор?
&iter
++++
====
Какое выражение позволяет вам продвигать итератор для доступа к следующему элементу?
====
#*итер
====
iterator_begin()
====
#++итер
++ нажать
-- толкать
====
====
* толкать
====
iterator_end()
====
-- толкать
====
++++
&iter
Machine Translated by Google


====
++ нажать
#итер – н
====
====
итер - н
====
* толкать
итер + н
====
====
Какое выражение позволяет вернуться к предыдущему элементу через итератор?
++++
итер += п
&iter
Какая функция возвращает итератор, который находится на n позиций раньше, чем итератор?
====
====
итер –= п
++++
#--итер
====
Какая функция возвращает итератор, который находится на n позиций позади итератора?
====
====
#итер + н
Machine Translated by Google


++++
Какая операция продвигает итератор на n позиций?
итер + н
++++
====
Какая операция перемещает итератор назад на n позиций?
====
#итер += п
====
итер += п
====
#iter –= n
итер - н
итер + н
====
====
итер - н
====
итер –= п
====
итер += п
====
++++
итер –= п
Machine Translated by Google


#Сортировать()
итер1 + итер2
valarray образец (12);
для (int i = 0; i < 13; ++i) sample[i] = i;
====
====
больше()
итер1 - итер1
valarray bar = sample[slice(2, 3, 4)];
cout << "срез (2, 3, 4):";
====
Какая операция возвращает количество позиций между итераторами ter1 и iter2?
++++
====
итер2 – итер2
Какая функция принимает вспомогательную функцию в качестве третьего параметра,
====
sort_if()
====
arr_sort()
#итер1 – итер2
так что мы можем сортировать так, как мы хотим?
++++
Что появится на экране после выполнения фрагмента программы
====
====
Machine Translated by Google


====
valarray data = sample[mygslice];
для (size_t n = 0; n < bar.size(); n++)
срез (2, 3, 4):
for (int i=0; i' '
срез (2, 3, 4): 10 6 2
====
=====
Что появится на экране после выполнения фрагмента программы
<< данные[i];
for (int i=0; i<14; ++i) sample[i]=i;
====
#gslice: 1 3 5 8 10 12
====
<< бар[н];
гсрез: 1 2 3 7 2 2
====
gslice mygslice (начало, valarray(длины,2), valarray(шаги,2));
cout << "gslice:";
' '
cout <<
++++
срез: 14
гсрез: 2 4 6 9 11 13
#срез(2, 3, 4): 2 6 10
valarray образец (14);
=====
====
срез (2, 3, 4): 2 3 4
size_t начало=1; длина size_t[]= {2,3}; size_t шагов[]= {7,2};
Machine Translated by Google


++++
cout << varr.size()<< endl;
====
Размер valarray: 6
=====
Что появится на экране после выполнения фрагмента программы
valarray varr = {-20, 40, -50, 60, 80, 0, 0};
#Размер valarray: 4
=====
Размер valarray: 4
====
++++
====
cout << "Размер valarray: ";
Размер valarray: 20 40 60 80
Размер valarray: 5
Что появится на экране после выполнения фрагмента программы
cout << varr.size()<< endl;
====
#Размер valarray: 7
valarray varr = {20, 40, 60, 80};
====
====
Размер valarray: 5
cout << "Размер valarray: ";
Размер valarray: 3
Machine Translated by Google


#valarray содержит = -10 -20 -30 -40
Что появится на экране после выполнения фрагмента программы
++++
====
cout << "valarray содержит =";
valarray varr = {10, 20, 30, 40, 50};
====
valarray содержит =4
for (auto i = begin(varr); i != end(varr); i++) {
valarray содержит =5
====
<< *я;
====
}
' '
#valarray содержит = 10 20 30 40 50
Что появится на экране после выполнения фрагмента программы
====
cout <<
++++
valarray varr = {-10, -20, -30, -40};
for (auto i = begin(varr); i != end(varr); i++) {
cout << "valarray содержит =";
valarray содержит = 5
====
====
<< *я;
valarray содержит = 50
}
====
cout <<
' '
valarray содержит = 10
Machine Translated by Google


====
cout << "Сумма valarray равна =
valarray содержит =3
====
<< varr.sum() << endl;
Что появится на экране после выполнения фрагмента программы
====
<< varr.sum() << endl;
====
# Сумма valarray = 15
++++
"
Сумма valarray = 1 2 3 4 5
Сумма valarray = 15 10 30 33 40
++++
Сумма valarray = 16
# Сумма valarray = 128
valarray varr = {1, 2, 3, 4, 5};
"
====
valarray varr = {15, 10, 30, 33, 40};
Сумма valarray = 129
Сумма valarray = 1 2 4 3 5
cout << "Сумма valarray равна =
Сумма valarray = 40 10 30 33 15
====
====
====
Что появится на экране после выполнения фрагмента программы
Machine Translated by Google


cout << "Координата X точки P:
====
+++++
====
Мнимая часть: 2
комплекс<двойной> мойкомплекс(10.0, 2.0);
Мнимая часть: 2
вернуть 0; }
cout << "Мнимая часть:
<< Рх << эндл;
Действительная часть: 10,0
Что появится на экране после запуска программы
====
<< реальный(мойкомплекс) << endl;
#определить х реальный()
<< Ру << эндл;
#Вещественная часть: 10
Что появится на экране после выполнения фрагмента программы
int main() { точка P(2.0, 3.0);
<< изображение (мой комплекс) << endl;
Мнимая часть: imag(mycomplex)
Реальная часть: 1
++++
cout << "Вещественная часть:
====
cout << "Координата Y точки P:
"
"
Мнимая часть: 2,0
typedef сложная <двойная> точка;
"
#определить изображение()
"
Реальная часть: реальная (mycomplex)
====
Machine Translated by Google


valarray varr = { 3, 2, 1, 4, 5 };
cout << sqrt(complex(-9, 0)) << endl;
Координата Y точки P: 3.0
====
Квадратный корень из -4 = (0, 2)
====
cout << "Квадратный корень из (-9, -0), is = ";
cout << sqrt(complex(-9, -0.0)) << endl;
Ошибка компиляции
++++
Что появится на экране после выполнения фрагмента программы
=====
#Координата X точки P равна: 2
Координата Y точки P: 3.0
=====
Координата X точки P: 4.0
++++
Координата Y точки P: 3
#Квадратный корень из -9 равен =(0, 3)
====
Квадратный корень из (-9, -0), = (0, -3)
====
Что появится на экране после выполнения фрагмента программы
====
ошибка компиляции
Координата X точки P: 2.0
cout << "Квадратный корень из -9 равен =";
Machine Translated by Google


Какая функция применяет манипуляции, указанные в ее аргументах, ко всем элементам valarray
одновременно и
valarray varr = {22, 24, 36, 42, 12};
# Наименьший элемент valarray = 1
Наименьший элемент valarray = 22
====
====
cout << "Наименьший элемент" << " valarray равен =
<< varr.min() << endl;
Наименьший элемент valarray =0
Наименьший элемент valarray =2
+++++
====
cout << "Наименьший элемент" << " valarray равен =
====
"
Наименьший элемент valarray =2
Наименьший элемент valarray =-2
<< varr.min() << endl;
====
# Наименьший элемент valarray = 12
====
"
++++
Наименьший элемент valarray =0
====
====
Что появится на экране после выполнения фрагмента программы
Machine Translated by Google


====
сумма ()
#кусочек()
====
====
применять()
====

Download 2.19 Mb.

Do'stlaringiz bilan baham:
  1   2




Ma'lumotlar bazasi mualliflik huquqi bilan himoyalangan ©fayllar.org 2024
ma'muriyatiga murojaat qiling