Crowdly

Add to Chrome

Course 58

Looking for Course 58 test answers and solutions? Browse our comprehensive collection of verified answers for Course 58 at courses.apriorit.com.

Get instant access to accurate answers and detailed explanations for your course questions. Our community-driven platform helps students succeed!

Why doesn't the catch block receive the exception, and what happens instead?
#include <iostream>

#include <stdexcept> void Foo() noexcept{ throw std::runtime_error("oops");} int main(){ try { Foo(); } catch (...) { std::cout << "caught"; }}

The exception occurs before entering the try block

catch(...) cannot catch std::runtime_error - a typed catch is required

Violating the noexcept contract causes std::terminate() to be called

The compiler removes the throw inside noexcept as an optimization

100%

View this question

Reminder to complete the English test. Have you already taken the test?

Link: https://assessment.corporate.ef.com/public/test/d19cf15c-fc35-4d8c-8b20-75b9514e6b5d

What will the program output and which C++ mechanism causes this result?What will the program output and which C++ mechanism causes this result?
#include <iostream>

class A{public: virtual void Foo() { std::cout << "A"; }}; class B : public A{public: void Foo() override { std::cout << "B"; }}; int main(){ B b; A a = b; // ! a.Foo();}

Won't compile - cannot assign B to A

"A" - object slicing occurs, the B-part is cut off, virtual dispatch does not work through value

100%

"B" - virtual dispatch works through value too

"AB" - first the A-part is copied, then B::Foo is called

View this question

What value will m_val have after constructing an object of type A?
class

A{public: A() : m_val(42) {} private: int m_val = 10;};

100%

Undefined behavior

View this question

What will the program output and which C++ feature determines this result?
#include <iostream>

class A{public: virtual void Foo() { std::cout << "A::Foo"; } void Bar() { Foo(); }}; class B : public A{public: void Foo() override { std::cout << "B::Foo"; }}; int main(){ A* obj = new B(); obj->Bar(); delete obj;}

"B::Foo" - virtual dispatch through this works even inside a base class method

100%

Won't compile - Bar() is not declared in class B

"A::Foo B::Foo" - first call in A, then override in B

"A::Foo" - Bar() is defined in class A, so Foo() is called as A::Foo

View this question

Which special function is called in expressions (1) and (2)?
class

MyClass { /* ... */ }; MyClass a;MyClass b = a; // (1)MyClass c;c = a; // (2)

(1) default constructor, (2) copy assignment operator

(1) copy assignment operator, (2) copy constructor

(1) copy constructor, (2) copy assignment operator

100%

(1) copy constructor, (2) copy constructor

View this question

Which overload of Foo is selected for each call and why?
#include <iostream>

void Foo(int n) { std::cout << "int "; }void Foo(int* p) { std::cout << "ptr "; } int main(){ Foo(NULL); // (1) Foo(nullptr); // (2)}

(1) int, (2) int - nullptr also converts to int

(1) ptr, (2) ptr - both are null pointers

(1) int, (2) ptr - NULL is 0 (type int), nullptr has type nullptr_t

100%

(1) Compile error, (2) ptr

View this question

When is variable n initialized and how many times during program execution?
#include <iostream>

void Counter(){ static int n = 0; std::cout << ++n << " ";} int main(){ Counter(); Counter(); Counter();}

On every call to Counter() - like a regular local variable

At program startup, once - like a global variable

On the first call to Counter(), once - the value is preserved between calls

100%

Undefined behavior - static inside a function is an error

View this question

Which statement correctly describes the difference between these two declarations?
const

int* p1; // Aint* const p2; // B

A - address is immutable; B - value is immutable

A and B are identical - both are pointers to const int

A - value is immutable; B - address is immutable

100%

A - everything is immutable; B - everything is mutable

View this question

What will the program output?
#include <iostream>

int main(){ int x = 2147483647; // INT_MAX std::cout << (x + 1);}

-2147483648

100%

Undefined behavior

2147483648

View this question

Want instant access to all verified answers on courses.apriorit.com?

Get Unlimited Answers To Exam Questions - Install Crowdly Extension Now!

Add to Chrome

Telegram Instagram TikTok Question Bank