Question

QUESTION 18

1. According to class materials, the program is allowed to overload operators only if at least one incoming parameter received by the operator has a class type.

   	1.	(a) True
   	2.	(b) False

QUESTION 19

1. According to the course materials, a function can take value parameters and reference parameters. A value parameter is a separate variable from the one in main() or another calling function only if the function value parameter has a different name than the one in main() or the calling function.

   	1.	(a) True
   	2.	(b) False

QUESTION 19

1. According to the course materials, a function can take value parameters and reference parameters. A value parameter is a separate variable from the one in main() or another calling function only if the function value parameter has a different name than the one in main() or the calling function.

   	1.	(a) True
   	2.	(b) False

QUESTION 21

1. Suppose you have a programmer-defined class called Data and want to overload the << operator to output the private attributes of Data to the screen in the form cout << dataObject; where dataObject is an object of class Data. In your definition of the function to overload the << operator, you have:
   
   X              // X is first line of the definition of the function to overload the << operator   
   {
       // the body of the function to overload the << operator
   }
   
   What would the correct X, the first line of the definition of the function to overload the << operator?
   
   

   	1.	(a) ostream& operator<<(ostream& output, const Data& dataObject)
   	2.	(b) ostream operator<<( ostream& output, const Data& dataObject)
   	3.	(c) ostream& operator<<(ostream output, const Data& dataObject)
   	4.	(d) ostream operator<<(ostream output, const Data& dataObject)
   	5.	(e) ostream& operator<<(const Data & dataObject, ostream& output)
   	6.	(f) ostream operator<<(const Data & dataObject, ostream& output)
   	7.	(g) ostream operator<<(const Data & dataObject, ostream output)
   	8.	(h) None of (a) through (g) is a correct answer.

Class Book has a private attribute called price (double). A method of class Book is called set_price_the_same_as(). It has a Book object model_b as the incoming parameter (as shown below). This method is called for setting the value of the private attribute priceof the implicit parameter, so that its price will be the same as that of model_b. Besides, there is a get() method and a set() method for each private attribute of Book and they are working.

  class Book
   {
      public:
         .....
         void set_price_the_same_as(Book model_b);
       .....
      private:
         .....
         double price;
       .....
    } //end of classs Book declaration

    ........

   void Book::set_price_the_same_as(Book model_b)
    {
       price = model_b.price ;
       model_b.price = 10000.0;

    }

  int main()
   {
      Book b2("Model", 90.0); //instantiating a b2 Book object with name "Model" and price $90.0
      Book b1("C++ Text", 40.0); //instantiating a b1 Book object with name "C++ Text" and price $40.00

      b2.set_price_the_same_as(b1);

      cout << "Price of Book b1 is: " << b1.get_price() << endl; //<==Statement X

      cout << "Price of Book b2 is:" << b2.get_price() << endl; //<=== Statement Y

      .......
   } //end of main()

When Statement Y is executed, it will display:

Price of Book b2 is: ____________

	1.	(a) 40.0
	2.	(b) 90.0
	3.	(c) 10000.0
	4.	(d) 130.0
	5.	(e) None of (a) through (d) is the correct answer.

QUESTION 23

1. According to class materials, if we define class MyInterface, class Class1, and class Class2 as follows:
   class MyInterface  
   {
       public:
           void Display();
   };
   void MyInterface::Display()
   {
          cout << "#Weeks";
   }
   
   
   class Class1 : public MyInterface
   {
      public:
          void Display();
   };
   void Class1::Display()
   {
          string a = "#Week1";
          cout << a;
   }
   
   
   class Class2 : public MyInterface
   {
      public:
          void Display();
   };
   void Class2::Display()
   {
          cout <<"#Week2";
   }
   
   What is the output when the following main() function is executed?
   int main()
   {
       Class1 obj1;
      obj1.Display();
      Class2 obj2;
      obj2.Display();
      return 0;
   }

   	1.	(a) Nothing would be displayed.
   	2.	(b) #Weeks#Weeks
   	3.	(c) #Week1#Week1
   	4.	(d) #Week2#Week2
   	5.	(e) #Week1#Week2
   	6.	(f) None of (a) through (e) is a correct answer.

QUESTION 25

1. According to the course material, when a derived class inherits from a base class, the base class is usually the more specialized class while the derived class the more general class.

   	1.	(a) True
   	2.	(b) False

QUESTION 26

1. According to the class material, if we define class A and class B as follows:

   class A
   {
       public:
          A(double d);
   };
     
   A::A(double d)
   {
          cout << d;
   }
           
   class B : public A
   {
       public:
            B(int n, double d);             
   };

   B::B(int n, double d) : A(d)
   {
          cout << n;
   }
   
   
   In the main() program, when we create an object of class B by using the following statement:
   
   B b(5, 4.3);
   
   What would be displayed on the console by this statement, assuming that the rest of the code in main() function is compiled successfully and execute successfully?
   

   	1.	(a) Nothing would be displayed, but the object b would be created.
   	2.	(b) 5
   	3.	(c) 4.3
   	4.	(d) 9.3
   	5.	(e) 4.35
   	6.	(f) 54.3
   	7.	(g) None of (a) through (f) is a correct answer.

QUESTION 27

1. According to class material, when we allocate a new heap variable/object using new operator, the memory allocator tells where it is located by providing the memory address, so we must declare a pointer variable to hold this address and we must use this pointer to manipulate the variable/object.

   	1.	(a) True
   	2.	(b) False

QUESTION 28

1. According to class materials, the correct function name for overloading the addition (+) operator is:

   	1.	(a) operator(+)
   	2.	(b) operator+
   	3.	(c) operator:+
   	4.	(d) operator_+
   	5.	(e) None of (a) through (d) is a correct answer

Answer 1

Dear Student ,

As per the requirement submitted above , kindly find the below solution.

Question 18:

Answer :a.true

Explanation :the program is allowed to overload operators only if at least one incoming parameter received by the operator has a class type.

**************************

Question 19:

Answer :(b) False

Explanation :Value parameters name can be same at the function call and function definition.

*************************

Question 23:

Answer :(e) #Week1#Week2

Explanation :Obj1.Display() will call method from Class1 and  obj2.Display(); will call method from Class2.

******************************

Question 25:

Answer :(b) False

Explanation :Base class is more generic class and derived class is more specific class.

***************************

Question 26:

Answer :e.4.35

Explanation :

• While calling  B b(5, 4.3); , constructor of class B is called.
• But the constructor calling A(d) and hence first value of d that is 4.3 will be printed by A's class constructor and then value of n is printed by class B 's constructor that is 5.

******************************

Question 21 :

Answer :(a) ostream& operator<<(ostream& output, const Data& dataObject)

******************************

Question 28 :

Answer :(b) operator+

Explanation :operator+ is the correct function name for overloading the addition (+) operator.

******************************

NOTE : PLEASE FEEL FREE TO PROVIDE FEEDBACK ABOUT THE SOLUTION.