Why does your class have a pure virtual function?

1 To ensure that this function is overridden in derived classes that are to be instantiated

2 To maximize the execution speed of the function provided that memory is not at a premium Choice 3

3 To maximize code reuse

4 To maximize the memory efficiency provided that execution speed is not at a premium

5 To allow for templated classes to be used with friend functions

A function throws an exception of type std::unexpected. Referring to the scenario above, what is a logical cause?

1 An exception is thrown in which the type is not in the function's exception specification.

2 An exception of type std::unexpected can never be thrown in a well-formed C/C++ program.

3 An exception thrown is not yet caught and the destructor for an object throws an exception during the stack unwinding.

4 The application is targeting one operating system, but another operating system is being used, which generates the exception.

5 There is no catch-all enabled in scope closest to the function call.

Which one of the following statements is true in regarding the overloading of the ++ operator?

1 You must use a dummy parameter to define a prefix increment operator.

2 You cannot define a postfix increment operator.

3 You cannot define a prefix increment operator.

4 You must use a dummy parameter to define a postfix increment operator.

5 You cannot define both a prefix increment and postfix increment operator for a class.

class A
{
public:
    void f();
protected:
    A(){}
    A(const &A) {}
}

Referring to the sample code above, why are the default and copy constructors declared as protected?

1 To ensure that A cannot be instantiated on the stack

2 To ensure that instances of A cannot be created via new by a more derived class

3 To ensure that instances of A can only be created by subclasses of A

4 To ensure that instances of A cannot be copied

5 To ensure that A cannot be used as a base class

What is the purpose of the friend keyword?

1 It informs the linker that the current class should be linked closely to the friend class or function.

2 It allows the friend function to be notified when member variables change.

3 It allows the friend class or function to access the current class's private members.

4 It allows the current class to access the friend classes' private members.

5 It specifies that the friend functions or classes are allowed to use a class.

If a class inherits from another and overrides a virtual function, how must the exception-specification for the derived (overridden) function be related to the base function?

1 It must be at least as restrictive.

2 Derived functions cannot have exception-specifications.

3 It must be the same.

4 Virtual functions cannot have exception-specifications.

5 It must be less restrictive.

Where do you initialize a non-static class member that is a reference?

1 Point of declaration and member initialization list

2 Point of declaration only

3 Member initialization list only

4 Body of constructor only

5 Member initialization list and body of constructor

extern void done(int, int) throw(const char*, RangeErr)

Referring to the sample code above, which one of the following statements is true regarding the declaration of done?

1 done guarantees that it only throws RangeErr and character pointer exceptions.

2 done is an extern void; therefore, it does not throw exceptions.

3 done guarantees that it only throws char* exceptions.

4 done guarantees that it only throws integer exceptions.

5 done guarantees that it only throws RangeErr exceptions

With regard to enumeration types, which one of the following statements is true?

1 When an enumerator is used, its value is implicitly converted to an integer when needed.

2 Enumerators for which no value is explicitly specified have a value of zero.

3 Enumeration types must be defined in the body of a class definition.

4 An integer can implicitly be converted to an enumeration type.

5 Only one identifier in an enum list can have the value zero.

What kind of variable do you use if you need to share a variable from one instance of a class to the next?

1 volatile

2 auto

3 protected

4 register

5 static

Which one of the following is the correct way to declare a pointer to non-static member function of class A that accepts an int reference and returns void?

1 void (A*::f)(int&);

2 void (A::f*)(int&);

3 void (A::f)(int&);

4 void (*A::f)(int&);

5 void (A::*f)(int&);

Which one of the following statements replaces all elements in an integer sequence that is delimited by start and end and in which the value is less than 10 with 10?

1 std::replace(start, end, std::bind2nd(std::less<>(10)), 10);

2 std::replace_if(start, end, std::bind2nd(std::less(10)), 10);

3 std::replace_if(start, end, std::bind2nd(std::less<int>(), 10), 10);

4 std::replace(start, end, std::bind2nd(std::less<int>(), 10), 10);

5 std::replace_if(start, end, std::bind2nd(std::less<int>, 10), 10);

int x;
function()=x;

Is the assignment statement in the sample code above legal or illegal?

