Chapter 7

[Skip Breadcrumb Navigation]

Home

Student Resources

Quizzes

Chapter 7

Constructors and Other Tools

This activity contains 10 questions.

What will the following code fragment output?


class Foo
{
  private:
    int x;
  public:
    Foo();
    Foo(int val);
    void Print();
};

Foo::Foo()
{
   x=1;
}

Foo::Foo(int val)
{
   x=val;
}

void Foo::Print()
{
  cout << x << endl;
}

int main()
{
   Foo f1;
   Foo f2(3);
   f1.Print();
   f2.Print();
   return 1;
}

3
30
31
3This program will crash because we did not initialize f1.

What is the bug in the following code fragment?


class Foo
{
  private:
    int x;
  public:
    Foo();
    Foo(int val);
};

Foo::Foo()
{
   x=1;
}

Foo::Foo(int val)
{
   x=val;
}

int main()
{
   Foo f1();
   Foo f2(3);
   return 1;
}

The constructor must have a return type of void in the implementation. There should be no semicolon after the right curly brace in the definition of the Foo class.There should be no parentheses when declaring the variable f1 and invoking the default constructor.In the definition of the constructor, the return type of void should be specified.

What will the following code fragment output?


class Foo
{
  public:
    Foo();
    void Print();
};

Foo::Foo()
{
   cout << "In default constructor" << endl;
}

void Foo::Print()
{
  cout << "Printing" << endl;
}

int main()
{
   Foo f1, f2;   
   f1.Print();
   f2.Print();
   return 1;
}

In default constructor
Printing
In default constructor
Printing

In default constructor
In default constructor
Printing
Printing

Printing
Printing

In default constructor
Printing
Printing

Given the following classes, how can we define a BankAccount constructor that initializes the amount member variable as well as the id member variable?


class Money
{
 public:
   Money(int d, int c);
   int dollars;
   int cents;
};

Money::Money(int d, int c)
{
   dollars = d;
   cents = c;
}

class BankAccount
{
 public:
   int id;
   Money amount;
   BankAccount(int id, int dollars, int cents);
};

BankAccount::BankAccount(int newID, int dollars, int cents)
{
  id = newID;
  amount.dollars = dollars;
  amount.cents = cents;
}

BankAccount::BankAccount(int newID, int dollars, int cents)
  : amount(dollars, cents)
{
  id = newID;
}

BankAccount::BankAccount(int newID, int dollars, int cents)
  : Money(dollars, cents)
{
  id = newID;
}

BankAccount::BankAccount(int newID, int dollars, int cents)
{
  id = newID;
  amount = Money(dollars, cents);
}

Which of the following snippets of code will correctly check to see if the two Money objects have the same dollar and cent amount?


class Money
{
 public:
   Money(int d, int c);
   bool equals(Money m);
private:
   int dollars;
   int cents;

};

Money::Money(int d, int c)
{
   dollars = d;
   cents = c;
}

bool Money::equals(Money m)
{
  return ((dollars == m.dollars) && (cents==m.cents));
}

