С++ вопросы : Вопрос 1 : 68

Всегда ли в С++ выполняется деструктор? Назовите ситуацию, когда деструктор может быть никогда не вызван?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Вопрос имеет отношение не совсем к С++, а к многопоточному программированию.
Вспомним как в С++ вызываются деструкторы:
1) явным образом - при вызове оператора delete;
2) неявным образом при выходе из блока в котором определена переменная, или при раскрутке стека и отработке исключения; 

Этот механизм может быть нарушен, если поток выполнения прерван извне (например функцией операционной системы "завершить поток" или "завершить процесс"). И если завершение процесса не особо критично (при этом все ресурсы освобождаются), то завершение потока без вызова деструкторов может привести к утечкам памяти, или ресурсов (например не разлоченные объекты синхронизации, которые могут привести к дедлокам). По этой причине в коде С++ настоятельно не рекомендуется пользоваться "сырым" API для работы с потоками, а использовать С++ библиотеки гарантирующие корректную очистку ресурсов, например Boost threads

Всегда ли в С++ выполняется деструктор? Назовите ситуацию, когда деструктор может быть никогда не вызван?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Вопрос имеет отношение не совсем к С++, а к многопоточному программированию.
Вспомним как в С++ вызываются деструкторы:
1) явным образом - при вызове оператора delete;
2) неявным образом при выходе из блока в котором определена переменная, или при раскрутке стека и отработке исключения; 

Этот механизм может быть нарушен, если поток выполнения прерван извне (например функцией операционной системы "завершить поток" или "завершить процесс"). И если завершение процесса не особо критично (при этом все ресурсы освобождаются), то завершение потока без вызова деструкторов может привести к утечкам памяти, или ресурсов (например не разлоченные объекты синхронизации, которые могут привести к дедлокам). По этой причине в коде С++ настоятельно не рекомендуется пользоваться "сырым" API для работы с потоками, а использовать С++ библиотеки гарантирующие корректную очистку ресурсов, например Boost threads

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

#include <iostream> 
#include <string> 
 
void print(int v) 
{ 
    std::cout << "int:" << v << std::endl; 
} 
 
void print(bool v) 
{ 
    std::cout << "bool:" << v << std::endl; 
} 
 
void print(std::string v) 
{ 
    std::cout << "std::string:" << v << std::endl; 
} 
 
int main() 
{ 
    print(1); 
    print(true); 
    print("Hello world"); 
} 

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

int:1 
bool:1 
bool:1 


В первых двух пунктах всё понятно, т.к. приведения типов нет.

Третий же пункт не такой очевидный. Согласно стандарту, выбор одной из перегруженных функций осуществляется по правилу "Более жизнеспособной функции" (англ. "Best viable function").

"Hello world" имеет тип const char* и приведение его к POD-типу bool целесообразней чем к типу std::string.

Подробней о выборе перегруженной функции: en.cppreference.com/.../overload_resolution

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

#include <iostream> 
#include <string> 
 
void print(int v) 
{ 
    std::cout << "int:" << v << std::endl; 
} 
 
void print(bool v) 
{ 
    std::cout << "bool:" << v << std::endl; 
} 
 
void print(std::string v) 
{ 
    std::cout << "std::string:" << v << std::endl; 
} 
 
int main() 
{ 
    print(1); 
    print(true); 
    print("Hello world"); 
} 

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

int:1 
bool:1 
bool:1 


В первых двух пунктах всё понятно, т.к. приведения типов нет.

Третий же пункт не такой очевидный. Согласно стандарту, выбор одной из перегруженных функций осуществляется по правилу "Более жизнеспособной функции" (англ. "Best viable function").

"Hello world" имеет тип const char* и приведение его к POD-типу bool целесообразней чем к типу std::string.

Подробней о выборе перегруженной функции: en.cppreference.com/.../overload_resolution

Есть ли разница между struct и class?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Разницы нет, кроме того что в struct модификаторы доступа по умолчанию public, в class private. Также отличается и наследование по умолчанию, у struct — public, у class — private.

Есть ли разница между struct и class?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Разницы нет, кроме того что в struct модификаторы доступа по умолчанию public, в class private. Также отличается и наследование по умолчанию, у struct — public, у class — private.

В чем отличие между сокрытием данных (data hiding) и инкапсуляцией данных (data encapsulation)?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

1. Инкапсуляция данных представляет собой процесс, в то время как сокрытие данных является одновременно процессом и техникой.
2. Они оба являются концепцией объектно-ориентированного программирования.
3. Данные в инкапсуляции рассматриваются как private или public, в то время как данные в сокрытии данных рассматриваются как private или non-accessible.
4. Инкапсуляция данных является одним из механизмов сокрытия данных.
5. Инкапсуляция данных состоит в консолидации данных связанных с конкретной сущностью в объект называемым класс.Это делается с целью скрытия данных и установления меньшей сложности в них. С другой стороны, сокрытие данных включает в себя также их защиту и безопасность.
6. В центре внимания инкапсуляции лежит объединение данных в капсулу (класс), в то время как сокрытие данных связано с ограничениями в плане доступа и использования.

В чем отличие между сокрытием данных (data hiding) и инкапсуляцией данных (data encapsulation)?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

1. Инкапсуляция данных представляет собой процесс, в то время как сокрытие данных является одновременно процессом и техникой.
2. Они оба являются концепцией объектно-ориентированного программирования.
3. Данные в инкапсуляции рассматриваются как private или public, в то время как данные в сокрытии данных рассматриваются как private или non-accessible.
4. Инкапсуляция данных является одним из механизмов сокрытия данных.
5. Инкапсуляция данных состоит в консолидации данных связанных с конкретной сущностью в объект называемым класс.Это делается с целью скрытия данных и установления меньшей сложности в них. С другой стороны, сокрытие данных включает в себя также их защиту и безопасность.
6. В центре внимания инкапсуляции лежит объединение данных в капсулу (класс), в то время как сокрытие данных связано с ограничениями в плане доступа и использования.

Какие подозрения вызывает std::map<const char*, const char*> ?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Ассоциативный контейнер std::map хранит свои элементы (пары ключ-значение) упорядоченными по ключу. В качестве критерия сравнения по-умолчанию используется операция < .

Однако для C-строк (т.е. для char*) операция < не даёт лексикографического упорядочивания т.к. в этом случае сравниваются не сами строки, а указатели на строки.

Из-за этого стандартные ассоциативные контейнеры, в которых в качестве типа ключа используется C-строка, будут работать неожиданно для многих пользователей.

Чтобы заставить их работать надлежащим образом, нужно передать контейнеру альтернативный вариант компаратора для сравнения C-строк. Это можно сделать через параметры шаблона, либо как аргумент конструктора.

Какие подозрения вызывает std::map<const char*, const char*> ?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Ассоциативный контейнер std::map хранит свои элементы (пары ключ-значение) упорядоченными по ключу. В качестве критерия сравнения по-умолчанию используется операция < .

Однако для C-строк (т.е. для char*) операция < не даёт лексикографического упорядочивания т.к. в этом случае сравниваются не сами строки, а указатели на строки.

Из-за этого стандартные ассоциативные контейнеры, в которых в качестве типа ключа используется C-строка, будут работать неожиданно для многих пользователей.

Чтобы заставить их работать надлежащим образом, нужно передать контейнеру альтернативный вариант компаратора для сравнения C-строк. Это можно сделать через параметры шаблона, либо как аргумент конструктора.

Чем отличается new от malloc?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

1. new бросает эксепшен в случае неудачи, malloc возвращает 0.
2. new вызывает конструктор класса и выделяет память либо просто вызывает конструктор (в случае placement new), malloc только выделяет память.
3. new нужен для работы с объектами, malloc для работы непосредственно с памятью.

Чем отличается new от malloc?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

1. new бросает эксепшен в случае неудачи, malloc возвращает 0.
2. new вызывает конструктор класса и выделяет память либо просто вызывает конструктор (в случае placement new), malloc только выделяет память.
3. new нужен для работы с объектами, malloc для работы непосредственно с памятью.

Для следующей функции:

std:: string ReturnStringValue() 
{ 
    return "string value"; 
} 

Привести аргументы за/против использования следующих сценариев работы:
1. std:: string& val = ReturnStringValue();
2. const std:: string& val = ReturnStringValue();

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Поскольку в обоих вариантах используется привязка временного объекта на стеке к ссылке во внешней области видимости, казалось бы, оба варианта некорректны.
Тем не менее, для C++ четко оговорено, что привязка временного объекта к ссылке на const в стеке - продлевает время жизни объекта на время существования данной ссылки. Таким образом:
1-й вариант приводит к чистой воды UB. 
2-й вариант - абсолютно корректен и безопасен.

Для следующей функции:

std:: string ReturnStringValue() 
{ 
    return "string value"; 
} 

Привести аргументы за/против использования следующих сценариев работы:
1. std:: string& val = ReturnStringValue();
2. const std:: string& val = ReturnStringValue();

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Поскольку в обоих вариантах используется привязка временного объекта на стеке к ссылке во внешней области видимости, казалось бы, оба варианта некорректны.
Тем не менее, для C++ четко оговорено, что привязка временного объекта к ссылке на const в стеке - продлевает время жизни объекта на время существования данной ссылки. Таким образом:
1-й вариант приводит к чистой воды UB. 
2-й вариант - абсолютно корректен и безопасен.

Какие существуют типы компоновки (linkage) имён в C++?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Говорят, что имена, которые можно использовать в единицах трансляции, отличных от той, где они определены, имеют внешнюю компоновку (external linkage).
Если же на имя можно ссылаться лишь в единице трансляции, где оно определено, то говорят, что имя имеет внутреннюю компоновку (internal linkage).

Какие существуют типы компоновки (linkage) имён в C++?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Говорят, что имена, которые можно использовать в единицах трансляции, отличных от той, где они определены, имеют внешнюю компоновку (external linkage).
Если же на имя можно ссылаться лишь в единице трансляции, где оно определено, то говорят, что имя имеет внутреннюю компоновку (internal linkage).

Перечислите и покажите в действии способы вывода на экран содержимого вектора(STL-vector).

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

1) С помощью итераторов потоков: istream_iterator - поток ввода, ostream_iterator - поток вывода.
2) С помощью функции copy
3) С помощью созданной функции printng + использование специального метода-функции for_each.
4) С помощью итератора на созданный вектор vector1.

Пример кода перечисленных способов:

#include<stdio.h> 
#include<stdlib.h> 
#include<iostream> 
#include<algorithm> 
#include<vector> 
using namespace std; 
  
typedef void(*pm)(int); 
typedef int INT; 
 
pm printng(int i) { 
    cout << "\n" << i << ";"; 
    return 0; 
} 
 
int main() {  
    vector<int> vector1; 
    ostream_iterator<int> output(cout," "); //stream of output 
    istream_iterator<int> input(cin); //stream of input 
    INT num; 
    while((num = *input) != 0) { 
        *output++ = num; 
        input++; 
        if (num % 2 ==0) 
            vector1.push_back(num); //vector consists of even numbers 
    } 
    cout << "\n using copy(vector1.rbegin(), vector1.rend(), " 
            << ostream_iterator<int>(cout,''\\n'')\n"; 
    copy(vector1.rbegin(), vector1.rend(),  
            ostream_iterator<int>(cout,"\n")); 
 
    cout << "using for_each\n"; 
    for_each(vector1.begin(), vector1.end(), printng); 
  
    vector<int>::iterator it = vector1.begin(); 
    m = 0; 
    while(it != vector1.end()) {    
        m++; 
        cout << "\n" << m << ")" << *it; 
        it++; 
    }        
    system("pause"); 
    return 0; 
}  

Перечислите и покажите в действии способы вывода на экран содержимого вектора(STL-vector).

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

1) С помощью итераторов потоков: istream_iterator - поток ввода, ostream_iterator - поток вывода.
2) С помощью функции copy
3) С помощью созданной функции printng + использование специального метода-функции for_each.
4) С помощью итератора на созданный вектор vector1.

Пример кода перечисленных способов:

#include<stdio.h> 
#include<stdlib.h> 
#include<iostream> 
#include<algorithm> 
#include<vector> 
using namespace std; 
  
typedef void(*pm)(int); 
typedef int INT; 
 
pm printng(int i) { 
    cout << "\n" << i << ";"; 
    return 0; 
} 
 
int main() {  
    vector<int> vector1; 
    ostream_iterator<int> output(cout," "); //stream of output 
    istream_iterator<int> input(cin); //stream of input 
    INT num; 
    while((num = *input) != 0) { 
        *output++ = num; 
        input++; 
        if (num % 2 ==0) 
            vector1.push_back(num); //vector consists of even numbers 
    } 
    cout << "\n using copy(vector1.rbegin(), vector1.rend(), " 
            << ostream_iterator<int>(cout,''\\n'')\n"; 
    copy(vector1.rbegin(), vector1.rend(),  
            ostream_iterator<int>(cout,"\n")); 
 
    cout << "using for_each\n"; 
    for_each(vector1.begin(), vector1.end(), printng); 
  
    vector<int>::iterator it = vector1.begin(); 
    m = 0; 
    while(it != vector1.end()) {    
        m++; 
        cout << "\n" << m << ")" << *it; 
        it++; 
    }        
    system("pause"); 
    return 0; 
}  

Создать контейнер, в который можно добавлять и удалять методы. Размер контейнера должен увеличиваться автоматически.

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

#include "stdafx.h" 
#include  
#include  
#include  
 
using namespace std; 
 
typedef int (*Func)(void *,int); 
 
// Описание класса контейнера методов 
class FuncContainer 
{ 
private: 
    Func *Funcs;        // Массив указателей на методы 
    int funcs_count;        // Количество методов 
 
public: 
    FuncContainer()         
    { 
        funcs_count = 0;         
        Funcs = (Func*) malloc(0 * sizeof(Func));     
    } 
 
    void AddMethod(void *func) 
    { 
        funcs_count++;     
        Funcs = (Func*) realloc(Funcs, funcs_count*sizeof(Func));             
        Funcs[funcs_count - 1] = (Func) func;     
    } 
    void DeleteMethod(int idx) 
    { 
        for(int i = idx; i < funcs_ount - 1; i++) 
        { 
            Funcs[i] = Funcs[i + 1];                 
        } 
        funcs_count--; 
        Funcs = (Func*) realloc(Funcs, funcs_count * sizeof(Func));         
    } 
 
    int InvokeMethod(int n, void *args, int args_count) 
    { 
        int i = 0;             
 
        i = (*Funcs[n])(args, args_count);     
        return i;             
    } 
 
    int GetFunctionsCount(void) 
    { 
        return funcs_count; 
    } 
}; 
 
int AvgFunc(void *args, int args_count) 
{ 
    int res = 0;             
    for(int i = 0; i < args_count; i++) 
    { 
        res += ((int*)args)[i];     
    } 
    res = res/args_count;         
 
    return res;                 
} 
 
int SumFunc(void *args, int args_count) 
{ 
    int res = 0;             
    for(int i=0; i < args_count; i++) 
    { 
        res += ((int*)args)[i];    // Считаем сумму аргументов 
    } 
 
    return res;                } 
 
// Главная функция программы 
int _tmain(int argc, _TCHAR* argv[]) 
{ 
    FuncContainer    container;    // Объект класса контейнера 
    int    values[]={ 1, 2, 3, 4, 5, 3 };    // Массив аргументов для методов 
 
    container.AddMethod(AvgFunc);            // Добавляем метод в контейнер 
    container.AddMethod(SumFunc);            // Добавляем метод в контейнер 
 
                // Выводим на экран массив аргументов 
    cout << "Arguments array is: { 1, 2, 3, 4, 5, 3}" << endl << endl; 
                // Выводим на экран результат вызова первого метода 
    cout << "Average value is: " << container.InvokeMethod(0,values,6) << endl; 
                // Выводим на экран результат вызова второго метода 
    cout << "Sum is: " << container.InvokeMethod(1,values,6) << endl; 
 
    cout << endl << "Press any key to quit..."; 
    getch();        // Ожидаем нажатия клавиши для выхода из программы 
 
    return 0; 
} 

Создать контейнер, в который можно добавлять и удалять методы. Размер контейнера должен увеличиваться автоматически.

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

#include "stdafx.h" 
#include  
#include  
#include  
 
using namespace std; 
 
typedef int (*Func)(void *,int); 
 
// Описание класса контейнера методов 
class FuncContainer 
{ 
private: 
    Func *Funcs;        // Массив указателей на методы 
    int funcs_count;        // Количество методов 
 
public: 
    FuncContainer()         
    { 
        funcs_count = 0;         
        Funcs = (Func*) malloc(0 * sizeof(Func));     
    } 
 
    void AddMethod(void *func) 
    { 
        funcs_count++;     
        Funcs = (Func*) realloc(Funcs, funcs_count*sizeof(Func));             
        Funcs[funcs_count - 1] = (Func) func;     
    } 
    void DeleteMethod(int idx) 
    { 
        for(int i = idx; i < funcs_ount - 1; i++) 
        { 
            Funcs[i] = Funcs[i + 1];                 
        } 
        funcs_count--; 
        Funcs = (Func*) realloc(Funcs, funcs_count * sizeof(Func));         
    } 
 
    int InvokeMethod(int n, void *args, int args_count) 
    { 
        int i = 0;             
 
        i = (*Funcs[n])(args, args_count);     
        return i;             
    } 
 