1 It is legal if the return type of function is a reference to int.

2 It must be illegal since the left side of the assignment operator is not an rvalue.

3 It is legal if there is an overloaded, non-member assignment operator.

4 It is legal if the return type of function is a pointer to int.

5 It must be illegal since the left side of the assignment operator is not an lvalue.

Why does your class have a pure virtual function?
1 To ensure that this function is overridden in derived classes that are to be instantiated

A function throws an exception of type std::unexpected. Referring to the scenario above, what is a logical cause?
1 An exception is thrown in which the type is not in the function's exception specification.

Which one of the following statements is true in regarding the overloading of the ++ operator?
1 You must use a dummy parameter to define a prefix increment operator.
4 You must use a dummy parameter to define a postfix increment operator.

Referring to the sample code above, why are the default and copy constructors declared as protected?
4 To ensure that instances of A cannot be copied

What is the purpose of the friend keyword?

If a class inherits from another and overrides a virtual function, how must the exception-specification for the derived (overridden) function be related to the base function?
1 It must be at least as restrictive.
3 It must be the same.
5 It must be less restrictive.

Where do you initialize a non-static class member that is a reference?

extern void done(int, int) throw(const char*, RangeErr)

Referring to the sample code above, which one of the following statements is true regarding the declaration of done?
1 done guarantees that it only throws RangeErr and character pointer exceptions.

- What is the purpose of the friend keyword?

S>А может это вопрос-ловушка (обман зрения, так сказать ) и за правильный ответ считается:

S>

void f()
{
  try
  {
    throw std::unexpected; // well formed
  }
  catch(std::unexpected un) // well formed
  {
    un();
  }
}

AG>>void f()
AG>>{
AG>>  try
AG>>  {
AG>>    throw std::unexpected; // well formed
AG>>  }
AG>  catch( void un() ) // well formed
AG>  {
AG>>    un();
AG>>  }
AG>>}
AG>>

AG>>

A function throws an exception of type std::unexpected.

namespace my { // обход запрета объявлять своё в std   
  namespace std { 
    struct unexpected{};
  }
  void f() {
    throw std::unexpected();
  }
}

 Which one of the following describes how data abstraction is used?

 Which one of the following describes the concept of inheritance?

1. It is used to cause late binding through a base type in order to achieve extensibility.
2. It is used to express the similarities between types through base and derived types.
3. It is used to express the similarities between objects that are semantically identical.
4. It is used to hide the implementation details of a defined type.
5. It is used to package attributes and functionality in order to create a new data type.

class MyClass
{ public:
   MyClass(void) {}
   virtual ~MyClass() {}
   operator int() const { return (0); }
}

int main()
{
  MyClass myclass1, myclass2;
  myclass1=myclass2;
  return 0;
}

Referring to the above sample code, which one of the following statements is true?
1. Sizeof(myclass) is 0.
2. MyClass will not have a vtable.
3. Void is an illegal constructor argument type.
4. The assignment operation is invalid.
5. MyClass is declared incorrectly.

class Base {
public:
  Base();
  virtual ~Base();
};

class Derived: protected Base {
public:
  virtual ~Derived();
};

int main()
{
  Base *pb=new Derived;
  return 0;
}

Question:  What is the error in the sample code above?
1. "Derived" cannot have a virtual destructor in a derived class.
2. "pb" cannot be type cast from "Derived" to "Base".
3. There is nothing wrong with the sample.
4. A constructor needs to be added to class "Derived".
5. A pointer to a base class cannot point to an instance of a derived class.

class Derived: protected Base {
...
 public:
  Base* GetBase() { return this; }
...
};

Derived *pd=new Derived;
Base *pb=pd->GetBase();

class Base {
public:
  Base();
  ~Base();
  int GetBaseNum();

private:
  int baseNum;
};

class A: public Base {
public:
  A();
  ~A();
  float GetBaseNum();

private:
  float baseNum;
};

What concept is represented by the sample code above?
1. Polymorphism
2. Virtual Function
3. Recursion
4. Inheritance
5. Function overloading

13.2 Declaration matching

...

class B {
public:
int f(int);
};

class D : public B {
public:
int f(char*);
};

Here D::f(char*) hides B::f(int) rather than overloading it.