11.12. Multiple Choice Exercises¶

Q-1: Select all the true statements.

In C++, anything done with a member function can also be done by a free-standing function
Though sometimes there may be an advantage of one over the other this process is doable and converting from one form to the other is a mechanical process
In a function that operates on 3 structures, 2 are accessed with dot notation
There is one implicit structure, and two structures that need to be accessed with dot notation.
The scope resolution operator should be used every time you work with data structures and implement member function inside the structure definition.
The scope resolution operator need not be used everytime one works with structures and is used to implement member functions outside the class definition.
The this keyword is used to refer to the current object
The this keyword is a pointer to the current object.

Q-2: What is the correct way to declare a member function called student_email outside the structure definition and takes a Student object as a parameter by reference?

Student::student_email(const Student& s1)
This is the proper way to declare a member function student_email that passes a Student object by reference.
student_email(Student)
This is not the proper way to pass a Student object and declare a member function.
Student::student_email(Student s1)
Close! Look closely at the answer choices again and the methos of passing the parameter.
student_email(Student& s1)
This is not the proper way to declare a member function.

Q-3: Which of the following options should replace the blank in the following code?

struct StarWars {
  string name;
  int num_appearences;
  bool isJedi;

  bool isMainCast ();
};

______________________ {
   if (character.num_appearences >= 3) {
      return true;
   }
   else {
       return false;
   }
}

int main () {
  StarWars character;
  character = (StarWars){ "Rey", 3, true};
  character.isMaincast();
}

bool StarWars::isMainCast ()
Correct!
void StarWars::isMainCast ()
Pay close attention to the function implementation adn return type
bool isMainCast ()
As the function was implemented outside the class definition a scope resolution operator must be used.
bool isMainCast (StarWars& character)
As the function was implemented outside the class definition a scope resolution operator must be used. Additionally, the object is passed implicitly.

Q-4: What is the output of the code below?

struct Cube {
  int mass;
  int density;


  //function to check if the current cude has a higher density than another
  int greater_density (const Cube& cube2) {
      if (density > cube2.density) {
         return true;
      }
      else  {
         return false;
      }
  }
};

int main() {
  Cube c;
  Cube c1;
  c.mass = 128;
  c1.mass = 120
  c.density = 2;
  c1.density = 50;
  cout << c.greater_density(c1) << endl;
}

True
The output of a bool is either a 0 or 1.
False
The output of a bool is either a 0 or 1.
0
Then density of c (2) is not greater than that of c1 (50).
1
Is density of c greater than c1?

Q-5: What are the values stored in the p1 object below?

struct Penguin {
  int age;
  string gender;

  Penguin();
};

Penguin::Penguin () {
  age = 1;
  gender = "female";
}

int main() {
  Penguin p1;
}

1 and “female”
Correct! The constructor was called to store age as 1 and gender as female in p1.
No values, the constructor cannot be invoked as it is out of the struct
The scope resolution operator allows for a member function outside the structure definition to be invoked by the class type.
0 and “”
In such a scenario a default constructor is not called. Pay attention to the constructor values implemented.
No values, nothing was assigned to age and gender and the constructor was never called
Upon creation of the Penguin p1 the constructor initialises the object automatically

Q-6: Will the following program run and if so, what does this program aptly depict?

struct Penguin {
  int age;
  string gender;

  Penguin();
  Penguin(int age_in, string gender_in);
};

Penguin::Penguin () {
  age = 1;
  gender = "female";
}

Penguin::Penguin(int age_in, string gender_in) {
  age = age_in;
  gender = gender_in;
}

int main() {
  Penguin p1;
  Penguin p2(3, "male");
}

This program does not run as the presence of two constructors will throw a compile error.
Constructor overloading is possible.
Friend constructors
“Friend” constructors are constructors that are private except to the friend class.
Constructor overriding
Overriding is the ability of an inherited class to rewrite the methods of the base class at runtime. Constructors cannot be overwritten
Overloading
Correct! The constructors are overloaded as they have the same the name but different number of arguments.

Q-7: What statements are true based on the following Stundent.h header file?

struct Student {
  // Instance variables
  int age, id;
  string year;

  // Constructors
  Student (int age, int id, string year);
  Student (string year);

  // Modifiers
  void increment (int age);

  // Functions
  void print () const;
  bool isJunior (const Student& student2) const;
  Student add (const Student& s2) const;
};

The Student.cpp file will have the definitions of the member functions.
This is true!
Student.cpp needs to #include the header file.
This is true!
The Student.cpp file must implement the member functions in the same order as the declarations.
This is not necessary.
Header files contain the structure/function definitions and by splitting the program into multiple files one can compile the files seperately and link it to a single program later.
This is true!

Q-8: What is the output of the code below?

struct Penguin {
  int age;
  string gender;

  Penguin();
  Penguin(int age_in, string gender_in);
};

Penguin::Penguin () {
  age = 1;
  gender = "female";
}

Penguin::Penguin(int age_in, string gender_in) {
  age = age_in;
  gender = gender_in;
}

int main() {
  Penguin p1;
  Penguin p2(3, "male");
  cout << p2.age << " " << p1.gender << endl;
}

3
p1 is initialised using the Penguin() constructor, its gender variable would not be null.
3 female
Correct!
1 male
Pay closer attention to the values being printed!
No output. The code won’t compile.
Constructor overloading is allowed!

Q-9: What is the output of the code below?

struct Point3D {
  int x, y, z;

  Point3D () {
    x = 4;
    y = 2;
    z = 3;
    cout << "Sum of relevant variables = " << x+x+y << endl;
  }
};

int main() {
Point3D p1;
}

Sum of relevant variables =
Take a closer look Point3D ( )
Sum of relevant variables = 9
Take a closer look at what is outputted in Point3D ( )
Sum of relevant variables = 10
Correct!
No output is printed.
Remember what you clearned about constructors and when they’re called

Q-10: Select all the true statements.

When we call a member function we invoke the function on the data structure
When called, the member function is invoked on the data structure
In a member function, you should declare the implicit parameter to be const before the parameter list
The implicit parameter should be declared const after the parameter list
In the example x::y the scope resolution operator indicates that a function named y can be invoked on a structure x
When defining a member function outside of the sturucture definition the :: operator is used to indicate that an object of that class type can call the function is question.
Implicit variable access in member functions allows us to access member variables without the dot notation
Correct! Implicit variable access allows us to access variables directly