    int GetFunctionsCount(void) 
    { 
        return funcs_count; 
    } 
}; 
 
int AvgFunc(void *args, int args_count) 
{ 
    int res = 0;             
    for(int i = 0; i < args_count; i++) 
    { 
        res += ((int*)args)[i];     
    } 
    res = res/args_count;         
 
    return res;                 
} 
 
int SumFunc(void *args, int args_count) 
{ 
    int res = 0;             
    for(int i=0; i < args_count; i++) 
    { 
        res += ((int*)args)[i];    // Считаем сумму аргументов 
    } 
 
    return res;                } 
 
// Главная функция программы 
int _tmain(int argc, _TCHAR* argv[]) 
{ 
    FuncContainer    container;    // Объект класса контейнера 
    int    values[]={ 1, 2, 3, 4, 5, 3 };    // Массив аргументов для методов 
 
    container.AddMethod(AvgFunc);            // Добавляем метод в контейнер 
    container.AddMethod(SumFunc);            // Добавляем метод в контейнер 
 
                // Выводим на экран массив аргументов 
    cout << "Arguments array is: { 1, 2, 3, 4, 5, 3}" << endl << endl; 
                // Выводим на экран результат вызова первого метода 
    cout << "Average value is: " << container.InvokeMethod(0,values,6) << endl; 
                // Выводим на экран результат вызова второго метода 
    cout << "Sum is: " << container.InvokeMethod(1,values,6) << endl; 
 
    cout << endl << "Press any key to quit..."; 
    getch();        // Ожидаем нажатия клавиши для выхода из программы 
 
    return 0; 
} 

Зачем делать в базовом классе закрытыми копирующий конструктор и присваивание?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Зачастую это делается для того, чтобы исключить неявное копирование объекта (на стек, например). Причины могут быть разные -- или объект очень большой (тогда копировать - терять производительность), или объект содержит указатели на данные, выделенные с помощью new, которые в деструкторе удаляет (тогда, если объект неявно скопируется, то delete вызовется дважды для одного указателя).

Зачем делать в базовом классе закрытыми копирующий конструктор и присваивание?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Зачастую это делается для того, чтобы исключить неявное копирование объекта (на стек, например). Причины могут быть разные -- или объект очень большой (тогда копировать - терять производительность), или объект содержит указатели на данные, выделенные с помощью new, которые в деструкторе удаляет (тогда, если объект неявно скопируется, то delete вызовется дважды для одного указателя).

Для чего ключевое слово volatile?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Для указания компилятору, что доступ к переменной может осуществляться из мест, неподконтрольных ему. А как следствие, что работу с данной переменной не нужно подвергать разного рода оптимизациям.

volatile int i = 1; // Независимо от прочего кода, данная переменная не будет оптимизирована. 


Т.е. если volatile присутствует в каком-то условии, которое не меняется со временем, то компилятор может оптимизировать его, чтобы избежать ненужных проверок, при использовании volatile компилятор скорее всего не будет этого делать.

while (1)  
{ 
    if(i == 1) 
    { 
        // Какой-то код не изменяющий i 
    } 
} 
 
// Если бы volatile отсутствовало, то компилятор мог бы переделать код на что-то аля: 
if(i == 1) // Нет необходимости проверять i все время, если и так известно, что оно не изменяется 
{ 
    while (1)  
    { 
        // Какой-то код не изменяющий i 
    } 
} 

Для чего ключевое слово volatile?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Для указания компилятору, что доступ к переменной может осуществляться из мест, неподконтрольных ему. А как следствие, что работу с данной переменной не нужно подвергать разного рода оптимизациям.

volatile int i = 1; // Независимо от прочего кода, данная переменная не будет оптимизирована. 


Т.е. если volatile присутствует в каком-то условии, которое не меняется со временем, то компилятор может оптимизировать его, чтобы избежать ненужных проверок, при использовании volatile компилятор скорее всего не будет этого делать.

while (1)  
{ 
    if(i == 1) 
    { 
        // Какой-то код не изменяющий i 
    } 
} 
 
// Если бы volatile отсутствовало, то компилятор мог бы переделать код на что-то аля: 
if(i == 1) // Нет необходимости проверять i все время, если и так известно, что оно не изменяется 
{ 
    while (1)  
    { 
        // Какой-то код не изменяющий i 
    } 
} 

Для чего используются ключевые слова try, catch, throw в C++?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Ключевое слово throw служит для генерации исключений, try - для выделения фрагмента кода, в котором генерируется исключение, а catch - для обработки исключения из предыдущего фрагмента try. При этом блок catch следует сразу после try, а самих блоков catch может быть сколько угодно.
Пример:

int main() 
{ 
    try  
    { 
        int a; 
        cout<<"\nWhat is lesser than five?\n"; 
        cin>>a; 
        if (a>=5) throw a; 
    } 
    catch (int) 
    { 
        cout<<"\nWrong!\n"; 
        return 0; 
    } 
    cout<<"\nCorrect!\n"; 
    return 0; 
} 


Можно также использовать catch без аргумента:

catch(...) 
{/*Обработка любого исключения*/} 


Такой catch(...) советуется использовать последним в блоке обработок исключений.
Если будет сгенерировано исключение, которое не обрабатывается, программа вызовет функцию terminate(), которая вызывает abort(). При помощи set_terminate можно вызвать и другую функцию:

void ue_error() 
{cout<<"\nUnhandled exception!\n";} 
 
int main() 
{ 
    set_unexpected(ue_error); 
    throw 3; 
    return 0; 
} 


Вывод будет следующим:
Unhandled exception!

Обработка исключений позволяет избежать непредсказуемых и исключительных событий.

Для чего используются ключевые слова try, catch, throw в C++?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Ключевое слово throw служит для генерации исключений, try - для выделения фрагмента кода, в котором генерируется исключение, а catch - для обработки исключения из предыдущего фрагмента try. При этом блок catch следует сразу после try, а самих блоков catch может быть сколько угодно.
Пример:

int main() 
{ 
    try  
    { 
        int a; 
        cout<<"\nWhat is lesser than five?\n"; 
        cin>>a; 
        if (a>=5) throw a; 
    } 
    catch (int) 
    { 
        cout<<"\nWrong!\n"; 
        return 0; 
    } 
    cout<<"\nCorrect!\n"; 
    return 0; 
} 


Можно также использовать catch без аргумента:

catch(...) 
{/*Обработка любого исключения*/} 


Такой catch(...) советуется использовать последним в блоке обработок исключений.
Если будет сгенерировано исключение, которое не обрабатывается, программа вызовет функцию terminate(), которая вызывает abort(). При помощи set_terminate можно вызвать и другую функцию:

void ue_error() 
{cout<<"\nUnhandled exception!\n";} 
 
int main() 
{ 
    set_unexpected(ue_error); 
    throw 3; 
    return 0; 
} 


Вывод будет следующим:
Unhandled exception!

Обработка исключений позволяет избежать непредсказуемых и исключительных событий.

Опишите, какие виды наследования вы знаете и для чего они применяются.

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Пусть D унаследован от B. Виды: открытое, закрытое, защищённое, виртуальное. Во всех случаях класс D получает доступ к открытым и защищённым членам B. Отличия:
1. Открытое - Открытые члены B становятся открытыми в D. Защищённые B - защищёнными D. Говорят, что класс наследует как интерфейс, так и реализацию предка.
2. Закрытое - Открытые и защищённые члены B становятся закрытыми в D. Применяют когда класс должен наследовать только реализацию.
3. Защищённое - открытые и защищённые члены B становятся защищёнными в D.
4. Виртуальное. В объекте D компилятор заводит указатель, ссылающийся на объект B, входящий в состав D. В сложной иерархии наследования, когда B повторяется многократно в числе предков конечного класса, эти указатели будут ссылаться на один и тот же объект B. Получается экономия памяти. Виртуальное наследование может применяться вместе с предыдущими тремя.

Опишите, какие виды наследования вы знаете и для чего они применяются.

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Пусть D унаследован от B. Виды: открытое, закрытое, защищённое, виртуальное. Во всех случаях класс D получает доступ к открытым и защищённым членам B. Отличия:
1. Открытое - Открытые члены B становятся открытыми в D. Защищённые B - защищёнными D. Говорят, что класс наследует как интерфейс, так и реализацию предка.
2. Закрытое - Открытые и защищённые члены B становятся закрытыми в D. Применяют когда класс должен наследовать только реализацию.
3. Защищённое - открытые и защищённые члены B становятся защищёнными в D.
4. Виртуальное. В объекте D компилятор заводит указатель, ссылающийся на объект B, входящий в состав D. В сложной иерархии наследования, когда B повторяется многократно в числе предков конечного класса, эти указатели будут ссылаться на один и тот же объект B. Получается экономия памяти. Виртуальное наследование может применяться вместе с предыдущими тремя.

Каково назначение и возможности препроцессора в C++?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Назначение препроцессора - обработка исходного текста программы до ее компиляции. 

На стадии обработки директив препроцессора возможны следующие действия:
1. замена идентификаторов заранее подготовленными последовательностями символов;
#define идентификатор строка
Пример:
#define ABC 100
Заменяет каждое вхождение идентификатора ABC в тексте программы на 100:
#undef идентификатор
Пример:
#undef ABC
Отменяет предыдущее определение для идентификатора ABC.

2. включение в программу текстов из указанных файлов;
Командная строка #include может встречаться в любом месте программы, но обычно все включения размещаются в начале файла исходного текста.
#include <имя_файла>
Пример:
#include <math.h>
Процессор заменяет эту строку содержимым файла math.h. Угловые скобки означают, что файл math.h будет взят из некоторого стандартного каталога. Текущий каталог не просматривается.
#include "имя_файла"
Пример:
#include "ABC"
Препроцессор заменяет эту строку содержимым файла ABC. Так как имя файла заключено в кавычки, то поиск производится в текущем каталоге (в котором содержится основной файл исходного текста). Если в текущем каталоге данного файла нет, то поиск производится в каталогах, определенных именем пути в опции -1 препроцессора. Если и там нет файла, то просматривается стандартный каталог.

3. исключение из программы отдельных частей ее текста, условная компиляция;
Командные строки препроцессора используются для условной компиляции различных частей исходного текста в зависимости от внешних условий.
#if константное_выражение
Пример:
#if ABC + 3
Истина, если константное выражение ABC + 3 не равно нулю.
#ifdef идентификатор
Пример:
#ifdef ABC
истина, если идентификатор ABC определен ранее командой #define.
#ifndef идентификатор
Пример:
#ifndef ABC
истина, если идентификатор ABC не определен в настоящий момент.
#else
. . .
#endif

Если предшествующие проверки #if, #ifdef или #ifndef дают значение "Истина", то строки от #else до #endif игнорируются при компиляции.
Если эти проверки дают значение "Ложь", то строчки от проверки до #else (а при отсутствии #else - до #endif) игнорируются.
Команда #endif обозначает конец условной компиляции.
Пример:
#ifdef DEBUG
fprintf (stderr, "location: x = %d\n", x);
#endif

4. макроподстановка, то есть замена обозначения параметризованным текстом, формируемым препроцессором с учетом конкретных аргументов.
Пример:
#define abs(A) (((A) > 0)?(A) : -(A))
Каждое вхождение выражения abs(arg) в тексте программы заменяется на 
((arg) > 0) ? (arg) : -(arg),
причем параметр макроопределения А заменяется на arg.

Каково назначение и возможности препроцессора в C++?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Назначение препроцессора - обработка исходного текста программы до ее компиляции. 

На стадии обработки директив препроцессора возможны следующие действия:
1. замена идентификаторов заранее подготовленными последовательностями символов;
#define идентификатор строка
Пример:
#define ABC 100
Заменяет каждое вхождение идентификатора ABC в тексте программы на 100:
#undef идентификатор
Пример:
#undef ABC
Отменяет предыдущее определение для идентификатора ABC.

2. включение в программу текстов из указанных файлов;
Командная строка #include может встречаться в любом месте программы, но обычно все включения размещаются в начале файла исходного текста.
#include <имя_файла>
Пример:
#include <math.h>
Процессор заменяет эту строку содержимым файла math.h. Угловые скобки означают, что файл math.h будет взят из некоторого стандартного каталога. Текущий каталог не просматривается.
#include "имя_файла"
Пример:
#include "ABC"
Препроцессор заменяет эту строку содержимым файла ABC. Так как имя файла заключено в кавычки, то поиск производится в текущем каталоге (в котором содержится основной файл исходного текста). Если в текущем каталоге данного файла нет, то поиск производится в каталогах, определенных именем пути в опции -1 препроцессора. Если и там нет файла, то просматривается стандартный каталог.

3. исключение из программы отдельных частей ее текста, условная компиляция;
Командные строки препроцессора используются для условной компиляции различных частей исходного текста в зависимости от внешних условий.
#if константное_выражение
Пример:
#if ABC + 3
Истина, если константное выражение ABC + 3 не равно нулю.
#ifdef идентификатор
Пример:
#ifdef ABC
истина, если идентификатор ABC определен ранее командой #define.
#ifndef идентификатор
Пример:
#ifndef ABC
истина, если идентификатор ABC не определен в настоящий момент.
#else
. . .
#endif

Если предшествующие проверки #if, #ifdef или #ifndef дают значение "Истина", то строки от #else до #endif игнорируются при компиляции.
Если эти проверки дают значение "Ложь", то строчки от проверки до #else (а при отсутствии #else - до #endif) игнорируются.
Команда #endif обозначает конец условной компиляции.
Пример:
#ifdef DEBUG
fprintf (stderr, "location: x = %d\n", x);
#endif

4. макроподстановка, то есть замена обозначения параметризованным текстом, формируемым препроцессором с учетом конкретных аргументов.
Пример:
#define abs(A) (((A) > 0)?(A) : -(A))
Каждое вхождение выражения abs(arg) в тексте программы заменяется на 
((arg) > 0) ? (arg) : -(arg),
причем параметр макроопределения А заменяется на arg.

В чём заключается суть правила одного определения?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

"The one-definition rule" — ODR
Каждый класс, перечисление, шаблон и т.д. должны быть определены в программе ровно один раз.
Два определения класса, шаблона или встраиваемой функции принимаются за экземпляры одного и того же уникального определния тогда и только тогда, если:
1. Они находятся в разных единицах трансляции;
2. Они полексемно идентичны;
3. Смысл этих лексем одинаковый в обеих единицах трансляции.
Например:

//файл file1.c 
struct S {int a; char b;}; 
void f(S*); 
 
//файл file2.c 
struct S {int a; char b;}; 
void f(S* p) {/*...*/} 


Правило ODR говорит, что данный пример корректен, и что определения в обоих исходных файлах ссылаются на один и тот же класс (структуру).

В чём заключается суть правила одного определения?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

"The one-definition rule" — ODR
Каждый класс, перечисление, шаблон и т.д. должны быть определены в программе ровно один раз.
Два определения класса, шаблона или встраиваемой функции принимаются за экземпляры одного и того же уникального определния тогда и только тогда, если:
1. Они находятся в разных единицах трансляции;
2. Они полексемно идентичны;
3. Смысл этих лексем одинаковый в обеих единицах трансляции.
Например:

//файл file1.c 
struct S {int a; char b;}; 
void f(S*); 
 
//файл file2.c 
struct S {int a; char b;}; 
void f(S* p) {/*...*/} 


Правило ODR говорит, что данный пример корректен, и что определения в обоих исходных файлах ссылаются на один и тот же класс (структуру).

Какой объем памяти занимает объект пустого класса class Empty{ };? Почему?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

За одним исключением, в С++ размер всех объектов больше 0. Размер объекта пустого класса равен 1му байту. Это реализовано затем, чтобы адрес каждого объекта был отличным от адреса любого другого объекта.

Код для примера:

class Empty { }; 
 
    void f() 
    { 
        Empty a, b; 
        if (&a == &b) cout << "если данная строка выведена на экран, то есть ошибка в работе компилятора"; 
 
        Empty* p1 = new Empty; 
        Empty* p2 = new Empty; 
        if (p1 == p2) cout << "если данная строка выведена на экран, то есть ошибка в работе компилятора"; 
    }     


Собственно, исключение: размер пустого базового класса в классе-наследнике может быть (и скорее всего будет) равен 0.

struct X : Empty { 
        int i; 
        // ... 
    }; 
 
    void f(X* p) 
    { 
        void* p1 = p; 
        void* p2 = &p->i; 
        if (p1 == p2) cout << оптимизация пустого базового класса сработала"; 
    } 
 

Какой объем памяти занимает объект пустого класса class Empty{ };? Почему?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

За одним исключением, в С++ размер всех объектов больше 0. Размер объекта пустого класса равен 1му байту. Это реализовано затем, чтобы адрес каждого объекта был отличным от адреса любого другого объекта.

Код для примера:

class Empty { }; 
 
    void f() 
    { 
        Empty a, b; 
        if (&a == &b) cout << "если данная строка выведена на экран, то есть ошибка в работе компилятора"; 
 
        Empty* p1 = new Empty; 
        Empty* p2 = new Empty; 
        if (p1 == p2) cout << "если данная строка выведена на экран, то есть ошибка в работе компилятора"; 
    }     


Собственно, исключение: размер пустого базового класса в классе-наследнике может быть (и скорее всего будет) равен 0.

