Chapter 11

[Skip Breadcrumb Navigation]

Home

Student Resources

Quizzes

Chapter 11

Separate Compilation and Namespaces

This activity contains 10 questions.

How would we include the header file named "myfile.h" in an implementation file?

#include "myfile.h"#include <myfile.h>#include <myfile>#include "myfile.h";

Which of the following is not an advantage of separating the definition (.h file) from the implementation (.cpp file)?

The definition file can be included in multiple implementation files without duplication.The implementation file only needs to be compiled once, making compilation or an entire project faster.It is easier to find an associated definition with the implementation.The implementation can be changed independently from the definition.

What is the role of the linker?

The linker connects the implementation file with the definition file.The linker connects the object files created by the compiler to create an executable.The linker executes a program by interpreting the source code as executable machine instructions.The linker compiles the source code into object code.

If the following class definition is stored in a file called MyInt.h:


class MyInt {
private:
    int *p_num;
public:
	MyInt();
	MyInt(int n);
	int GetNum();
	void SetNum(int n);
	MyInt& operator=(const MyInt &rtSide);
};

What could you add to the file so that it is not included more than once if the file is used in multiple implementation files?

#ifndef  __MyInt_
class MyInt {
private:
    int *p_num;
public:
	MyInt();
	MyInt(int n);
	int GetNum();
	void SetNum(int n);
	MyInt& operator=(const MyInt &rtSide);
};
#endif

#ifndef __MyInt_
#define __MyInt_
class MyInt {
private:
    int *p_num;
public:
	MyInt();
	MyInt(int n);
	int GetNum();
	void SetNum(int n);
	MyInt& operator=(const MyInt &rtSide);
};
#endif

if (#define(MyInt))
{
class MyInt {
private:
    int *p_num;
public:
	MyInt();
	MyInt(int n);
	int GetNum();
	void SetNum(int n);
	MyInt& operator=(const MyInt &rtSide);
};
}

#define __MyInt_
class MyInt {
private:
    int *p_num;
public:
	MyInt();
	MyInt(int n);
	int GetNum();
	void SetNum(int n);
	MyInt& operator=(const MyInt &rtSide);
};
#endif

What is the major difference between a directive, such as #define, and a statement such as "if (defined) { ... }" ?

The directive is evaluated by the compiler during compile time; it does not directly generate code. The statement compiles into actual executable machine instructions.The directive is turned into C++ code. This C++ code is combined with code such as the if-statement that is ultimately compiled into machine code.There is no difference.The statement is evaluated by the compiler during compile time; it does not directly generate code. The directive compiles into actual executable machine instructions.

What is the output of the following program?


using namespace std;

namespace Foo
{
	void zot(int i) {
		cout << i << endl; 
	}
}

namespace Bar
{
	void zot(int i) {
		cout << ++i << endl; 
	}
}

int main()
{
	int x=0;
	{
		using namespace Bar;
		zot(x);
	}

	{
		using namespace Foo;
		zot(x);
	}
	
	return 0;
}

1
00
00
11
1

When your program only uses cin and cout from namespace std, why is it preferable to use:


using std::cout;
using std::cin;

instead of:


using namespace std;

By not including everything in the namespace, you are free to define your own version of classes and functions that otherwise might result in a conflicting name.This will only compile the items you are including instead of compiling everything in the namespace. To generate more lines of code for the programmer.This will only link the items you are using from the namespace instead of linking everything, producing a smaller executable.

What will the following program output?


using namespace std;

namespace Foo
{
	void zot(int i) {
		cout << i << endl; 
	}
}

namespace Bar
{
	void zot(int i) {
		cout << ++i << endl; 
	}
}

int main()
{
	int x=0;
	using namespace Bar;
	using namespace Foo;
	zot(x);
	
	return 0;
}

00
11This program will generate a compiler error because of conflicting function names from the two namespaces in the same scope.

Anything that is defined outside a namespace is automatically put in the:

std namespaceGlobal namespaceNo namespaceUnnamed namespace

How could we use cout to output a variable named "var" without adding any "using" directive at all?

i.e. there is no:


using namespace std;


using std::cout;

std::cout << var;std:cout << var;It would not be possible to access cout..

namespace std
{
  cout << var;
}

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 11

How would we include the header file named "myfile.h" in an implementation file?

Which of the following is not an advantage of separating the definition (.h file) from the implementation (.cpp file)?

What is the role of the linker?

What is the major difference between a directive, such as #define, and a statement such as "if (defined) { ... }" ?

When your program only uses cin and cout from namespace std, why is it preferable to use:
using std::cout; using std::cin;
instead of:
using namespace std;

Anything that is defined outside a namespace is automatically put in the:

How could we use cout to output a variable named "var" without adding any "using" directive at all?
i.e. there is no:
using namespace std;
or
using std::cout;

Chapter 11

How would we include the header file named "myfile.h" in an implementation file?

Which of the following is not an advantage of separating the definition (.h file) from the implementation (.cpp file)?

What is the role of the linker?

What is the major difference between a directive, such as #define, and a statement such as "if (defined) { ... }" ?

When your program only uses cin and cout from namespace std, why is it preferable to use: using std::cout; using std::cin; instead of: using namespace std;

Anything that is defined outside a namespace is automatically put in the:

How could we use cout to output a variable named "var" without adding any "using" directive at all? i.e. there is no: using namespace std; or using std::cout;

When your program only uses cin and cout from namespace std, why is it preferable to use:
using std::cout; using std::cin;
instead of:
using namespace std;

How could we use cout to output a variable named "var" without adding any "using" directive at all?
i.e. there is no:
using namespace std;
or
using std::cout;