Результаты прохождения теста C++ основы пользователем Валерий_Жбанов

Результат прохождения теста "C++ основы" - Не пройден

+53

Сколько конструкторов и деструкторов может быть у одного класса (выберите наиболее точный вариант)?
Ваши ответы
Несколько конструкторов, один деструктор
Что выведет программа:
#include <iostream> 
 
class A { 
   void foo(){ 
     std::cout << "A::foo()"; 
   } 
}; 
 
struct B { 
   friend A; 
   friend void foo(){ 
      class A a; 
      a.foo(); 
   } 
}; 
 
int main() 
{ 
   foo(); 
} 
Ваши ответы
ничего не выведет, так-как будет ошибка компиляции
Что будет напечатано в консоль?
#include <iostream> 
 
int main() 
{ 
   int a = 1 << 2; 
 
   switch (a) 
   { 
   default: 
       std::cout << "0"; 
   case 1: 
       std::cout << "1"; ++a; break; 
   case 2: 
       std::cout << "2"; 
   case 3: 
       std::cout << "3"; break; 
   } 
 
   return 0; 
}
Ваши ответы
01
Объяснение:

<< — операция побитового сдвига. Фактически такая операция даёт умножение левого операнда на 2 в степени правого операнда, соответственно a инициализируется значением 4.
Поскольку ни одна из меток case не соответствует значению 4 управление передаётся метке default.
Поскольку в конце этой метки отсутствует break, управление передаётся следующей.
Изменение значения a в case 1 не приведет к передачи управления case 2 поскольку break передаёт его оператору следующему за switch.
Поэтому в консоль будет выведено "01"

Какие из перечисленных фрагментов кода не содержат ошибки?
Ваши ответы
// 2 
const int i = 0;  
int j = i;  
// 3 
int i = 0; 
int j = i; 
Объяснение:

(1) ссылка должна быть с модификатором const.
(2) все нормально, значение константы i копируется в переменную j

Выберите правильный вариант ответа в 32-ух битной операционной системе (автоматическое выравнивание не определено):
class A 
{ 
      char A; 
      int B; 
      double C; 
}; 
class B 
{ 
     char A; 
     double C; 
     int B; 
};  
Ваши ответы
sizeof(A)
Объяснение:

Компилятор для быстрого доступа к переменным выравнивает их по наибольшему размеру. В классе А переменная A и B выравниваются в 8 байт (1 байт char и 4 байт int) по максимальной переменной double C 8 байт. sizeof(A) равен 16 байтам. В классе B переменная A выравнивается по С, переменная B - аналогично, потому что компилятор обрабатывает переменные в их последовательности объявления. sizeof(B) равен 24 байтам.

Что мы увидим на экране в следствии выполнения этого кода?
#include <iostream>   
 
void a(int *pa) 
{ 
   pa = new int(3); 
} 
 
int main()  
{ 
   int s(5); 
   int *ps = &s; 
   a(ps); 
   std::cout << *ps << std::endl; 
       return 0; 
}
Ваши ответы
5
Что напечатает программа?
#include <iostream> 
 
int main() { 
   int i=0; 
   do { 
       i++; 
       if(i < 10) continue; 
       std::cout << i; 
   } while(false); 
 
   std::cout << i; 
   return 0; 
} 
Ваши ответы
1
Объяснение:

По стандарту оператор continue передаёт управление (в нашем случае) в конец цикла.
§6.6.2 in the standard: "The continue statement (...) causes control to pass to the loop-continuation portion of the smallest enclosing iteration-statement, that is, to the end of the loop." (Not to the beginning.)

Какое значение выведет программа на х86?
#include <stdio.h> 
#include <iostream> 
 
int main() 
{ 
   char* str = "Hello"; 
   std::cout << (sizeof(str) + sizeof(',') + sizeof(" world!")); 
   return 0; 
}
Ваши ответы
13
За что отвечает аргумент argv?
int main(int argc, char* argv[])
Ваши ответы
Массив указателей на аргументы, которые передаются в качестве строковых переменных.
Объяснение:

Аргумент argv является массивом указателей на аргументы, которые передаются в программу при запуске. То есть каждый элемент массива является указателем на одно слово.

Какое будет поведение следующей программы
#include <iostream> 
using namespace std; 
 
template <typename T> void foo(T& a, T b = T()) 
{ 
   cout<<"a = "<<a<<", b = "<<b<<endl; 
} 
 
int main() { 
   foo(3); 
   return 0; 
} 
Ваши ответы
Выведет a = 3, b = 0
Скомпилируется ли следующий код?
#include <iostream>  
 
class X {}; 
class Y : X {}; 
 
int main()  
{  
   X *pX = new Y; 
 
   return 0;  
}
Ваши ответы
Да
Объяснение:

Будет получена ошибка доступа при приведения типа Y* к X*, так как модификаторы protected или private запрещают приведения указателя на класс наследник к указателю на базовый класс. В данном примере класс Y наследует от класса X с модификатором private, так как явное задание модификатора отсутствует.

Что будет выведено на экран в результате работы программы?
#include <iostream> 
 
class A { 
public: 
   explicit A(int _k = 10) {k = _k;} 
   int k; 
}; 
 
int main() { 
   A a = int(100); 
   std::cout << a.k;   
} 
Ваши ответы
100
Объяснение:

Т.к. конструктор по умолчанию объявлен как explicit он не будет являтся конструктором преобразования типа. Возникнет ошибка компиляции.

Какие строки вызовут ошибку компиляции?
#include <iostream> 
template <typename T1, typename T2> void f(T1 x, T2 y) { 
   std::cout << x << " " << y <<     std::endl; 
} 
 
class A { 
public: 
   A(int x) : val(x) { } 
 
private: 
   int val; 
}; 
 
int main() { 
   f<char>('1', "2");          // 1 
   f<string>('1', "2");        // 2 
   f('1', "2");                // 3 
   f<A, int> (1, 2);           // 4 
   f(1.0, 2);                  // 5 
   return 0; 
} 
Ваши ответы
2
4
5
В каких строках возникнет ошибка компиляции?
void foo(int const* x, int* const y) 
{ 
   int a; 
 
   *x = 5; //1 
   x = &a; //2 
   *y = 5; //3 
   y = &a; //4 
 
} 
int main() 
{ 
   int x,y; 
   foo(&x,&y); 
} 
Ваши ответы
//2
//3
Объяснение:

Для того, чтобы правильно ответить на этот вопрос, можно использовать простое правило-запоминалку. Нужно читать объявление аргумента функции справа налево: int const* x // x это указатель на константный int (нельзя менять значение переменной, на которую указывает указатель //1) int *const y // y это константный указатель на int (нельзя менять значение указателя //4)

Каков результат работы следующей программы?
#include<iostream>
 
using namespace std;
 
main() {
    int *p = new int;
    delete p;
    delete p;
 
    cout << "Done";
}