struct X : Empty { 
        int i; 
        // ... 
    }; 
 
    void f(X* p) 
    { 
        void* p1 = p; 
        void* p2 = &p->i; 
        if (p1 == p2) cout << оптимизация пустого базового класса сработала"; 
    } 
 

Какие функции по умолчанию генерирует компилятор для классов в C++?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Компилятор C++ по умолчанию генерирует следующие функции:

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

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

3. оператор присваивания (assignment operator)

4. деструктор (destructor)

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

Какие функции по умолчанию генерирует компилятор для классов в C++?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Компилятор C++ по умолчанию генерирует следующие функции:

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

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

3. оператор присваивания (assignment operator)

4. деструктор (destructor)

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

Зачем используется вызов throw без аргументов?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Для повторного возбуждения предыдущего исключения и направления его следующему обработчику.

try 
{ 
    //.... 
    try 
    { 
        // Call something 
    } 
    catch(const std::exception& ) 
    { 
        // Make/Check something.. 
        throw; // Пересылаем исключение следующему обработчику 
    } 
    //... 
} 
catch(const std::exception& e) 
{ 
    std::cout << e.what() << std::endl; 
} 

Зачем используется вызов throw без аргументов?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Для повторного возбуждения предыдущего исключения и направления его следующему обработчику.

try 
{ 
    //.... 
    try 
    { 
        // Call something 
    } 
    catch(const std::exception& ) 
    { 
        // Make/Check something.. 
        throw; // Пересылаем исключение следующему обработчику 
    } 
    //... 
} 
catch(const std::exception& e) 
{ 
    std::cout << e.what() << std::endl; 
} 

Какой из двух способов обхода вектора быстрее( при полной оптимизации ) 
1)

std::vector<int> v; 
for(size_t i = 0; i < v.size(); ++i) 
    v[i] = get_value(); 

2)

std::vector<int> v; 
for(std::vector<int>::iterator it = v.begin();  
        it != v.end(); ++it) 
    *it = get_value(); 

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Второй способ быстрее.
При полной оптимизации итератор превращается в обычный указатель, и доступ к нему - обычная операция разыменования. В первом же случае на каждой итерации происходит прибавление к базе значения (i * sizeof( int )).

Какой из двух способов обхода вектора быстрее( при полной оптимизации ) 
1)

std::vector<int> v; 
for(size_t i = 0; i < v.size(); ++i) 
    v[i] = get_value(); 

2)

std::vector<int> v; 
for(std::vector<int>::iterator it = v.begin();  
        it != v.end(); ++it) 
    *it = get_value(); 

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Второй способ быстрее.
При полной оптимизации итератор превращается в обычный указатель, и доступ к нему - обычная операция разыменования. В первом же случае на каждой итерации происходит прибавление к базе значения (i * sizeof( int )).

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

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Например, у нас есть класс:

class A 
{ 
public: 
    A() 
    { 
        cout << "A() "; 
    } 
    void f() 
    { 
        cout << "Hello "; 
    } 
    ~A() 
    { 
        cout << "~A() "; 
    } 
}; 


вызвать метод f () можно таким способом

A *p = (A*)12; 
p->f() 


или

( (A *) 12 ) -> f(); 


в результате на экран будет выведено


Hello
вместо 
A() Hello ~A()


Почему так возможно? Да потому, что физически функция f() существует в области кода, в "неймспейсе" класса A, тоесть когда мы пишем такое

A a; 
a.f(); 


реально компилятор делает чтото на подобии этого:

A::f(&a) 


то есть существование єкземпляра класса не обязательное, можна вместо &a передать любой адрес(число)

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

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Например, у нас есть класс:

class A 
{ 
public: 
    A() 
    { 
        cout << "A() "; 
    } 
    void f() 
    { 
        cout << "Hello "; 
    } 
    ~A() 
    { 
        cout << "~A() "; 
    } 
}; 


вызвать метод f () можно таким способом

A *p = (A*)12; 
p->f() 


или

( (A *) 12 ) -> f(); 


в результате на экран будет выведено


Hello
вместо 
A() Hello ~A()


Почему так возможно? Да потому, что физически функция f() существует в области кода, в "неймспейсе" класса A, тоесть когда мы пишем такое

A a; 
a.f(); 


реально компилятор делает чтото на подобии этого:

A::f(&a) 


то есть существование єкземпляра класса не обязательное, можна вместо &a передать любой адрес(число)

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

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Макрос состоит из процедурной директивы #define (определить), собственно выражения и выражения, на которое должно быть заменено предыдущие. К примеру, чтобы не писать постоянное «аккуратное» взятие размера, можно создать такой макрос:
#define sz(x) (int) (x.size())

Как вы могли заметить, даже такой простой макрос является довольно «длинным». Макрос же для арифметического выражения (к примеру, поднесения в третью степень) будет выглядеть вот так:

#define cube(x) (x) * (x) * (x)

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

#define cube(x) x*x*x

А потому, что программа просто подставит то, что будет у вас в коде на месте x в выражении cube(x) в выражение справа (x*x*x)

При вызове cube(2) все в порядке: 2*2*2 = 8.
Если же вызвать cube(2 + 3), а скобки не поставить, результат будет отличным от ожидаемого, после подстановки 2 + 3 вместо х получим: 2 + 3 * 2 + 3 * 2 + 3 = 17, а вовсе не 125.

Если же макрос написан с использованием скобок для каждого «объекта подстановки» все будет именно так, как мы хотим: (2 + 3) * (2 + 3) * (2 + 3) = 125

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

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Макрос состоит из процедурной директивы #define (определить), собственно выражения и выражения, на которое должно быть заменено предыдущие. К примеру, чтобы не писать постоянное «аккуратное» взятие размера, можно создать такой макрос:
#define sz(x) (int) (x.size())

Как вы могли заметить, даже такой простой макрос является довольно «длинным». Макрос же для арифметического выражения (к примеру, поднесения в третью степень) будет выглядеть вот так:

#define cube(x) (x) * (x) * (x)

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

#define cube(x) x*x*x

А потому, что программа просто подставит то, что будет у вас в коде на месте x в выражении cube(x) в выражение справа (x*x*x)

При вызове cube(2) все в порядке: 2*2*2 = 8.
Если же вызвать cube(2 + 3), а скобки не поставить, результат будет отличным от ожидаемого, после подстановки 2 + 3 вместо х получим: 2 + 3 * 2 + 3 * 2 + 3 = 17, а вовсе не 125.

Если же макрос написан с использованием скобок для каждого «объекта подстановки» все будет именно так, как мы хотим: (2 + 3) * (2 + 3) * (2 + 3) = 125

Что происходит здесь:

int* foo() 
{ 
    int x=2; 
    return &x; 
}

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Локальные переменные, созданные на стеке, уничтожаются при выходе из области видимости (в данном случае это выход из функции), таким образом, память получает статус свободный и туда могут записаться какие-либо данные, либо, если это еще не успело произойти, там будет по прежнему находиться 2. Но указатель валидный и указывает на тот участок памяти, где, на момент обращения, могут быть записаны абсолютно любые данные.

Что происходит здесь:

int* foo() 
{ 
    int x=2; 
    return &x; 
}

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Локальные переменные, созданные на стеке, уничтожаются при выходе из области видимости (в данном случае это выход из функции), таким образом, память получает статус свободный и туда могут записаться какие-либо данные, либо, если это еще не успело произойти, там будет по прежнему находиться 2. Но указатель валидный и указывает на тот участок памяти, где, на момент обращения, могут быть записаны абсолютно любые данные.

Что из себя представляет итератор потока в STL? Назовите его виды, подвиды.

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Важную роль в STL играют итераторы потоков, которые делятся на итераторы потоков ввода и вывода. Практически итератор потока вывода используется для отображения данных на экране. Суть применения потоковых итераторов в том, что они превращают любой поток в итератор, используемый точно так же, как и прочие итераторы: перемещаясь по цепочке данных, считывает значения объектов и присваивает им другие значения. (Действуют по системе шаблона - подставляют("определяют") переменные в определенную конструкцию).

Итератор потока ввода — это удобный программный интерфейс, обеспечивающий доступ к любому потоку, из которого требуется считать данные. Конструктор итератора имеет единственный параметр — поток ввода. А поскольку итератор потока ввода представляет собой шаблон, то ему передается тип вводимых данных. Вообще-то должно передаваться четыре типа, но последние три имеют значения по умолчанию, и вряд ли вы решитесь их изменять прежде, чем досконально изучите STL. Каждый раз, когда нужно ввести очередной элемент информации, используйте оператор ++ точно так же, как с основными итераторами. Считанные данные можно узнать, если применить разыменовывание (*).

Итератор потока вывода весьма схож с итератором потока ввода, но у его конструктора имеется дополнительный параметр, которым указывают строку-разделитель, добавляемую в поток после каждого выведенного элемента. Ниже приведен пример программы, читающей из стандартного потока cin числа, вводимые пользователем и дублирующие их на экране, завершая сообщение строкой “ — new data“. Работа программы заканчивается, как только пользователь введет число 33:

#include <algorithm> 
#include <iostream> 
#include <vector> 
 
using namespace std; 
 
int main() { 
    istream_iterator<int> is (cin); 
    ostream_iterator<int> os  (cout, " — new data"); 
 
    int input; 
 
    while  ((input = *is) != 33) { 
        *os++ = input; 
        is++ ; 
    } 
} 


Потоковые итераторы имеют одно существенное ограничение — в них нельзя возвратиться к предыдущему элементу. Единственный способ сделать это - заново создать итератор потока.

Что из себя представляет итератор потока в STL? Назовите его виды, подвиды.

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Важную роль в STL играют итераторы потоков, которые делятся на итераторы потоков ввода и вывода. Практически итератор потока вывода используется для отображения данных на экране. Суть применения потоковых итераторов в том, что они превращают любой поток в итератор, используемый точно так же, как и прочие итераторы: перемещаясь по цепочке данных, считывает значения объектов и присваивает им другие значения. (Действуют по системе шаблона - подставляют("определяют") переменные в определенную конструкцию).

Итератор потока ввода — это удобный программный интерфейс, обеспечивающий доступ к любому потоку, из которого требуется считать данные. Конструктор итератора имеет единственный параметр — поток ввода. А поскольку итератор потока ввода представляет собой шаблон, то ему передается тип вводимых данных. Вообще-то должно передаваться четыре типа, но последние три имеют значения по умолчанию, и вряд ли вы решитесь их изменять прежде, чем досконально изучите STL. Каждый раз, когда нужно ввести очередной элемент информации, используйте оператор ++ точно так же, как с основными итераторами. Считанные данные можно узнать, если применить разыменовывание (*).

Итератор потока вывода весьма схож с итератором потока ввода, но у его конструктора имеется дополнительный параметр, которым указывают строку-разделитель, добавляемую в поток после каждого выведенного элемента. Ниже приведен пример программы, читающей из стандартного потока cin числа, вводимые пользователем и дублирующие их на экране, завершая сообщение строкой “ — new data“. Работа программы заканчивается, как только пользователь введет число 33:

#include <algorithm> 
#include <iostream> 
#include <vector> 
 
using namespace std; 
 
int main() { 
    istream_iterator<int> is (cin); 
    ostream_iterator<int> os  (cout, " — new data"); 
 
    int input; 
 
    while  ((input = *is) != 33) { 
        *os++ = input; 
        is++ ; 
    } 
} 


Потоковые итераторы имеют одно существенное ограничение — в них нельзя возвратиться к предыдущему элементу. Единственный способ сделать это - заново создать итератор потока.

В чем основное различие между деструктором и оператором delete?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Оператор delete освобождает область памяти зарезервированную ранее с помощью оператора new. При этом для объектов автоматически будет вызван деструктор.

Деструктор содержит код, который необходимо выполнить до освобождения памяти, например, освобождение системных ресурсов и т.д.

Вызов деструктора вручную не приводит к освобождению памяти, занимаемой объектом.

В чем основное различие между деструктором и оператором delete?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Оператор delete освобождает область памяти зарезервированную ранее с помощью оператора new. При этом для объектов автоматически будет вызван деструктор.

Деструктор содержит код, который необходимо выполнить до освобождения памяти, например, освобождение системных ресурсов и т.д.

Вызов деструктора вручную не приводит к освобождению памяти, занимаемой объектом.

В чем отличия макросов от встраиваемых функций?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

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

#define max(aa, bb) (aa>bb?aa:bb) 
 
int main() 
{ 
int a = 0; 
int b = 1; 
 
int c = max(a++, b++); 
cout << a << endl << b << endl << c << endl; 
}

В консоли будет: 13, потому что макрос развернется в следующее выражение

int c = a++ > b++ ? a++ : b++; 


(b увеличится 2 раза)

2. Макросы разворачивает предпроцессор, тело встроенной функции вставляет в место вызова компилятор. 

3. Встроенные функции более безопасны в плане типов передаваемых аргументов, т.к. это проверяется еще на этапе компиляции. Макросы могут получить в качестве аргумента (-ов) значения совершенно неподходящего типа (при этом ошибки предпроцессора не будет и компиляция пройдет успешно), что может вызвать undefined behavoir, макрос может вернуть некорректный результат или могут произойти другие нежелательные, но не всегда очевидные последствия.

4. Макросы [i]всегда[/i] разворачиваются предпроцессором, в том время как компилятор делает функцию с inline директивой встроенной в зависимости от своей внутренней логики.

5. Встраиваемые функции всегда передают аргументы по значению. Если аргумент - выражение, то перед передачей оно всегда вычисляется и передается уже результат этого выражения. Функция func(3 + 5) передаст в качестве аргумента 5, в то время как макросы не всегда производят вычисления выражений в качестве аргументов.

#define square(x) x*x 
... 
int y =  square(2+3) 


Будет заменено на int y = 2 + 3*2 + 3

6. Встраиваемые функции учитывают пространство имен, в то время как макросы не различают границ пространства имен, они доступны везде. Макросы не могут определяться внутри класса (т.е. принадлежать ему), встраиваемые функции - могут.

В чем отличия макросов от встраиваемых функций?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

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

#define max(aa, bb) (aa>bb?aa:bb) 
 
int main() 
{ 
int a = 0; 
int b = 1; 
 
int c = max(a++, b++); 
cout << a << endl << b << endl << c << endl; 
}

В консоли будет: 13, потому что макрос развернется в следующее выражение

int c = a++ > b++ ? a++ : b++; 


(b увеличится 2 раза)

2. Макросы разворачивает предпроцессор, тело встроенной функции вставляет в место вызова компилятор. 

3. Встроенные функции более безопасны в плане типов передаваемых аргументов, т.к. это проверяется еще на этапе компиляции. Макросы могут получить в качестве аргумента (-ов) значения совершенно неподходящего типа (при этом ошибки предпроцессора не будет и компиляция пройдет успешно), что может вызвать undefined behavoir, макрос может вернуть некорректный результат или могут произойти другие нежелательные, но не всегда очевидные последствия.

4. Макросы [i]всегда[/i] разворачиваются предпроцессором, в том время как компилятор делает функцию с inline директивой встроенной в зависимости от своей внутренней логики.

5. Встраиваемые функции всегда передают аргументы по значению. Если аргумент - выражение, то перед передачей оно всегда вычисляется и передается уже результат этого выражения. Функция func(3 + 5) передаст в качестве аргумента 5, в то время как макросы не всегда производят вычисления выражений в качестве аргументов.

#define square(x) x*x 
... 
int y =  square(2+3) 


Будет заменено на int y = 2 + 3*2 + 3

6. Встраиваемые функции учитывают пространство имен, в то время как макросы не различают границ пространства имен, они доступны везде. Макросы не могут определяться внутри класса (т.е. принадлежать ему), встраиваемые функции - могут.

Существует ли синтаксически корректный способ доступа снаружи к закрытому свойству класса? Если да, то приведите пример.

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Способ основан на том факте, что исследуемый класс имеет шаблонный метод в открытом доступе и заключается в простой специализации функции, из которой и производится доступ к закрытому свойству класса:



class VeryPrivateClass {
    int protectedVar;
public:
    VeryPrivateClass() {};

    template
    int someFeature()
    {
        // Do useful work and return value
        return 1;
    }

};

class A;

template<>
int VeryPrivateClass::someFeature()
{
    // Change the private variable outside the class
    protectedVar = -1;
}

int main()
{
    VeryPrivateClass c1;
    c1.someFeature();
}

Существует ли синтаксически корректный способ доступа снаружи к закрытому свойству класса? Если да, то приведите пример.

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Способ основан на том факте, что исследуемый класс имеет шаблонный метод в открытом доступе и заключается в простой специализации функции, из которой и производится доступ к закрытому свойству класса:



class VeryPrivateClass {
    int protectedVar;
public:
    VeryPrivateClass() {};

    template
    int someFeature()
    {
        // Do useful work and return value
        return 1;
    }

};

class A;

template<>
int VeryPrivateClass::someFeature()
{
    // Change the private variable outside the class
    protectedVar = -1;
}

int main()
{
    VeryPrivateClass c1;
    c1.someFeature();
}

Как запретить наследование от класса в C++, не пряча при этом конструкторы и деструктор в приватную секцию?
При этом программист должен видеть ошибку времени компиляции.

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Для этого в С++ используется виртуальный замок (virtual lock):

class Lock
{
    friend class Foo;
    Lock() { }
    Lock(const Lock&) { }
};

class Foo: virtual private Lock
{

};

class Bar: public Foo
{

};

int main()
{
    Foo foo;
    Bar bar;
    return 0;
}