Money m1(10,50), m2(10,50);
 if ((m1.dollars == m2.dollars) && (m1.cents==m2.cents)
 {
          cout << "equal" << endl;
 }

Money m1(10,50), m2(10,50);
 if (m1 = m2)
 {
          cout << "equal" << endl;
 }

Money m1(10,50), m2(10,50);
 if (m1 == m2)
 {
          cout << "equal" << endl;
 }

Money m1(10,50), m2(10,50);
 if (m1.equals(m2))
 {
          cout << "equal" << endl;
 }

Which of the following is not a valid reason to declare a class parameter as const?
e.g.:
void someFunction(const FooClass &foo)

When you would like an indicator that the intended use of the class variable is that it should not be changed inside the function.It is more efficient to pass a class by value than by reference.When you want to pass the class by reference.XWhen you want to ensure the programmer does not change the contents of a class variable inside a function.

Why is it recommended that an inline function only be used when the function is short?

It is not recommended; the inline function can be used even when the function is long.Because inline functions include the interface with the implementation in one place.The compiler is only capable of handling inline functions that are a few lines long due to resource constraints with the number of registers in the CPU.Wherever the inline function is invoked, the contents of the function are replicated to avoid the overhead of a function call. However, this results in larger, duplicate, code that can be inefficient if the body of the function is long.

Given the class definition below:


class Compute
{
 public:
   static int square(int x);
};

int Compute::square(int x)
{
  return (x*x);
}

What is the shortest way to invoke the square function to get the square of 4?

void main()
{
  cout << square(4) << endl;
}

void main()
{
  Compute x;
  cout << x.square(4) << endl;
}

void main()
{
  cout << Compute::square(4) << endl;
}

void main()
{
  cout << Compute:square(4) << endl;
}

Give the output of this program:


class Foo
{
 public:
   static int val1;
   int val2;
   Foo(int v);
   void Print();
};

int Foo::val1 = 0;

Foo::Foo(int v)
{
 val1++;
 val2 = v;
}

void Foo::Print()
{
 cout << "val1=" << val1 << " val2=" << val2 << endl;
}

void main()
{
  Foo f1(1),f2(2);
  f1.Print();
  f2.Print();

  Foo f3(3);
  f2.Print();
}

val1=0 val2=1
val1=0 val2=2
val1=0 val2=2

val1=2 val2=1
val1=2 val2=2
val1=2 val2=2

val1=1 val2=1
val1=2 val2=2
val1=3 val2=2

val1=2 val2=1
val1=2 val2=2
val1=3 val2=2

The following code snippet intends to read 5 integers into a vector and then print them out. However, this code has a bug. What is it?


vector<int> v;
 int i, val;

 // Input values
 for (i=0; i<5; i++) {
  cin >> val;
  v.push_back(val);
 }
 // Output values
 for (i=0; i<v.capacity(); i++) {
  cout << v[i] << endl;
 }

The vector must be initialized to hold the 5 elements as:

vector<int> v(5); To store items in the vector we should use:

  v[i] = val;

instead of v.push_back(val);We must use an iterator to loop through the elements in the vector.The loop to output the values should loop to v.size() instead of v.capacity().

The Submit Answers for Grading feature requires scripting to function. Your browser either does not support scripting or you have turned scripting off.

So, the Submit Answers for Grading button below will not work.

The following Submit Answers for Grading button is provided in its place and will clear your answers:
The Clear Answers and Start Over feature requires scripting to function. Your browser either does not support scripting or you have turned scripting off.

So, the Clear Answers and Start Over button below will not work.

The following Clear Answers button is provided in its place and will clear your answers:

Your browser either does not support scripting or you have turned scripting off. Because of this, the answer choices will NOT appear in a different order each time the page is loaded, though that is mentioned below. Note that you do not need this feature to use this site.

Answer choices in this exercise appear in a different order each time the page is loaded.

Chapter 7

What is the bug in the following code fragment?
class Foo { private: int x; public: Foo(); Foo(int val); }; Foo::Foo() { x=1; } Foo::Foo(int val) { x=val; } int main() { Foo f1(); Foo f2(3); return 1; }

Which of the following is not a valid reason to declare a class parameter as const?
e.g.:
void someFunction(const FooClass &foo)

Why is it recommended that an inline function only be used when the function is short?

Given the class definition below:
class Compute { public: static int square(int x); }; int Compute::square(int x) { return (x*x); }
What is the shortest way to invoke the square function to get the square of 4?

Chapter 7

What is the bug in the following code fragment? class Foo { private: int x; public: Foo(); Foo(int val); }; Foo::Foo() { x=1; } Foo::Foo(int val) { x=val; } int main() { Foo f1(); Foo f2(3); return 1; }

Which of the following is not a valid reason to declare a class parameter as const? e.g.: void someFunction(const FooClass &foo)

Why is it recommended that an inline function only be used when the function is short?

Given the class definition below: class Compute { public: static int square(int x); }; int Compute::square(int x) { return (x*x); } What is the shortest way to invoke the square function to get the square of 4?

What is the bug in the following code fragment?
class Foo { private: int x; public: Foo(); Foo(int val); }; Foo::Foo() { x=1; } Foo::Foo(int val) { x=val; } int main() { Foo f1(); Foo f2(3); return 1; }

Which of the following is not a valid reason to declare a class parameter as const?
e.g.:
void someFunction(const FooClass &foo)

Given the class definition below:
class Compute { public: static int square(int x); }; int Compute::square(int x) { return (x*x); }
What is the shortest way to invoke the square function to get the square of 4?