При виртуально наследовании класс последний в иерархии ответственен за вызов конструктора класса, от которого пошло виртуальное наследование. В данном примере Lock имеет приватный конструктор, который доступен только классу Foo

Как запретить наследование от класса в C++, не пряча при этом конструкторы и деструктор в приватную секцию?
При этом программист должен видеть ошибку времени компиляции.

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Для этого в С++ используется виртуальный замок (virtual lock):

class Lock
{
    friend class Foo;
    Lock() { }
    Lock(const Lock&) { }
};

class Foo: virtual private Lock
{

};

class Bar: public Foo
{

};

int main()
{
    Foo foo;
    Bar bar;
    return 0;
}

При виртуально наследовании класс последний в иерархии ответственен за вызов конструктора класса, от которого пошло виртуальное наследование. В данном примере Lock имеет приватный конструктор, который доступен только классу Foo

Перечислите слабые и сильные стороны функции sprintf, а также перечислите ее альтернативы.

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Sprintf(char* buf,format,int chislo); используется для преобразования целого числа в удобочитаемое строковое представление(можно сказать-является аналогом char *itoa(value,string,radix), которая возвращает указатель на преобразованную строку).

Положительные стороны: работа без динамического выделения памяти, возвращает количество записанных-преобразованных символов, удобно использовать, если преобразованные данные необходимо использовать несколько раз.

Недостатки: скорость действия, в некоторых случаях переполнение буфера, как вариант можно найти альтернативную замену:

1) snprintf(buf,buflen,format,chislo); (небольшой "+" наличие длины буфера-buflen);

2) как вариант можно использовать std::strstream следующим образом("-" достаточно громоздко):

ostrstream temp(buf,buflen); 
temp<<setw(int)<<chislo<<ends; 
//setw-для форматного вывода программы, например setw(4)... 


3) lexical_cast - предназначен для конвертирования данных из 1-го типа в другой(больше всего нравится по удобству):
Сразу пример использования:

string& s; 
int i; 
s = lexical_cast<string>(i); 


Маленький вывод: у каждого метода есть свои недостатки(быстродействие, удобство, семантика, рациональное-нерациональное использование памяти...) и свои плюсы, поэтому использование того или иного метода зависит только от Вашего выбора. Необходимо лишь отметить, что лучше все же искать альтернативу (замену sprintf) и использовать данную функцию реже (так как любое нерационально использование данных может привести к переполнению буфера, а неверно указанный формат приведет к ошибке - поиск которой может затянуться на неопределенный промежуток времени).

Перечислите слабые и сильные стороны функции sprintf, а также перечислите ее альтернативы.

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Sprintf(char* buf,format,int chislo); используется для преобразования целого числа в удобочитаемое строковое представление(можно сказать-является аналогом char *itoa(value,string,radix), которая возвращает указатель на преобразованную строку).

Положительные стороны: работа без динамического выделения памяти, возвращает количество записанных-преобразованных символов, удобно использовать, если преобразованные данные необходимо использовать несколько раз.

Недостатки: скорость действия, в некоторых случаях переполнение буфера, как вариант можно найти альтернативную замену:

1) snprintf(buf,buflen,format,chislo); (небольшой "+" наличие длины буфера-buflen);

2) как вариант можно использовать std::strstream следующим образом("-" достаточно громоздко):

ostrstream temp(buf,buflen); 
temp<<setw(int)<<chislo<<ends; 
//setw-для форматного вывода программы, например setw(4)... 


3) lexical_cast - предназначен для конвертирования данных из 1-го типа в другой(больше всего нравится по удобству):
Сразу пример использования:

string& s; 
int i; 
s = lexical_cast<string>(i); 


Маленький вывод: у каждого метода есть свои недостатки(быстродействие, удобство, семантика, рациональное-нерациональное использование памяти...) и свои плюсы, поэтому использование того или иного метода зависит только от Вашего выбора. Необходимо лишь отметить, что лучше все же искать альтернативу (замену sprintf) и использовать данную функцию реже (так как любое нерационально использование данных может привести к переполнению буфера, а неверно указанный формат приведет к ошибке - поиск которой может затянуться на неопределенный промежуток времени).

Для каких целей применяется ключевое слово const в C++?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

1. Позволяет задать константность объекта
2. Позволяет задать константность указателя
3. Позволяет указать, что данный метод не модифицирует члены класса, т.е. сохраняет состояние объекта

Пример 1. Не можем изменить значение объекта:

const int i = 1; 
i = 2; // error C3892: 'i' : you cannot assign to a variable that is const 


Пример 2. Не можем изменить указатель на объект:

int i = 1; 
int* const j(&i); 
int k = 2; 
*j = k; // Ok 
j = &k; // error C3892: 'j' : you cannot assign to a variable that is const 


Пример 3. Не можем изменить члены класса:

class Foo 
{ 
private: 
    int i; 
public: 
    void func() const 
    { 
        i = 1; // error C3490: 'i' cannot be modified  
               //because it is being accessed through a const object 
    } 
}; 


Дополнение: константный метод может изменять члены класса, если они объявлены как mutable.

Для каких целей применяется ключевое слово const в C++?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

1. Позволяет задать константность объекта
2. Позволяет задать константность указателя
3. Позволяет указать, что данный метод не модифицирует члены класса, т.е. сохраняет состояние объекта

Пример 1. Не можем изменить значение объекта:

const int i = 1; 
i = 2; // error C3892: 'i' : you cannot assign to a variable that is const 


Пример 2. Не можем изменить указатель на объект:

int i = 1; 
int* const j(&i); 
int k = 2; 
*j = k; // Ok 
j = &k; // error C3892: 'j' : you cannot assign to a variable that is const 


Пример 3. Не можем изменить члены класса:

class Foo 
{ 
private: 
    int i; 
public: 
    void func() const 
    { 
        i = 1; // error C3490: 'i' cannot be modified  
               //because it is being accessed through a const object 
    } 
}; 


Дополнение: константный метод может изменять члены класса, если они объявлены как mutable.

Назовите все отличия ссылки от указателя. В чем преимущество использования ссылок? В чем ограничения ссылок?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Ссылки
-должны быть инициализированы в момент объявления;
-не могут быть null;
-инвариантны (не могут быть переприсвоены);
-всегда ссылаются на действительное значение переменной;
и в силу всего вышесказанного, являются более безопасными в использовании, т.к. защищают от многих ошибок программирования связанными с указателями (например попытка обращения по адресу, содержащему мусор в памяти) 

Ограничения:
-ссылки нельзя использовать в контейнерах STL (не удовлетворяют требованию копироваться по значению)

Назовите все отличия ссылки от указателя. В чем преимущество использования ссылок? В чем ограничения ссылок?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Ссылки
-должны быть инициализированы в момент объявления;
-не могут быть null;
-инвариантны (не могут быть переприсвоены);
-всегда ссылаются на действительное значение переменной;
и в силу всего вышесказанного, являются более безопасными в использовании, т.к. защищают от многих ошибок программирования связанными с указателями (например попытка обращения по адресу, содержащему мусор в памяти) 

Ограничения:
-ссылки нельзя использовать в контейнерах STL (не удовлетворяют требованию копироваться по значению)

Опишите общую идею полиморфизма.

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Полиморфизм - это техника, позволяющая одному и тому же фрагменту кода оперировать разными типами входных данных. В С++ существуют следующие типы полиморфизма:

переопределение методов (наследование)

параметрический полиморфизм (шаблоны)

Опишите общую идею полиморфизма.

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Полиморфизм - это техника, позволяющая одному и тому же фрагменту кода оперировать разными типами входных данных. В С++ существуют следующие типы полиморфизма:

переопределение методов (наследование)

параметрический полиморфизм (шаблоны)

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

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Виртуальный деструктор в базовом классе необходим для корректного удаления памяти объекта наследника через указатель на базовый класс. Если деструктор в базовом классе объявлен как виртуальный, то при удалении объекта наследника через указатель на базовый класс вызовется сначала деструктор наследника, а потом деструктор базового класса. Иначе, вызовется деструктор только базового класса.

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

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Виртуальный деструктор в базовом классе необходим для корректного удаления памяти объекта наследника через указатель на базовый класс. Если деструктор в базовом классе объявлен как виртуальный, то при удалении объекта наследника через указатель на базовый класс вызовется сначала деструктор наследника, а потом деструктор базового класса. Иначе, вызовется деструктор только базового класса.

Что стоит помнить при использовании исключений в конструкторе объекта?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Если исключение не обработано, то c логической точки зрения разрушается объект, который еще не создан, а с технической, так как он еще не создан, то и деструктор этого объекта не будет вызван. Пример:

class Base 
{ 
private:  
    HANDLE m_hFile; 
 
public: 
    Base() 
    { 
        std::cout << "Hello from Base()" << std::endl; 
        m_hFile = ::CreateFileA(...); 
        // Вызываем код, который в ходе своего выполнения бросает исключение 
        SomeLib.SomeFunc(...); 
    } 
 
    virtual ~Base() 
    { 
        std::cout << "Hello from ~Base()" << std::endl; 
        // Здесь мы планировали закрыть хэндл 
        ::CloseHandle(m_hFile); 
    } 
}; 
 
try 
{ 
    Base b; 
} 
catch(const std::exception &e) 
{ 
    std::cout << "Exception message: " << e.what() << std::endl; 
} 


Output:
Hello from Base() 
Exception message: Something failed 
Я немного модифицировал предыдущий пример, чтобы проблема была наглядней. Здесь объект m_hFile (если был открыт) утечет т.к. до CloseHandle() выполнение не дойдет. Т.е. имеем такие же проблемы как в первом примере: возможная утечка ресурсов или другие проблемы из-за нарушения логики работы класса. 
Здесь могут спросить: «Как бы вы поступили при подобной ситуации». Правильный ответ: «Воспользовался бы умными указателями». Простой пример умного указателя:

class Base 
{ 
private:  
    class CHandle 
    { 
    public: 
        ~CHandle() 
        { 
            ::CloseHandle(m_handle); 
        } 
    private: 
        HANDLE m_handle; 
    public: 
        // Для полноценного smart pointer'а перегрузки одной операции 
        // не достаточно, но для нашего примера и понимания вполне хватит 
        void operator = (const HANDLE &handle) 
        { 
            m_handle = handle; 
        } 
    }; 
 
    CHandle m_hFile; 
 
public: 
    Base() 
    { 
        std::cout << "Hello from Base()" << std::endl; 
        m_hFile = ::CreateFileA(...); 
        // Вызываем код, который в ходе своего выполнения бросает исключение 
        SomeLib.SomeFunc(...); 
    } 
 
    virtual ~Base() 
    { 
        std::cout << "Hello from ~Base()" << std::endl; 
    } 
... 


Теперь и без вызова деструктора Base хэндл будет закрыт, т.к. при уничтожении класса Base будет уничтожен объект m_hFile класса CHandle, в деструкторе которого и будет закрыт хэндл. 
Изобретать велосипед, конечно, не надо, все уже написано до нас, это пример который можно написать на бумажке при соответствующем вопросе. А так есть boost, Loki, ATL и т.п., где это уже реализовано.

Что стоит помнить при использовании исключений в конструкторе объекта?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Если исключение не обработано, то c логической точки зрения разрушается объект, который еще не создан, а с технической, так как он еще не создан, то и деструктор этого объекта не будет вызван. Пример:

class Base 
{ 
private:  
    HANDLE m_hFile; 
 
public: 
    Base() 
    { 
        std::cout << "Hello from Base()" << std::endl; 
        m_hFile = ::CreateFileA(...); 
        // Вызываем код, который в ходе своего выполнения бросает исключение 
        SomeLib.SomeFunc(...); 
    } 
 
    virtual ~Base() 
    { 
        std::cout << "Hello from ~Base()" << std::endl; 
        // Здесь мы планировали закрыть хэндл 
        ::CloseHandle(m_hFile); 
    } 
}; 
 
try 
{ 
    Base b; 
} 
catch(const std::exception &e) 
{ 
    std::cout << "Exception message: " << e.what() << std::endl; 
} 


Output:
Hello from Base() 
Exception message: Something failed 
Я немного модифицировал предыдущий пример, чтобы проблема была наглядней. Здесь объект m_hFile (если был открыт) утечет т.к. до CloseHandle() выполнение не дойдет. Т.е. имеем такие же проблемы как в первом примере: возможная утечка ресурсов или другие проблемы из-за нарушения логики работы класса. 
Здесь могут спросить: «Как бы вы поступили при подобной ситуации». Правильный ответ: «Воспользовался бы умными указателями». Простой пример умного указателя:

class Base 
{ 
private:  
    class CHandle 
    { 
    public: 
        ~CHandle() 
        { 
            ::CloseHandle(m_handle); 
        } 
    private: 
        HANDLE m_handle; 
    public: 
        // Для полноценного smart pointer'а перегрузки одной операции 
        // не достаточно, но для нашего примера и понимания вполне хватит 
        void operator = (const HANDLE &handle) 
        { 
            m_handle = handle; 
        } 
    }; 
 
    CHandle m_hFile; 
 
public: 
    Base() 
    { 
        std::cout << "Hello from Base()" << std::endl; 
        m_hFile = ::CreateFileA(...); 
        // Вызываем код, который в ходе своего выполнения бросает исключение 
        SomeLib.SomeFunc(...); 
    } 
 
    virtual ~Base() 
    { 
        std::cout << "Hello from ~Base()" << std::endl; 
    } 
... 


Теперь и без вызова деструктора Base хэндл будет закрыт, т.к. при уничтожении класса Base будет уничтожен объект m_hFile класса CHandle, в деструкторе которого и будет закрыт хэндл. 
Изобретать велосипед, конечно, не надо, все уже написано до нас, это пример который можно написать на бумажке при соответствующем вопросе. А так есть boost, Loki, ATL и т.п., где это уже реализовано.

В чём суть и особенности неименованных пространств имён?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Целью создания неименованных пространств имён является не предоставление интерфейса к пользовательскому коду, а просто локализация имён:

#include "header.h" 
namespace 
{ 
    int a; 
    void f() {/*...*/} 
    int g() {/*...*/} 
} 


Доступ к членам неименованного пространства имён осуществляется в локальном контексте без квалификации, так что предыдущее объявление эквивалентно следующему:

namespace $$$ 
{ 
    int a; 
    void f() {/*...*/} 
    int g() {/*...*/} 
} 
using namespace $$$; 


Плюс соответствующая директива using, а $$$ — некоторое уникальное для текущей области видимости имя.
Неименованные пространства имён в разных единицах компиляции разные по определению, так что, как и задумано, невозможно обратиться к члену неименованного пространства имён из другой единицы компиляции.

В чём суть и особенности неименованных пространств имён?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Целью создания неименованных пространств имён является не предоставление интерфейса к пользовательскому коду, а просто локализация имён:

#include "header.h" 
namespace 
{ 
    int a; 
    void f() {/*...*/} 
    int g() {/*...*/} 
} 


Доступ к членам неименованного пространства имён осуществляется в локальном контексте без квалификации, так что предыдущее объявление эквивалентно следующему:

namespace $$$ 
{ 
    int a; 
    void f() {/*...*/} 
    int g() {/*...*/} 
} 
using namespace $$$; 


Плюс соответствующая директива using, а $$$ — некоторое уникальное для текущей области видимости имя.
Неименованные пространства имён в разных единицах компиляции разные по определению, так что, как и задумано, невозможно обратиться к члену неименованного пространства имён из другой единицы компиляции.

Что такое "умные" указатели, чем они отличаются от обычных? Зачем они нужны? Какие реализации вам известны?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Как правило шаблонный класс, имитирующий интерфейс обычного указателя и добавляющий некую новую функциональность, например проверку границ при доступе или очистку памяти.
Обычные указатели по сравнению с умными имеют ряд недостатков:

1, Указатель не управляет временем жизни объекта, ответственность за удаление объекта целиком лежит на программисте. Проще говоря, указатель не «владеет» объектом.

2, Указатели, ссылающиеся на один и тот же объект, никак не связаны между собой. Это создаёт проблему «битых» указателей – указателей, ссылающихся на освобождённые или перемещенные объекты.

3, Нет никакой возможности проверить, указывает ли указатель на корректные данные, либо «в никуда».

4, Указатель на единичный объект и указатель на массив объектов никак не отличаются друг от друга.

Из этих недостатков вытекает преимущество использования умных указателей.

Бывают нескольких видов, например
Простые владеющие указатели, которые при присвоении нового значения или удалении сами удаляют объект.
Еще пример - Указатели с подсчётом ссылок
Различные реализации доступны в stl и boost.
std::auto_ptr<> 
std::tr1::shared_ptr<> 
std::tr1::weak_ptr<> 
boost::intrusive_ptr<> 
boost::scoped_ptr<> 
boost::scoped_array<>, boost::shared_array<> 

Что такое "умные" указатели, чем они отличаются от обычных? Зачем они нужны? Какие реализации вам известны?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Как правило шаблонный класс, имитирующий интерфейс обычного указателя и добавляющий некую новую функциональность, например проверку границ при доступе или очистку памяти.
Обычные указатели по сравнению с умными имеют ряд недостатков:

1, Указатель не управляет временем жизни объекта, ответственность за удаление объекта целиком лежит на программисте. Проще говоря, указатель не «владеет» объектом.

2, Указатели, ссылающиеся на один и тот же объект, никак не связаны между собой. Это создаёт проблему «битых» указателей – указателей, ссылающихся на освобождённые или перемещенные объекты.

3, Нет никакой возможности проверить, указывает ли указатель на корректные данные, либо «в никуда».

4, Указатель на единичный объект и указатель на массив объектов никак не отличаются друг от друга.

Из этих недостатков вытекает преимущество использования умных указателей.

Бывают нескольких видов, например
Простые владеющие указатели, которые при присвоении нового значения или удалении сами удаляют объект.
Еще пример - Указатели с подсчётом ссылок
Различные реализации доступны в stl и boost.
std::auto_ptr<> 
std::tr1::shared_ptr<> 
std::tr1::weak_ptr<> 
boost::intrusive_ptr<> 
boost::scoped_ptr<> 
boost::scoped_array<>, boost::shared_array<> 

Дана функция F(A, B, C, D)
Укажите отличия между __stdcall, __cdecl, __fastcall, __thiscall.

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

__stdcall - прямой порядок расположения данных на стеке, обратный по времени способ запихивания, стек очищает функция, поэтому число параметров фиксировано:


  push D
  push C
  push B
  push A
  call F
  ; ret 16 ; очистка стека - в функции


__cdecl - - прямой порядок расположения данных на стеке, обратный по времени способ запихивания, допускает переменное число параметров, поскольку стек очищает тот, кто вызвал функцию:


  push D
  push C
  push B
  push A
  call F
  ; ret
  inc esp, 16  ; очистка стека здесь


_fastcall: ; аналогично stdcall, но два первых параметра передаются через регистры:


  push D
  push C
  mov edx, B
  mov eax, A
  call F
  ; ret 8 ; очистка стека - в функции


__thiscall - прямой порядок расположения данных на стеке, параметр this передается в регистре., аргументы удаляются вызывающей стороной.

Дана функция F(A, B, C, D)
Укажите отличия между __stdcall, __cdecl, __fastcall, __thiscall.

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

__stdcall - прямой порядок расположения данных на стеке, обратный по времени способ запихивания, стек очищает функция, поэтому число параметров фиксировано:


  push D
  push C
  push B
  push A
  call F
  ; ret 16 ; очистка стека - в функции


__cdecl - - прямой порядок расположения данных на стеке, обратный по времени способ запихивания, допускает переменное число параметров, поскольку стек очищает тот, кто вызвал функцию:


  push D
  push C
  push B
  push A
  call F
  ; ret
  inc esp, 16  ; очистка стека здесь


_fastcall: ; аналогично stdcall, но два первых параметра передаются через регистры:


  push D
  push C
  mov edx, B
  mov eax, A
  call F
  ; ret 8 ; очистка стека - в функции


__thiscall - прямой порядок расположения данных на стеке, параметр this передается в регистре., аргументы удаляются вызывающей стороной.

Укажите все возможные способы передачи в функцию f целочисленного аргумента:

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

0. void f(const int a);
1. void f(int a);
2. void f(int* a);
3. void f(int& a);
4. void f(const int* a);
5. void f(const int& a);

Укажите все возможные способы передачи в функцию f целочисленного аргумента:

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

0. void f(const int a);
1. void f(int a);
2. void f(int* a);
3. void f(int& a);
4. void f(const int* a);
5. void f(const int& a);

Дано:
- Heap отсутствует.
- Запрещены new и delete, естественно.

Необходимо реализовать "динамический" контейнер простых объектов(т.е. не требующих deep copy). 
Достаточно функций add и getAt.

Контейнер должен быть cross-platform.
Все внутренние проверки можно пропустить, требуется продемонстрировать идею.
Размер контейнера должен передаваться в в него при создании.

Продемонстрируйте использование.

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

// Implementation. Header file. 
template <typename Elem, size_t SIZE> 
class Pool 
{ 
public: 
 
    // 
    Pool() 
        : sizeArr(0) 
    { 
    }; 
 
    // 
    size_t size() 
    { 
        return sizeArr; 
    } 
     
    // 
    bool add(Elem const& elem) 
    { 
        if ((sizeArr + 1) < SIZE) 
        { 
            arr[sizeArr] = elem; 
            ++sizeArr; 
            return true; 
        } 
 
        return false; 
    } 
     
    // 
    Elem& getAt(int idx) 
    { 
        return arr[idx]; 
    } 
 
private: 
    size_t sizeArr; 
    Elem arr[SIZE]; 
}; 
 
 
// Element for pool. 
class PoolElem 
{ 
public: 
 
    // 
    PoolElem() 
        : valueVal(0) 
    { 
    } 
 
    // 
    PoolElem(int val) 
        : valueVal(val) 
    { 
    } 
 
    // 
    int value() 
    { 
        return valueVal; 
    } 
 
private: 
    int valueVal; 
}; 
 
// Using. CPP file. 
 
void poolTest() 
{ 
    const size_t SIZE = 10; 
    Pool<PoolElem, SIZE> pool; 
 
    pool.add(PoolElem(10)); 
    pool.add(PoolElem(15)); 
    pool.add(PoolElem(20)); 
    // Show content.                          
    std::cout << "POOL" << std::endl; 
    for (size_t i = 0; i < pool.size(); ++i) 
    { 
        std::cout << pool.getAt(i).value() << std::endl; 
    } 
} 

Дано:
- Heap отсутствует.
- Запрещены new и delete, естественно.

Необходимо реализовать "динамический" контейнер простых объектов(т.е. не требующих deep copy). 
Достаточно функций add и getAt.

Контейнер должен быть cross-platform.
Все внутренние проверки можно пропустить, требуется продемонстрировать идею.
Размер контейнера должен передаваться в в него при создании.

Продемонстрируйте использование.

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

// Implementation. Header file. 
template <typename Elem, size_t SIZE> 
class Pool 
{ 
public: 
 
    // 
    Pool() 
        : sizeArr(0) 
    { 
    }; 
 
    // 
    size_t size() 
    { 
        return sizeArr; 
    } 
     
    // 
    bool add(Elem const& elem) 
    { 
        if ((sizeArr + 1) < SIZE) 
        { 
            arr[sizeArr] = elem; 
            ++sizeArr; 
            return true; 
        } 
 
        return false; 
    } 
     
    // 
    Elem& getAt(int idx) 
    { 
        return arr[idx]; 
    } 
 
private: 
    size_t sizeArr; 
    Elem arr[SIZE]; 
}; 
 
 
// Element for pool. 
class PoolElem 
{ 
public: 
 
    // 
    PoolElem() 
        : valueVal(0) 
    { 
    } 
 
    // 
    PoolElem(int val) 
        : valueVal(val) 
    { 
    } 
 
    // 
    int value() 
    { 
        return valueVal; 
    } 
 
private: 
    int valueVal; 
}; 
 
// Using. CPP file. 
 
void poolTest() 
{ 
    const size_t SIZE = 10; 
    Pool<PoolElem, SIZE> pool; 
 
    pool.add(PoolElem(10)); 
    pool.add(PoolElem(15)); 
    pool.add(PoolElem(20)); 
    // Show content.                          
    std::cout << "POOL" << std::endl; 
    for (size_t i = 0; i < pool.size(); ++i) 
    { 
        std::cout << pool.getAt(i).value() << std::endl; 
    } 
} 

Как вызвать функцию с помощью указателя в C++?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Указатель, полученный с помощью операции взятия адреса функции, можно впоследствии использовать для вызова функции.
Например:

void MyFunc ( char* pStr) 
{ 
  //... 
} 
 
void ( *pMyFunc ) ( char* ); // указатель на функцию 
 
void F() 
{ 
    // pMyFunc инициализирован адресом функции MyFunc 
    pMyFunc = &MyFunc;    
    // вызов MyFunc через указатель pMyFunc 
    ( *pMyFunc ) ( "Hello World!" );  
} 


Для вызова функции с помощью указателя (pMyFunc в данном примере) надо вначале применить операцию косвенности к указателю - *pMyFunc.
Поскольку приоритет операции вызова () выше, чем приоритет косвенности *, нельзя писать просто *pMyFunc( "Hello World!" ). 
Это будет означать *( pMyFunc( "Hello World!") ), что является ошибкой

Как вызвать функцию с помощью указателя в C++?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Указатель, полученный с помощью операции взятия адреса функции, можно впоследствии использовать для вызова функции.
Например:

void MyFunc ( char* pStr) 
{ 
  //... 
} 
 
void ( *pMyFunc ) ( char* ); // указатель на функцию 
 
void F() 
{ 
    // pMyFunc инициализирован адресом функции MyFunc 
    pMyFunc = &MyFunc;    
    // вызов MyFunc через указатель pMyFunc 
    ( *pMyFunc ) ( "Hello World!" );  
} 


Для вызова функции с помощью указателя (pMyFunc в данном примере) надо вначале применить операцию косвенности к указателю - *pMyFunc.
Поскольку приоритет операции вызова () выше, чем приоритет косвенности *, нельзя писать просто *pMyFunc( "Hello World!" ). 
Это будет означать *( pMyFunc( "Hello World!") ), что является ошибкой

В чем разница, и что будет, если:
1)

int *x = new int(2);  
delete x;

2)

int *x = new int(2);  
delete []x;

3)

int *x = new int[2];  
delete x;

4)

int *x = new int[2];  
delete []x;

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Для каждой из версий new либо new[] следует вызывать соответствующую версию delete / delete[]. В первом случае все верно, для new вызывается delete. Во втором и третьем результат не определен по стандарту. В четвертом все верно, для new[] вызывается delete[]

В чем разница, и что будет, если:
1)

int *x = new int(2);  
delete x;

2)

int *x = new int(2);  
delete []x;

3)

int *x = new int[2];  
delete x;

4)

int *x = new int[2];  
delete []x;

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Для каждой из версий new либо new[] следует вызывать соответствующую версию delete / delete[]. В первом случае все верно, для new вызывается delete. Во втором и третьем результат не определен по стандарту. В четвертом все верно, для new[] вызывается delete[]

Что более эффективно ++i или i++?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

++i иногда быстрее и никогда не медленнее, чем i++
Для встроенных типов вроде int, это не имеет значения: ++i и i++ имеют одинаковую скорость. Для классов вроде итераторов, которые перегружают ++, оператор ++i вполне возможно выполниться быстрее, чем i++, за счет того, что последний может создать копию this. (Это обусловлено тем, что при ++i объект возвращается по ссылке, а при i++ - по значению)
Тем не менее в реальных приложениях разница не ощущается, но с другой стороны программисту ничего не стоит напечатать ++i вместо i++.
Разумеется это нужно делать не всегда, а только тогда, если это не противоречит семантике выражения, например i++ выступает как одиночный оператор.

Что более эффективно ++i или i++?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

++i иногда быстрее и никогда не медленнее, чем i++
Для встроенных типов вроде int, это не имеет значения: ++i и i++ имеют одинаковую скорость. Для классов вроде итераторов, которые перегружают ++, оператор ++i вполне возможно выполниться быстрее, чем i++, за счет того, что последний может создать копию this. (Это обусловлено тем, что при ++i объект возвращается по ссылке, а при i++ - по значению)
Тем не менее в реальных приложениях разница не ощущается, но с другой стороны программисту ничего не стоит напечатать ++i вместо i++.
Разумеется это нужно делать не всегда, а только тогда, если это не противоречит семантике выражения, например i++ выступает как одиночный оператор.

Дана функция F(A, B, C, D)
Укажите отличия между __stdcall, __cdecl, __fastcall, __thiscall.

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

__stdcall - прямой порядок расположения данных на стеке, обратный по времени способ запихивания, стек очищает функция, поэтому число параметров фиксировано: 

push D push C
push B
push A
call F
; ret 16 ; очистка стека - в функции 


__cdecl - - прямой порядок расположения данных на стеке, обратный по времени способ запихивания, допускает переменное число параметров, поскольку стек очищает тот, кто вызвал функцию:

push D
push C
push B
push A
call F
; ret inc esp, 16 ; очистка стека здесь 


_fastcall: ; аналогично stdcall, но два первых параметра передаются через регистры:

push D
push C
mov edx,
B mov eax,
A call F ; ret 8
; очистка стека - в функции 

__thiscall - прямой порядок расположения данных на стеке, параметр this передается в регистре., аргументы удаляются вызывающей стороной.

Дана функция F(A, B, C, D)
Укажите отличия между __stdcall, __cdecl, __fastcall, __thiscall.

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

__stdcall - прямой порядок расположения данных на стеке, обратный по времени способ запихивания, стек очищает функция, поэтому число параметров фиксировано: 

push D push C
push B
push A
call F
; ret 16 ; очистка стека - в функции 


__cdecl - - прямой порядок расположения данных на стеке, обратный по времени способ запихивания, допускает переменное число параметров, поскольку стек очищает тот, кто вызвал функцию:

push D
push C
push B
push A
call F
; ret inc esp, 16 ; очистка стека здесь 


_fastcall: ; аналогично stdcall, но два первых параметра передаются через регистры:

push D
push C
mov edx,
B mov eax,
A call F ; ret 8
; очистка стека - в функции 

__thiscall - прямой порядок расположения данных на стеке, параметр this передается в регистре., аргументы удаляются вызывающей стороной.

Что можно сказать о такой конструкции:

delete this; 

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Это выражение считается выражением плохого тона и нужно стараться избегать его использования, так как оно ведет к ошибкам.
Данная конструкция имеет две ловушки.
Во-первых, если оно выполняется в методе extern, static или automatic объекта, программа скорее всего завершится досрочно вскоре после выполнения оператора delete. Не существует переносимого способа сообщить, что объект создан на куче, таким образом класс не может проверить корректно ли объект создался.
Во-вторых, при таком самоуничтожении, программа может и не узнать об этом. Для нее объект по-прежнему продолжает существовать, несмотря на то, что это не так. Любое обращение к this или к любым данным объекта приведет к катастрофическим последствиям. При этом методы, которые не содержат обращения к полям-данным объекта, выполняются нормально.

Что можно сказать о такой конструкции:

delete this; 

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Это выражение считается выражением плохого тона и нужно стараться избегать его использования, так как оно ведет к ошибкам.
Данная конструкция имеет две ловушки.
Во-первых, если оно выполняется в методе extern, static или automatic объекта, программа скорее всего завершится досрочно вскоре после выполнения оператора delete. Не существует переносимого способа сообщить, что объект создан на куче, таким образом класс не может проверить корректно ли объект создался.
Во-вторых, при таком самоуничтожении, программа может и не узнать об этом. Для нее объект по-прежнему продолжает существовать, несмотря на то, что это не так. Любое обращение к this или к любым данным объекта приведет к катастрофическим последствиям. При этом методы, которые не содержат обращения к полям-данным объекта, выполняются нормально.

Что такое мультиметоды в C++? Расскажите об их поддержке в C++? Почему, как Вы думаете, они непопулярны?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

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

В ограниченной форме поддерживаются.
Во-первых, однопараметрические мультиметоды есть в C++ в лице виртуальных методов классов. Связывание по первому (неявному this) параметру является поздним, связывание остальных параметров - ранним.
Во-вторых, многопараметрические мультиметоды тоже имеются в C++, но связывание для них всегда раннее. Это обычная перегрузка. Общий случай - многопараметрические мультиметоды с произвольно задаваемым временем связывания для каждого - не поддерживается на уровне языка. Между тем мультиметоды - это та же перегрузка, только разрешаемая в run-time, а не в compile-time.

Непопулярность связана в первую очередь с отсутствием явной языковой поддержки. Они могут быть реализованы вручную, причём многими способами, но получить универсальную, эффективную, кроссплатформенную и удобную реализацию крайне сложно. Так или иначе плюсы одного варианта реализации компенсируются её минусами, которых не имеет другая, но зато в той присутствуют другие минусы, отсутствующие в этой.
В связи с этим программисты на C++ предпочитают писать велосипеды под каждый конкретный случай, где будут нужные им плюсы, а минусы будут нейтрализованы или не критичны. Это основная причина. Второй причиной является то, что в связи с первой немногие программисты вообще знают о мультиметодах. Даже когда сталкиваются с ними и пытаются решить с их помощью свою задачу.

Что такое мультиметоды в C++? Расскажите об их поддержке в C++? Почему, как Вы думаете, они непопулярны?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

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

В ограниченной форме поддерживаются.
Во-первых, однопараметрические мультиметоды есть в C++ в лице виртуальных методов классов. Связывание по первому (неявному this) параметру является поздним, связывание остальных параметров - ранним.
Во-вторых, многопараметрические мультиметоды тоже имеются в C++, но связывание для них всегда раннее. Это обычная перегрузка. Общий случай - многопараметрические мультиметоды с произвольно задаваемым временем связывания для каждого - не поддерживается на уровне языка. Между тем мультиметоды - это та же перегрузка, только разрешаемая в run-time, а не в compile-time.

Непопулярность связана в первую очередь с отсутствием явной языковой поддержки. Они могут быть реализованы вручную, причём многими способами, но получить универсальную, эффективную, кроссплатформенную и удобную реализацию крайне сложно. Так или иначе плюсы одного варианта реализации компенсируются её минусами, которых не имеет другая, но зато в той присутствуют другие минусы, отсутствующие в этой.
В связи с этим программисты на C++ предпочитают писать велосипеды под каждый конкретный случай, где будут нужные им плюсы, а минусы будут нейтрализованы или не критичны. Это основная причина. Второй причиной является то, что в связи с первой немногие программисты вообще знают о мультиметодах. Даже когда сталкиваются с ними и пытаются решить с их помощью свою задачу.

В чем различия между dynamic_cast и reinterpret_cast в С++?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

xxx_cast<type_to>(expression_from)

Динамическое приведение - это безопасное приведение по иерархии наследования, в том числе и для виртуального наследования. Проводит преобразование типа, предварительно убедившись (с помощью RTTI), что объект expression_from в действительности является объектом типа type_to. Если нет: для указателей возвращает NULL.

При reinterpret_cast результат не гарантирован, проверки не осуществляются. Ограничения на expression_from: порядковый тип (логический, символьный, целый, перечисляемый), указатель, ссылка. Ограничения на type_to: для порядкового типа или указателя — порядковый тип или указатель. Для ссылки — ссылка.

В чем различия между dynamic_cast и reinterpret_cast в С++?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

xxx_cast<type_to>(expression_from)

Динамическое приведение - это безопасное приведение по иерархии наследования, в том числе и для виртуального наследования. Проводит преобразование типа, предварительно убедившись (с помощью RTTI), что объект expression_from в действительности является объектом типа type_to. Если нет: для указателей возвращает NULL.

При reinterpret_cast результат не гарантирован, проверки не осуществляются. Ограничения на expression_from: порядковый тип (логический, символьный, целый, перечисляемый), указатель, ссылка. Ограничения на type_to: для порядкового типа или указателя — порядковый тип или указатель. Для ссылки — ссылка.

Общее понятие итератора STL. Итератор возвращающий значение "за пределом".

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

STL (Standart Template Librаry) - библиотека, ставшая первым масштабным шагом к упрощению работы программиста, содержащая наиболее часто употребляемые конструкции, шаблоны функций, "объемные ящики" предназначенные для хранения важной информации(упорядоченной или неупорядоченной, например:vector, list, multiset...), доступ к данным которых осуществляется через заранее прописанные методы-функции (предполагающие для начала создание определенных классов с методами шаблонизированного типа).

Для начала хотелось бы отметить, что главным атрибутом STL является итератор - удобная обертка для указателей, выполненных как шаблоны классов. Кстати говоря, обычный указатель тоже можно считать итератором, правда, очень примитивным. Итераторы обладают массой достоинств, например таких, как автоматическое отслеживание размера типа, на который указывает итератор, или автоматизированные операции инкремента и декремента для перехода от элемента к элементу. Именно благодаря этим возможностям итераторы и являются фундаментом всей библиотеки.

Чтобы было более понятно, можно привести пример вывода элементов массива, состоящего из 5 элементов:
пусть у нас имеется массив чисел, которые нужно распечатать. Тогда программа печати с использованием for_each может выглядеть так:

#include  
#include  
using namespace std; 
 
void printValue(int num) 
{ 
  cout << num << "\n"; 
} 
 
main(void) 
{ 
  int init[] = {1, 2, 3, 4, 5}; 
  for_each(init, init + 5, printValue); 
} 


Вызывается алгоритм for_each, ему в качестве входных итераторов передаются указатели на начало массива и на адрес, следующий за концом массива, т. е. на значение "за пределами". Третьим параметром является указатель на функцию printValue, которая печатает элементы массива. Чтобы включить в программу возможность использования потоков, добавляется включаемый файл iostream, а для описания прототипа алгоритма for_each в программу включается заголовочный файл algorithm (algorith для продуктов Borland). Обязательным при использовании STL является использование директивы using namespace std, включающей пространство имен библиотеки STL.

А теперь продолжим знакомство с итераторами. Итераторы можно условно разделить на две категории: основные и вспомогательные. Но прежде чем перейти к подробному описанию и тех и других, необходимо остановиться на двух важных правилах работы с итераторами: получение итераторов и отслеживания значения "за пределом". Многие функции и методы классов STL возвращают итераторы, вместо того чтобы производить действия над обычными указателями С++. Классы STL, хранящие информацию, возвратят итератор, указывающий на первый элемент данных, если вызвать их метод begin(). Напротив, вызов метода end() приводит к возврату значения "за пределом" (past-the-end). Так называется значение итератора, при котором он указывает на элемент, следующий за последним разрешенным для ссылки элементом. Начиная со значения "за пределом", находится область данных, из которой нельзя читать и куда нельзя записывать. Нарушение этого запрета приведет к непредсказуемому результату. Представьте себе массив, например, из 10 элементов. Если итератор ссылается на некий одиннадцатый элемент, то говорят, что он ссылается на значение "за пределом". Разумеется, попытка записать в несуществующий элемент данные или оперировать данными этого элемента, как достоверными, приведет к неопределенному результату. Если бы вы попытались проделать такую операцию с блоком памяти в среде Windows, то немедленно получили бы исключение выхода за предел, что, скорее всего, окончилось бы аварийным завершением программы. Вот и судите сами, насколько важно следить за значением "за пределом".Каждый итератор взаимозаменяем, необходимо лишь учитывать иерархию:
1) двунаправленный итератор;
2) однонаправленный итератор;
3-4) соответственно итератор ввода и вывода;
Из всего вышеизложенного хотела бы отметить, что использование STL требует от нас повышенного внимания, так как корректное использование шаблонов - это итог надлежащей работы как на практике так и в теории.Надеюсь было познавательно, спасибо за внимание.

Общее понятие итератора STL. Итератор возвращающий значение "за пределом".

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

STL (Standart Template Librаry) - библиотека, ставшая первым масштабным шагом к упрощению работы программиста, содержащая наиболее часто употребляемые конструкции, шаблоны функций, "объемные ящики" предназначенные для хранения важной информации(упорядоченной или неупорядоченной, например:vector, list, multiset...), доступ к данным которых осуществляется через заранее прописанные методы-функции (предполагающие для начала создание определенных классов с методами шаблонизированного типа).

Для начала хотелось бы отметить, что главным атрибутом STL является итератор - удобная обертка для указателей, выполненных как шаблоны классов. Кстати говоря, обычный указатель тоже можно считать итератором, правда, очень примитивным. Итераторы обладают массой достоинств, например таких, как автоматическое отслеживание размера типа, на который указывает итератор, или автоматизированные операции инкремента и декремента для перехода от элемента к элементу. Именно благодаря этим возможностям итераторы и являются фундаментом всей библиотеки.

Чтобы было более понятно, можно привести пример вывода элементов массива, состоящего из 5 элементов:
пусть у нас имеется массив чисел, которые нужно распечатать. Тогда программа печати с использованием for_each может выглядеть так:

#include  
#include  
using namespace std; 
 
void printValue(int num) 
{ 
  cout << num << "\n"; 
} 
 
main(void) 
{ 
  int init[] = {1, 2, 3, 4, 5}; 
  for_each(init, init + 5, printValue); 
} 


Вызывается алгоритм for_each, ему в качестве входных итераторов передаются указатели на начало массива и на адрес, следующий за концом массива, т. е. на значение "за пределами". Третьим параметром является указатель на функцию printValue, которая печатает элементы массива. Чтобы включить в программу возможность использования потоков, добавляется включаемый файл iostream, а для описания прототипа алгоритма for_each в программу включается заголовочный файл algorithm (algorith для продуктов Borland). Обязательным при использовании STL является использование директивы using namespace std, включающей пространство имен библиотеки STL.

А теперь продолжим знакомство с итераторами. Итераторы можно условно разделить на две категории: основные и вспомогательные. Но прежде чем перейти к подробному описанию и тех и других, необходимо остановиться на двух важных правилах работы с итераторами: получение итераторов и отслеживания значения "за пределом". Многие функции и методы классов STL возвращают итераторы, вместо того чтобы производить действия над обычными указателями С++. Классы STL, хранящие информацию, возвратят итератор, указывающий на первый элемент данных, если вызвать их метод begin(). Напротив, вызов метода end() приводит к возврату значения "за пределом" (past-the-end). Так называется значение итератора, при котором он указывает на элемент, следующий за последним разрешенным для ссылки элементом. Начиная со значения "за пределом", находится область данных, из которой нельзя читать и куда нельзя записывать. Нарушение этого запрета приведет к непредсказуемому результату. Представьте себе массив, например, из 10 элементов. Если итератор ссылается на некий одиннадцатый элемент, то говорят, что он ссылается на значение "за пределом". Разумеется, попытка записать в несуществующий элемент данные или оперировать данными этого элемента, как достоверными, приведет к неопределенному результату. Если бы вы попытались проделать такую операцию с блоком памяти в среде Windows, то немедленно получили бы исключение выхода за предел, что, скорее всего, окончилось бы аварийным завершением программы. Вот и судите сами, насколько важно следить за значением "за пределом".Каждый итератор взаимозаменяем, необходимо лишь учитывать иерархию:
1) двунаправленный итератор;
2) однонаправленный итератор;
3-4) соответственно итератор ввода и вывода;
Из всего вышеизложенного хотела бы отметить, что использование STL требует от нас повышенного внимания, так как корректное использование шаблонов - это итог надлежащей работы как на практике так и в теории.Надеюсь было познавательно, спасибо за внимание.

Что такое namespace?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Namespace в переводе означает пространство имен. Используется для логической группировки классов, функций и переменных.

Говоря по другому namespace позволяет разделить глобальное пространство имен на подпространства. Пример определения namespace:

namespace N {  
  //список определений функций, классов и переменных 
} 


Для доступа к членам пространства имен извне используется оператор :: (scope operator). Пример:

namespace N { int a, b; } 
 
N::a = 1; 


Основная задача пространств имен состоит в том, чтобы избежать коллизий имен в глобальном пространстве имен.

Что такое namespace?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Namespace в переводе означает пространство имен. Используется для логической группировки классов, функций и переменных.

Говоря по другому namespace позволяет разделить глобальное пространство имен на подпространства. Пример определения namespace:

namespace N {  
  //список определений функций, классов и переменных 
} 


Для доступа к членам пространства имен извне используется оператор :: (scope operator). Пример:

namespace N { int a, b; } 
 
N::a = 1; 


Основная задача пространств имен состоит в том, чтобы избежать коллизий имен в глобальном пространстве имен.

Что такое перегрузка функций?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

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

В сигнатуру функции входят:

порядок и типы параметров

модификатор const для нестатических функций

модификатор volatile (см. ниже комментарий Aydario)

Возвращаемое значение не входит в сигнатуру.

Подробнее про const-overloading

Что такое перегрузка функций?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

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

В сигнатуру функции входят:

порядок и типы параметров

модификатор const для нестатических функций

модификатор volatile (см. ниже комментарий Aydario)

Возвращаемое значение не входит в сигнатуру.

Подробнее про const-overloading

Для чего в классе-контейнере зачастую перегружается одновременно две версии оператора индексирования: const и не-const?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Обычный (не-const) операторный метод доступа по индексу возвращает ссылку на элемент, пример для строки:
char& operator[](int index);

Это позволяет не только читать, но и модифицировать значение по индексу. Такой метод могут вызывать только не-константные объекты, а для константных объектов доступ по индексу будет не доступен. Сделать приведенный индексатор const-методом нельзя: он возвращает ссылку на данные класса. Поэтому, добавляют вторую перегрузку:
char operator[](int index) const;
Этот вариант может вызываться константными объектами, с помощье него возможно лишь чтение элементов, т.к. результат возвращается по значению, а не по ссылке:
const Vector <char> vec;
char ch = vec[0];

Для чего в классе-контейнере зачастую перегружается одновременно две версии оператора индексирования: const и не-const?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Обычный (не-const) операторный метод доступа по индексу возвращает ссылку на элемент, пример для строки:
char& operator[](int index);

Это позволяет не только читать, но и модифицировать значение по индексу. Такой метод могут вызывать только не-константные объекты, а для константных объектов доступ по индексу будет не доступен. Сделать приведенный индексатор const-методом нельзя: он возвращает ссылку на данные класса. Поэтому, добавляют вторую перегрузку:
char operator[](int index) const;
Этот вариант может вызываться константными объектами, с помощье него возможно лишь чтение элементов, т.к. результат возвращается по значению, а не по ссылке:
const Vector <char> vec;
char ch = vec[0];

В чем недостатки такого метода:

int* foo() 
{ 
    int *x = new int(2); 
    return x; 
}

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

При таком способе нет гарантии, что память в конечном счете освободится. При вызове

foo();

память просто утечет (функция не void, но написать так никто не мешает). Но, допустим, программист все же написал так:

int main() 
{ 
    int *x = foo(); 
    std::cout << *x; 
    // ... прочий код 
    // delete x; 
}

Нет никакой гарантии, что в конечном счете он напишет delete x; И это хорошо, если одной функцией все ограничивается, ну а что происходит в больших проектах, где возвращаться может не просто int, а объект класса, например, а объем кода уж очень велик. Никто не гарантирует, что тут не сыграет обычная человеческая невнимательность. Да и неправильно это, возлагать на программиста подобные задачи. Самое противное как раз то, что род ошибки как раз из тех, что не появятся во время компиляции, и, возможно, никак не проявят себя при нескольких запусках бинарника. Оно (зло) затаится и заявит о себе лишь в самый неподходящий момент, когда программа предоставляется заказчику. Возьмем ситуацию похуже. Вы написали действительно хорошую функцию (не считая данной утечки) и её добавили в библиотеку, которой потом будут пользоваться другие программисты. Откуда они могут знать, как надо освободить память (free или delete). И почему часть ответственности из библиотеки ложиться на программу, в которой она используется? Необходимо пользоваться правилом "Кто память выделяет, тот её и освобождает."

В чем недостатки такого метода:

int* foo() 
{ 
    int *x = new int(2); 
    return x; 
}

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

При таком способе нет гарантии, что память в конечном счете освободится. При вызове

foo();

память просто утечет (функция не void, но написать так никто не мешает). Но, допустим, программист все же написал так:

int main() 
{ 
    int *x = foo(); 
    std::cout << *x; 
    // ... прочий код 
    // delete x; 
}

Нет никакой гарантии, что в конечном счете он напишет delete x; И это хорошо, если одной функцией все ограничивается, ну а что происходит в больших проектах, где возвращаться может не просто int, а объект класса, например, а объем кода уж очень велик. Никто не гарантирует, что тут не сыграет обычная человеческая невнимательность. Да и неправильно это, возлагать на программиста подобные задачи. Самое противное как раз то, что род ошибки как раз из тех, что не появятся во время компиляции, и, возможно, никак не проявят себя при нескольких запусках бинарника. Оно (зло) затаится и заявит о себе лишь в самый неподходящий момент, когда программа предоставляется заказчику. Возьмем ситуацию похуже. Вы написали действительно хорошую функцию (не считая данной утечки) и её добавили в библиотеку, которой потом будут пользоваться другие программисты. Откуда они могут знать, как надо освободить память (free или delete). И почему часть ответственности из библиотеки ложиться на программу, в которой она используется? Необходимо пользоваться правилом "Кто память выделяет, тот её и освобождает."

Известно, что использование using-объявлений и using-директив в заголовочных файлах является плохим тоном. (Речь идёт о using в контексте пространств имён, а не классов.) Назовите хотя бы одно дизайнерское решение, когда тем не менее это не просто позволяется, но даже выгодно.

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

В процессе декомпозиции исходная задача разбивается на малые подзадачи. Пространства имён естественным образом инкапсулируют эти подзадачи для их разграничения и публикации их интерфейсов взаимодействия. Интерфейсы, представляя методы взаимодействия подзадач друг с другом, естественно зачастую друг с другом связаны. Некий интерфейс может использовать другой интерфейс для своих нужд. В частности некая сущность одного интерфейса может использоваться как часть другого. В этом случае явное на то указание путём using-объявления в принципе вполне вписывается в парадигму интерфейсно-ориентированного программирования. Также вполне можно представить ситуацию, когда некий интерфейс целиком предназначен для использования другим интерфейсом, или же этот другой является его расширением, новой версией, например. В таком случае и using-директива будет вполне на своём месте.
Эти (и только эти) ситуации т.о. позволяют использовать using в заголовочных файлах. Однако обратите внимание, что даже в этих случаях using оказывается локализованной в области видимости некоего пространства имён.

Известно, что использование using-объявлений и using-директив в заголовочных файлах является плохим тоном. (Речь идёт о using в контексте пространств имён, а не классов.) Назовите хотя бы одно дизайнерское решение, когда тем не менее это не просто позволяется, но даже выгодно.

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

В процессе декомпозиции исходная задача разбивается на малые подзадачи. Пространства имён естественным образом инкапсулируют эти подзадачи для их разграничения и публикации их интерфейсов взаимодействия. Интерфейсы, представляя методы взаимодействия подзадач друг с другом, естественно зачастую друг с другом связаны. Некий интерфейс может использовать другой интерфейс для своих нужд. В частности некая сущность одного интерфейса может использоваться как часть другого. В этом случае явное на то указание путём using-объявления в принципе вполне вписывается в парадигму интерфейсно-ориентированного программирования. Также вполне можно представить ситуацию, когда некий интерфейс целиком предназначен для использования другим интерфейсом, или же этот другой является его расширением, новой версией, например. В таком случае и using-директива будет вполне на своём месте.
Эти (и только эти) ситуации т.о. позволяют использовать using в заголовочных файлах. Однако обратите внимание, что даже в этих случаях using оказывается локализованной в области видимости некоего пространства имён.

Для чего используют виртуальное наследование в С++

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Рассмотрим следующий пример:

class Parent 
{ } 
class Child1 : virtual public Parent 
{ } 
class Child2 : virtual public Parent 
{ } 
class GrandChild : public Child1,  public Child1 
{ } 


Использование ключевого слова virtual в классах Child1, Child2 приводит к тому что они наследуют единый общий под объект базового класса Parent, а не каждый свою! Таким образом решается неоднозначность для компилятора по отношению к GrandChild

Для чего используют виртуальное наследование в С++

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Рассмотрим следующий пример:

class Parent 
{ } 
class Child1 : virtual public Parent 
{ } 
class Child2 : virtual public Parent 
{ } 
class GrandChild : public Child1,  public Child1 
{ } 


Использование ключевого слова virtual в классах Child1, Child2 приводит к тому что они наследуют единый общий под объект базового класса Parent, а не каждый свою! Таким образом решается неоднозначность для компилятора по отношению к GrandChild

В каких случаях тело функции, объявленной как inline, не может быть встроено в точке вызова (даже если функция небольшая и ее включение оптимально, или вместо inline использовано что-то вроде __forceinline)? А вместо встраивания будет использован вызов.

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Функция не может быть встроена если:
1. Это рекурсивная функция. Глубина рекурсии в момент компиляции может быть неизвестна, поэтому непонятно сколько раз вставлять тело функции. Даже если глубина известна, встраивание рекурсивной функции приведет к многократному увеличению объема кода.
Некоторые компиляторы(например Visual C++) имеют опции включающие встраивание рекурсивных функций на некоторую фиксированную глубину.
2. Вызов функции по указателю. Если где-то в программе от функции берется указатель, то компилятор создаст тело функции для вызова.
При этом если где-то в другом месте функция вызывается непосредственно, то в этом месте она может быть встроена.
3. Виртуальная функция. Если виртуальная функция вызывается через указатель или ссылку на класс, то она вызывается через указатель на функцию в таблице виртуальных функций, поэтому для нее так же должно быть создано тело для обычного вызова.
Если виртуальная функция вызывается непосредственно через экземпляр класса, то она может быть встроена.

В каких случаях тело функции, объявленной как inline, не может быть встроено в точке вызова (даже если функция небольшая и ее включение оптимально, или вместо inline использовано что-то вроде __forceinline)? А вместо встраивания будет использован вызов.

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Функция не может быть встроена если:
1. Это рекурсивная функция. Глубина рекурсии в момент компиляции может быть неизвестна, поэтому непонятно сколько раз вставлять тело функции. Даже если глубина известна, встраивание рекурсивной функции приведет к многократному увеличению объема кода.
Некоторые компиляторы(например Visual C++) имеют опции включающие встраивание рекурсивных функций на некоторую фиксированную глубину.
2. Вызов функции по указателю. Если где-то в программе от функции берется указатель, то компилятор создаст тело функции для вызова.
При этом если где-то в другом месте функция вызывается непосредственно, то в этом месте она может быть встроена.
3. Виртуальная функция. Если виртуальная функция вызывается через указатель или ссылку на класс, то она вызывается через указатель на функцию в таблице виртуальных функций, поэтому для нее так же должно быть создано тело для обычного вызова.
Если виртуальная функция вызывается непосредственно через экземпляр класса, то она может быть встроена.

Как С++ выбирает какой перегруженный вариант вызванной функции вызвать?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Результат вызова перегруженной функции сводится к одному из трех возможных исходов: 
1) найдено соответствие(match found). Вызов разрешен с конкретной перегруженной функцией.
2) не найдено соответствия(no match found). Аргументы не могут быть сопоставлены с любым перегруженным вариантом функции.
3) найдено неоднозначное соответствие(Ambiguous match found). Аргументы соответствуют более одной перегруженной функции.
Теперь более подробно...
Когда вызывается перегруженная функция, C++ проходит через следующие процессы, чтобы определить, какая версия функции будет вызвана:

1)Во-первых, C++ пытается найти точное совпадение(exact match). Это случай, когда переданный аргумент в точности совпадает с типом параметра одной из перегруженных функций. Например:

void Print(char* cValue); 
void Print(int nValue); 
  
Print(0); // exact match with Print(int) 


Несмотря на то, что 0 могло бы соответствовать Print(char*), есть точное совпадение с Print(int). Таким образом, Print(int) является лучшим кандидатом в наличии.

2) Если точного совпадения не найдено, C++ пытается найти соответствие(match) через продвижение("promotion").
Некоторые типы могут быть автоматически продвинуты(promoted) через внутренние преобразования типа в другие типы. Кратко, это можно представить так:
- bool, char, unsigned char, short and enum is promoted to an int.
- unsigned short can be promoted to int or unsigned int, depending on the size of an int.
- float is promoted to double. 

Подробнее об этом можно прочитать в стандарте C++, в разделе "integral promotions" и "floating point promotions" Например:

void Print(char* cValue); 
void Print(int nValue); 
  
Print('a'); // promoted to match Print(int) 


В этом случае, так как нет void Print(char), делается продвижение из char 'a' в int, который является соответствием(match) для Print(int).

3) Если продвижений тоже не найдено, С++ пытается найти соответствие при помощи стандартного преобразования типов(standard conversion):

- любой числовой тип будет соответствовать любому другому числовому типу, в том числе без знака (например, Int to float) 
- enum будет соответствовать формальному типу числовых типов (например,еnum to float).
- ноль будет соответствовать указателям и числовым типам (например, 0 to char*, 0 to float).
- указатель будет соответствовать void-указателю.

Например:

void Print(float fValue); 
void Print(struct sValue); 
  
Print('a');   // promoted to match Print(float) 


Так как нет Print(char), а также нет Print(int), то 'a' приводится к типу float, что соответствует Print(float). Обратите внимания на то, что все стандартные преобразования типов считаются равносильными. Ни одно стандартное преобразование не считается лучше любого другого!

4) В конце концов, C++ пытается найти соответствие через преобразования, определенные пользователем(user-defined conversion). Например, мы определяем class А в котором определяем преобразование к типу int.

class A; // with user-defined conversion to int 
 
  
void Print(float fValue); 
void Print(int nValue); 
 
A newValue;  
Print(newValue); // newValue will be converted to an int and matched to Print(int) 


Несмотря на то, что newValue имеет тип A, так как этот особый класс имеет определенное пользователем преобразование в int, вызов функции Print(newValue) будeт приведен к версии Print(int).

Неоднозначные соответствия(Ambiguous matches). Так как все стандартные преобразования считаются равными, и все пользовательские преобразования считаются равными,то если вызов функции имеет несколько кандидатов при стандартном преобразовании или же при преобразованных определяемых пользователем, тогда результат такого вызова будет "Ambiguous match" . Например:

void Print(unsigned int nValue); 
void Print(float fValue); 
  
Print('a'); 
Print(0); 
Print(3.14159); 


В случае Print('a'), C++ не может найти точное совпадение. Он пытается делать продвижение из 'а' в int, но перегрузки Print(int) тоже нет. Используя стандартное преобразование типов, можно конвертировать 'а' как в unsigned int, так и в float. Но так как все стандартные преобразования считаются равносильными, это неоднозначный матч("Ambiguous match"). 
Аналогично с Print(0). 0 является int, и нет перегрузки Print(int). Следовательно она может соответствовать обеим вызовам при помощи стандартного преобразования типов. 
Print(3,14159) может показаться немного удивительным, так как большинство программистов предположили бы, что это соответствует Print(float). Но помните, что все литеральные значения с плавающей точкой имеют тип double, если конечно они не имеют суффиксa 'f'. И так как нет варианта Print(double), следовательно, он соответствует обеим вариантам, через стандартные преобразования. 
При Ambiguous match компилятор выдает ошибку во время компиляции.

Как С++ выбирает какой перегруженный вариант вызванной функции вызвать?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Результат вызова перегруженной функции сводится к одному из трех возможных исходов: 
1) найдено соответствие(match found). Вызов разрешен с конкретной перегруженной функцией.
2) не найдено соответствия(no match found). Аргументы не могут быть сопоставлены с любым перегруженным вариантом функции.
3) найдено неоднозначное соответствие(Ambiguous match found). Аргументы соответствуют более одной перегруженной функции.
Теперь более подробно...
Когда вызывается перегруженная функция, C++ проходит через следующие процессы, чтобы определить, какая версия функции будет вызвана:

1)Во-первых, C++ пытается найти точное совпадение(exact match). Это случай, когда переданный аргумент в точности совпадает с типом параметра одной из перегруженных функций. Например:

void Print(char* cValue); 
void Print(int nValue); 
  
Print(0); // exact match with Print(int) 


Несмотря на то, что 0 могло бы соответствовать Print(char*), есть точное совпадение с Print(int). Таким образом, Print(int) является лучшим кандидатом в наличии.

2) Если точного совпадения не найдено, C++ пытается найти соответствие(match) через продвижение("promotion").
Некоторые типы могут быть автоматически продвинуты(promoted) через внутренние преобразования типа в другие типы. Кратко, это можно представить так:
- bool, char, unsigned char, short and enum is promoted to an int.
- unsigned short can be promoted to int or unsigned int, depending on the size of an int.
- float is promoted to double. 

Подробнее об этом можно прочитать в стандарте C++, в разделе "integral promotions" и "floating point promotions" Например:

void Print(char* cValue); 
void Print(int nValue); 
  
Print('a'); // promoted to match Print(int) 


В этом случае, так как нет void Print(char), делается продвижение из char 'a' в int, который является соответствием(match) для Print(int).

3) Если продвижений тоже не найдено, С++ пытается найти соответствие при помощи стандартного преобразования типов(standard conversion):

- любой числовой тип будет соответствовать любому другому числовому типу, в том числе без знака (например, Int to float) 
- enum будет соответствовать формальному типу числовых типов (например,еnum to float).
- ноль будет соответствовать указателям и числовым типам (например, 0 to char*, 0 to float).
- указатель будет соответствовать void-указателю.

Например:

void Print(float fValue); 
void Print(struct sValue); 
  
Print('a');   // promoted to match Print(float) 


Так как нет Print(char), а также нет Print(int), то 'a' приводится к типу float, что соответствует Print(float). Обратите внимания на то, что все стандартные преобразования типов считаются равносильными. Ни одно стандартное преобразование не считается лучше любого другого!

4) В конце концов, C++ пытается найти соответствие через преобразования, определенные пользователем(user-defined conversion). Например, мы определяем class А в котором определяем преобразование к типу int.

class A; // with user-defined conversion to int 
 
  
void Print(float fValue); 
void Print(int nValue); 
 
A newValue;  
Print(newValue); // newValue will be converted to an int and matched to Print(int) 


Несмотря на то, что newValue имеет тип A, так как этот особый класс имеет определенное пользователем преобразование в int, вызов функции Print(newValue) будeт приведен к версии Print(int).

Неоднозначные соответствия(Ambiguous matches). Так как все стандартные преобразования считаются равными, и все пользовательские преобразования считаются равными,то если вызов функции имеет несколько кандидатов при стандартном преобразовании или же при преобразованных определяемых пользователем, тогда результат такого вызова будет "Ambiguous match" . Например:

void Print(unsigned int nValue); 
void Print(float fValue); 
  
Print('a'); 
Print(0); 
Print(3.14159); 


В случае Print('a'), C++ не может найти точное совпадение. Он пытается делать продвижение из 'а' в int, но перегрузки Print(int) тоже нет. Используя стандартное преобразование типов, можно конвертировать 'а' как в unsigned int, так и в float. Но так как все стандартные преобразования считаются равносильными, это неоднозначный матч("Ambiguous match"). 
Аналогично с Print(0). 0 является int, и нет перегрузки Print(int). Следовательно она может соответствовать обеим вызовам при помощи стандартного преобразования типов. 
Print(3,14159) может показаться немного удивительным, так как большинство программистов предположили бы, что это соответствует Print(float). Но помните, что все литеральные значения с плавающей точкой имеют тип double, если конечно они не имеют суффиксa 'f'. И так как нет варианта Print(double), следовательно, он соответствует обеим вариантам, через стандартные преобразования. 
При Ambiguous match компилятор выдает ошибку во время компиляции.

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

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Можно, но такой вызов будет иметь неопределённое поведение, так как при создании объекта класса наследника сначала происходит инициализация базового класса, а потом наследников. При этом в момент инициализации базового класса ещё нет возможности вызвать полиморфно метод наследника, так как сам наследник ещё не проинициализирован и таблица виртуальных методов не содержит адресов методов наследника.

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

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Можно, но такой вызов будет иметь неопределённое поведение, так как при создании объекта класса наследника сначала происходит инициализация базового класса, а потом наследников. При этом в момент инициализации базового класса ещё нет возможности вызвать полиморфно метод наследника, так как сам наследник ещё не проинициализирован и таблица виртуальных методов не содержит адресов методов наследника.

Какая разница между указателями:

int* i=new int[0]; 
int* j=(int*) malloc(0);

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

int* i=new int[0];

возвращает ненулевой указатель, а

int* j=(int*) malloc(0);

возвращает нулевой указатель.

int* i=new int[0]; 

выделит память в GlobalHeap, а

int* j=(int*) malloc(0); 

выделит в LocalHeap. 

Отсюда в оператора new преимущества в памяти.

Какая разница между указателями:

int* i=new int[0]; 
int* j=(int*) malloc(0);

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

int* i=new int[0];

возвращает ненулевой указатель, а

int* j=(int*) malloc(0);

возвращает нулевой указатель.

int* i=new int[0]; 

выделит память в GlobalHeap, а

int* j=(int*) malloc(0); 

выделит в LocalHeap. 

Отсюда в оператора new преимущества в памяти.

Какие функции-члены класса могут быть автоматически созданы при объявлении "пустого" класса в C++, например class A { }; ?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Следующие методы будут созданы автоматически, если в коде будет встречено их использование:
-конструктор по умолчанию (без аргументов)
-конструктор копирования по умолчанию
-деструктор
-оператор присваивания

То есть объявление class A {} может быть эквивалентно следующему:

class A { 
public:  
  A() {} 
  A(const A&) {} 
  ~A() {} 
  A& operator=(const A&) {} 
}; 


P.S. На собеседовании можно углубиться в детали, например когда конструктор по умолчанию не создается, или в чем опасность конструктора копирования созданного по умолчанию.

Какие функции-члены класса могут быть автоматически созданы при объявлении "пустого" класса в C++, например class A { }; ?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Следующие методы будут созданы автоматически, если в коде будет встречено их использование:
-конструктор по умолчанию (без аргументов)
-конструктор копирования по умолчанию
-деструктор
-оператор присваивания

То есть объявление class A {} может быть эквивалентно следующему:

class A { 
public:  
  A() {} 
  A(const A&) {} 
  ~A() {} 
  A& operator=(const A&) {} 
}; 


P.S. На собеседовании можно углубиться в детали, например когда конструктор по умолчанию не создается, или в чем опасность конструктора копирования созданного по умолчанию.

Чем отличается vector от deque?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Отличие в организации памяти, у vector она как у обычного Си-массива - последовательный и непрерывный набор байт, а у deque это фрагменты с разрывами. За счет этого отличия vector всегда можно привести к обычному массиву или скопировать целиком участок памяти, но зато у deque операции вставки/удаления в начало быстрее (O(1) против O(n)), ввиду того, что не нужно перемещать остальные значения. А также наличие у deque методов push_front и pop_front.

Чем отличается vector от deque?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Отличие в организации памяти, у vector она как у обычного Си-массива - последовательный и непрерывный набор байт, а у deque это фрагменты с разрывами. За счет этого отличия vector всегда можно привести к обычному массиву или скопировать целиком участок памяти, но зато у deque операции вставки/удаления в начало быстрее (O(1) против O(n)), ввиду того, что не нужно перемещать остальные значения. А также наличие у deque методов push_front и pop_front.

Расскажите о try-catch-блоке в C++.

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Общий вид блока-контроля можно представить следующим образом:

try 
{ 
    if (некоторое условие) 
        throw string; 
    else 
        if(некоторое условие) 
            throw 42; 
} 
catch(const string &) 
{ 
    ....//в первом случае 
} 
catch(...) 
{ 
    ....//во всех последующих 
} 


Для наглядности можно привести следующий пример,в котором действуют следующие исключения, касающиеся х и у, которые не должны:
1)быть одновременно отрицательными;
2)быть равными 0;

#include<stdio.h> 
#include<iostream> 
using namespace std; 
 
int generate(int x,int y) 
{ 
    if(x==0||y==0)throw "\n ZERO-error"; 
    if(x<0)throw "negative parametr x"; 
    if(y<0)throw "negative parametr y"; 
    while(x!=y) 
    { 
        if(x>y) x=x-y; 
        else y=y-x; 
    } 
return x; 
} 
 
int main() 
{ 
 try 
 { 
    cout<<"generate(2,3)="<<generate(2,3); 
    cout<<"generate(0,8)="<<generate(0,8); 
 } 
 
catch(const char *answer) 
{ 
    cout<<answer; 
} 
system("pause"); 
return 0; 
} 


При этом:

try(пытаться)-начало блока исключений;

сatch(поймать)-начало блока, ловящего исключения;

throw -ключевое слово, создающее исключение.

Расскажите о try-catch-блоке в C++.

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Общий вид блока-контроля можно представить следующим образом:

try 
{ 
    if (некоторое условие) 
        throw string; 
    else 
        if(некоторое условие) 
            throw 42; 
} 
catch(const string &) 
{ 
    ....//в первом случае 
} 
catch(...) 
{ 
    ....//во всех последующих 
} 


Для наглядности можно привести следующий пример,в котором действуют следующие исключения, касающиеся х и у, которые не должны:
1)быть одновременно отрицательными;
2)быть равными 0;

#include<stdio.h> 
#include<iostream> 
using namespace std; 
 
int generate(int x,int y) 
{ 
    if(x==0||y==0)throw "\n ZERO-error"; 
    if(x<0)throw "negative parametr x"; 
    if(y<0)throw "negative parametr y"; 
    while(x!=y) 
    { 
        if(x>y) x=x-y; 
        else y=y-x; 
    } 
return x; 
} 
 
int main() 
{ 
 try 
 { 
    cout<<"generate(2,3)="<<generate(2,3); 
    cout<<"generate(0,8)="<<generate(0,8); 
 } 
 
catch(const char *answer) 
{ 
    cout<<answer; 
} 
system("pause"); 
return 0; 
} 


При этом:

try(пытаться)-начало блока исключений;

сatch(поймать)-начало блока, ловящего исключения;

throw -ключевое слово, создающее исключение.

Дана строка символов. Напишите ф-ию на С, которая принимает эту строку и убирает из нее все пробелы. Нельзя пользоваться стандартными классами string и т.п. Нельзя использовать цикл в цикле. Это надо сделать за один проход по строке.

Объявление: void compactString(char* str).

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

void compactString(char* str) 
{ 
    char* pStr = str; 
    while(*str != '\0') 
    { 
        if(*str != ' ') 
        { 
            *pStr = *str; 
            *pStr++; 
        } 
        str++; 
    } 
    *pStr = '\0'; 
} 

Дана строка символов. Напишите ф-ию на С, которая принимает эту строку и убирает из нее все пробелы. Нельзя пользоваться стандартными классами string и т.п. Нельзя использовать цикл в цикле. Это надо сделать за один проход по строке.

Объявление: void compactString(char* str).

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

void compactString(char* str) 
{ 
    char* pStr = str; 
    while(*str != '\0') 
    { 
        if(*str != ' ') 
        { 
            *pStr = *str; 
            *pStr++; 
        } 
        str++; 
    } 
    *pStr = '\0'; 
} 

Всегда ли можно увеличить производительность с помощью inline-функций?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Нет, не всегда. inline-функции могут сделать код как быстрее, так и медленнее, увеличить объем исполняемого кода или наоборот, уменьшить. Также, они могут (а часто так и есть) вообще не повлиять на скорость. Рассмотрим все эти случаи.
inline-функции ускоряют выполнение и уменьшают размер исполняемого кода, так как не тратится время и память на push/pop аргументов во время вызова функции.
inline-функции замедляют выполнение и увеличивают размер исполняемого кода, так как при большом количестве вызовов функций исполняемый код быстро разрастается. Замедление же происходит, когда при таком слишком большом расходе памяти, система вынуждена свопить страницы памяти на диск, а затем обратно их подгружать.
Потолок производительности многих систем упирается не в производительность CPU, а в производительность дискового ввода/вывода, базы данных или сети. Тогда inline-функции вообще не дадут почти никакого прироста в скорости.

Всегда ли можно увеличить производительность с помощью inline-функций?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Нет, не всегда. inline-функции могут сделать код как быстрее, так и медленнее, увеличить объем исполняемого кода или наоборот, уменьшить. Также, они могут (а часто так и есть) вообще не повлиять на скорость. Рассмотрим все эти случаи.
inline-функции ускоряют выполнение и уменьшают размер исполняемого кода, так как не тратится время и память на push/pop аргументов во время вызова функции.
inline-функции замедляют выполнение и увеличивают размер исполняемого кода, так как при большом количестве вызовов функций исполняемый код быстро разрастается. Замедление же происходит, когда при таком слишком большом расходе памяти, система вынуждена свопить страницы памяти на диск, а затем обратно их подгружать.
Потолок производительности многих систем упирается не в производительность CPU, а в производительность дискового ввода/вывода, базы данных или сети. Тогда inline-функции вообще не дадут почти никакого прироста в скорости.

В чём заключается разница между стандартными контейнерами vector, deque, list, set в STL (C++)?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

vector

последовательный контейнер, обеспечивающий возможность быстрого доступа к произвольному элементу с помощью операций индексирования [] или at()
изменение размеров вектора (в т.ч. неявное при вызове методов push_back(), pop_back(), insert(), erase()) является дорогостоящей операцией
предоставляет дополнительные средства для управления резервированием памяти reserve() и capasity()
предоставляет итераторы произвольного доступа

list

последовательный контейнер, оптимизированный под операции вставки и удаления элементов
операции индексирования [] и at() отсутствуют по причине их низкой эффективности
предоставляет дополнительные средства для эффективного манипулирования со списками: 
splice(), sort(), merge(), reverce(), 
а также операции для удаления элементов из списка: 
remove(), remove_if(), unique()
предоставляет двунаправленные итераторы

deque

последовательный контейнер, оптимизорованный таким образом, что головные и концевые операции для него почти также эффективны, как для списков, а индексирование почти также эффективно, как для векторов; 
однако, вставка и удаление элемента где-нибудь в "середине контейнера" неэффективны также, как для векторов
предоставляет итераторы произвольного доступа

set

ассоциативный контейнер, в котором ключом является само значение элемента
все элементы уникальны по значению и хранятся в постоянно упорядоченном состоянии; 
в качестве критерия сравнения по-умолчанию используется операция <
реализация в виде бинарного дерева обеспечивает приемлимую эффективность для вставки, удаления и поиска элементов (быстрее чем vector, но медленнее чем list)
предоставляет двунаправленные итераторы

В чём заключается разница между стандартными контейнерами vector, deque, list, set в STL (C++)?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

vector

последовательный контейнер, обеспечивающий возможность быстрого доступа к произвольному элементу с помощью операций индексирования [] или at()
изменение размеров вектора (в т.ч. неявное при вызове методов push_back(), pop_back(), insert(), erase()) является дорогостоящей операцией
предоставляет дополнительные средства для управления резервированием памяти reserve() и capasity()
предоставляет итераторы произвольного доступа

list

последовательный контейнер, оптимизированный под операции вставки и удаления элементов
операции индексирования [] и at() отсутствуют по причине их низкой эффективности
предоставляет дополнительные средства для эффективного манипулирования со списками: 
splice(), sort(), merge(), reverce(), 
а также операции для удаления элементов из списка: 
remove(), remove_if(), unique()
предоставляет двунаправленные итераторы

deque

последовательный контейнер, оптимизорованный таким образом, что головные и концевые операции для него почти также эффективны, как для списков, а индексирование почти также эффективно, как для векторов; 
однако, вставка и удаление элемента где-нибудь в "середине контейнера" неэффективны также, как для векторов
предоставляет итераторы произвольного доступа

set

ассоциативный контейнер, в котором ключом является само значение элемента
все элементы уникальны по значению и хранятся в постоянно упорядоченном состоянии; 
в качестве критерия сравнения по-умолчанию используется операция <
реализация в виде бинарного дерева обеспечивает приемлимую эффективность для вставки, удаления и поиска элементов (быстрее чем vector, но медленнее чем list)
предоставляет двунаправленные итераторы

Что такое функции-друзья и классы-друзья?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

С помощью ключевого слова friend можно обозначить так называемый дружественный класс или функцию. Такая функция (или класс) имеет доступ ко всем нестатическим полям и методам класса в котором находится через параметр-объект класса, которому она дружественна.
Дружба не наследуется, передается или даруется:
1. Допустим, класс Bicycle - друг класса Cycle. Тогда все потомки Bicycle не будут друзьями Cycle.
2. Если класс Bicycle - друг класса Cycle, а Cycle - друг класса Auto, то Bicycle не будет другом Auto.
3. Дружба односторонняя: Bicycle - друг Cycle, но Cycle не друг Bicycle.

Что такое функции-друзья и классы-друзья?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

С помощью ключевого слова friend можно обозначить так называемый дружественный класс или функцию. Такая функция (или класс) имеет доступ ко всем нестатическим полям и методам класса в котором находится через параметр-объект класса, которому она дружественна.
Дружба не наследуется, передается или даруется:
1. Допустим, класс Bicycle - друг класса Cycle. Тогда все потомки Bicycle не будут друзьями Cycle.
2. Если класс Bicycle - друг класса Cycle, а Cycle - друг класса Auto, то Bicycle не будет другом Auto.
3. Дружба односторонняя: Bicycle - друг Cycle, но Cycle не друг Bicycle.

Для чего служит ключевое слово virtual?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

1) Для объявления виртуальных функций. Объявление функции как "виртуальная" в базовом классе позволяет переопределять ее в классе-наследнике таким образом, что при создании указателя типа базового класса на объект класса-наследника и вызове виртуальной функции через этот указатель, будет вызван вариант функции класса-наследника. 
Пример:

#include <iostream> 
using namespace std; 
 
class Base 
{     
public: 
    virtual void SayHello(){cout<<"Hello (Base)!\n";} 
}; 
class Derived : public Base 
{ 
public: 
    void SayHello(){cout<<"Hello (Derived)!\n";} 
}; 
 
 
int main() 
{ 
    Base *pExample = new Derived; 
    pExample->SayHello(); 
    return 0; 
} 


Вывод:
Hello (Derived)!

То есть виртуальные функции позволяют компьютеру определять какую функцию вызвать, даже если не известен тип объекта о котором идет речь. 

2) Для объявления виртуального базового класса. Поскольку базовый класс в производном может быть косвенно унаследован более одного раза, то для исключения создания нескольких его копий, следует объявить наследование виртуального базового класса.
Например:

class Base 
{     
public: 
    void SayHello(){std::cout<<"Hello!\n";} 
}; 
class DerivedBase1 : public virtual Base{ }; 
class DerivedBase2 : public virtual Base{ }; 
class Derived : public DerivedBase1, public DerivedBase2{ }; 
 
int main() 
{ 
    Derived D; 
    D.SayHello(); 
    return 0; 
} 


Виртуальные базовые классы предоставляют способ сохранения места и избегания неоднозначности в иерархиях при множественном наследовании.

Для чего служит ключевое слово virtual?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

1) Для объявления виртуальных функций. Объявление функции как "виртуальная" в базовом классе позволяет переопределять ее в классе-наследнике таким образом, что при создании указателя типа базового класса на объект класса-наследника и вызове виртуальной функции через этот указатель, будет вызван вариант функции класса-наследника. 
Пример:

#include <iostream> 
using namespace std; 
 
class Base 
{     
public: 
    virtual void SayHello(){cout<<"Hello (Base)!\n";} 
}; 
class Derived : public Base 
{ 
public: 
    void SayHello(){cout<<"Hello (Derived)!\n";} 
}; 
 
 
int main() 
{ 
    Base *pExample = new Derived; 
    pExample->SayHello(); 
    return 0; 
} 


Вывод:
Hello (Derived)!

То есть виртуальные функции позволяют компьютеру определять какую функцию вызвать, даже если не известен тип объекта о котором идет речь. 

2) Для объявления виртуального базового класса. Поскольку базовый класс в производном может быть косвенно унаследован более одного раза, то для исключения создания нескольких его копий, следует объявить наследование виртуального базового класса.
Например:

class Base 
{     
public: 
    void SayHello(){std::cout<<"Hello!\n";} 
}; 
class DerivedBase1 : public virtual Base{ }; 
class DerivedBase2 : public virtual Base{ }; 
class Derived : public DerivedBase1, public DerivedBase2{ }; 
 
int main() 
{ 
    Derived D; 
    D.SayHello(); 
    return 0; 
} 


Виртуальные базовые классы предоставляют способ сохранения места и избегания неоднозначности в иерархиях при множественном наследовании.

В каких случаях применяется ключевое слово const?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

1. Позволяет задать константность объекта

const int i = 8; 
i = 125; // error C3892: 'i' : you cannot assign to a variable that is const 


2. Позволяет указать, что данный метод не модифицирует члены класса, т.е. сохраняет состояние объекта. Константный метод может изменять члены класса, если они объявлены как mutable.

class Foo 
{ 
private: 
    int i; 
public: 
    void func() const 
    { 
        i = 3; // error C3490: 'i' cannot be modified because it is being accessed through a const object 
    } 
}; 


3. Позволяет задать константность указателя

int i = 4; 
int* const j(&i); 
int k = 6; 
*j = k; // Ok 
j = &k; // error C3892: 'j' : you cannot assign to a variable that is const 


4. const можно использовать со ссылками, чтобы через ссылку нельзя было поменять значение переменной.

int p = 4; 
const int& x=p; //нельзя через x поменять значение p 
x=5; //ошибка 


5. const удобен, если нужно передать параметры в функцию, но при этом надо обязательно знать, что переданный параметр не будет изменен.

void f1(const std::string& s); 
void f2(const std::string* sptr); 


В первой и второй функции попытки изменить строку будут пойманы на этапе компиляции. 
6. Объявления

int const* p2 
const int* p3 


это по разному записанное одно и то же объявление. Указатель на целое, которое нельзя менять. 
7. Для предотвращения нечаянной модификации возвращенного объекта можно объявить тип возврата как const:

const int &get_val( ... ) 

В каких случаях применяется ключевое слово const?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

1. Позволяет задать константность объекта

const int i = 8; 
i = 125; // error C3892: 'i' : you cannot assign to a variable that is const 


2. Позволяет указать, что данный метод не модифицирует члены класса, т.е. сохраняет состояние объекта. Константный метод может изменять члены класса, если они объявлены как mutable.

class Foo 
{ 
private: 
    int i; 
public: 
    void func() const 
    { 
        i = 3; // error C3490: 'i' cannot be modified because it is being accessed through a const object 
    } 
}; 


3. Позволяет задать константность указателя

int i = 4; 
int* const j(&i); 
int k = 6; 
*j = k; // Ok 
j = &k; // error C3892: 'j' : you cannot assign to a variable that is const 


4. const можно использовать со ссылками, чтобы через ссылку нельзя было поменять значение переменной.

int p = 4; 
const int& x=p; //нельзя через x поменять значение p 
x=5; //ошибка 


5. const удобен, если нужно передать параметры в функцию, но при этом надо обязательно знать, что переданный параметр не будет изменен.

void f1(const std::string& s); 
void f2(const std::string* sptr); 


В первой и второй функции попытки изменить строку будут пойманы на этапе компиляции. 
6. Объявления

int const* p2 
const int* p3 


это по разному записанное одно и то же объявление. Указатель на целое, которое нельзя менять. 
7. Для предотвращения нечаянной модификации возвращенного объекта можно объявить тип возврата как const:

const int &get_val( ... ) 

Существуют ли вложенные (nested) классы в С++?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Cуществуют. Можно объявить класс B внутри класса A. В этом случае говорят что класс B является вложенным в класс A.

Данная техника применяется для управления областью имен классов. С помощью вложенных классов можно давать более короткие имена вложенным классам. При этом информативность имени не уменьшится, так как данное имя рассматривается в контексте имени внешнего класса.

Существуют ли вложенные (nested) классы в С++?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Cуществуют. Можно объявить класс B внутри класса A. В этом случае говорят что класс B является вложенным в класс A.

Данная техника применяется для управления областью имен классов. С помощью вложенных классов можно давать более короткие имена вложенным классам. При этом информативность имени не уменьшится, так как данное имя рассматривается в контексте имени внешнего класса.

Для чего нужен аллокатор и как создать свой собственный аллокатор?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Аллокатор это шаблонный класс, который отвечает за выделение памяти и создание объектов. По умолчанию все контейнера используют std::allocator<T>. 
В языке c++ имеется так же возможность написать свой аллокатор. У своего алокатора должно быть такое объявление:

template <class T> 
    class my_allocator  
    { 
      typedef size_t    size_type; 
      typedef ptrdiff_t difference_type; 
      typedef T*        pointer; 
      typedef const T*  const_pointer; 
      typedef T&        reference; 
      typedef const T&  const_reference; 
      typedef T         value_type; 
 
      pointer allocate(size_type st, const void* hint = 0); 
      void deallocate (pointer p, size_type st); 
      void construct (pointer p, const_reference val); 
      void destroy (pointer p); 
      template <class U>  
      struct rebind { typedef allocator<U> other; }; 
    }; 

Для чего нужен аллокатор и как создать свой собственный аллокатор?

Уважаемые учащиеся ниже Вы сможете увидеть ответ, перед тем, как ответить, пожалуйста, постарайтесь написать для себя ответ на черновике, и только потом сравните наш ответ с Вашим: 

Верно ли наше решение?

Ответ:

Аллокатор это шаблонный класс, который отвечает за выделение памяти и создание объектов. По умолчанию все контейнера используют std::allocator<T>. 
В языке c++ имеется так же возможность написать свой аллокатор. У своего алокатора должно быть такое объявление:

template <class T> 
    class my_allocator  
    { 
      typedef size_t    size_type; 
      typedef ptrdiff_t difference_type; 
      typedef T*        pointer; 
      typedef const T*  const_pointer; 
      typedef T&        reference; 
      typedef const T&  const_reference; 
      typedef T         value_type; 
 
      pointer allocate(size_type st, const void* hint = 0); 
      void deallocate (pointer p, size_type st); 
      void construct (pointer p, const_reference val); 
      void destroy (pointer p); 
      template <class U>  
      struct rebind { typedef allocator<U> other; }; 
    };