Week 1

Question 1

Objects are instances of _______

Answer 1

classes

Question 2

Object-oriented languages offer three high-level features for programming solutions:

Answer 2

encapsulation
inheritance
polymorphism

Question 3

fundamental types:

Answer 3

correspond directly to the. hardware facilities

Question 4

built-in types:

Answer 4

reflect the capabilities of the hardware facilities directly and efficiently

Question 5

User-defined types

concrete types:
abstract types:

Answer 5

concrete types - their representation is part of their definition and is known

abstract types - their representation is not part of their definition and is unknown

Question 6

declaration:

Answer 6

A declaration introduces a name into a program and associates that name with a type.

ex.
int x;

void display();

Question 7

4 types of scopes:

Answer 7

local scope - the name has been declared within a function or code block

class scope - the name has been declared as a member of a class

namespace scope - the name has been declared as a member of a named block

global scope - the name has not been declared in any one of the above scopes

Question 8

linkage:

Answer 8

A name has a linkage if it can refer to an identical name declared in another scope. Linkage is optional.

The linkage of a name may be

external - connected across different scopes in different modules

internal - connected across different scopes within the same module

non-existent - not connected to any entity outside its own scope

Question 9

memory distinctions:

Answer 9

code segment - stores the program instructions

data segments - store data that survives the lifetime of the program

stack segment - stores local data that is, statically allocated

heap segment - stores local data that is dynamically allocated

Question 10

definition:

Answer 10

A definition is a declaration that associates a meaning with a name. A declaration may be a definition but is not necessarily a definition.

Question 11

one-definition rule:

Answer 11

A definition may not appear more than once across all translation units. No translation unit may contain more than one definition of a variable, function, class or template. If a definition appears in multiple translation units, that definition must be identical in all translation units in which it appears.

Question 12

scope:

Answer 12

The scope is the region of the program throughout which the name is valid; that is, the region where the entity identified by that name is visible.

Question 13

initializer expressions:

Answer 13

The scope of a name declared in the selection condition of a selection construct extends to the end of the construct itself.

ex.
if (int j = i % 10; j < 5) {
i -= j;

Question 14

access a shadowed global variable with the name ‘x’:

Answer 14

use the scope resolution operator:

::x

Question 15

external linkage:

Answer 15

A name with external linkage refers to an entity that is declared in a different scope within another translation unit. The C++ keyword extern identifies external linkage.

ex.

extern int share_me; // declaration

We omit this linkage keyword in the translation unit that defines and initialize the named entity:

int share_me = 0; // definition

C++ ignores the extern keyword if an initialization is present.

Question 16

internal linkage:

Answer 16

A name with internal linkage refers to an entity that is invisible outside its own translation unit, but visible to other scopes within its translation unit. The C++ keyword static identifies internal linkage.

ex.

static int local = 2;

Question 17

what is a volatile type?

Answer 17

A value stored in a volatile type is subject to side-effects and needs its memory location updated every single time that the CPU changes that value.

Question 18

what is a type definition?

Answer 18

A type definition is an alias for a type. A type definition can simplify code readability for compound types.

The C++ keyword typedef identifies a synonym for a specified type. A type definition takes the form

typedef compoundType Synonym;

Question 19

namespaces:

Answer 19

A namespace is a scope that limits the visibility of its names with respect to the program as a whole.

Question 20

using declaration:

Answer 20

To minimize repetition of scope resolution, we can expose a name within a namespace by a using declaration. A using declaration takes the form

using namespace::identifier;

Question 21

anonymous namespaces:

Answer 21

Anonymous namespaces provide a means of isolating names within a translation unit. The names declared within an anonymous namespace are only visible inside their own translation unit and invisible to all other translation units. If a definition appears in multiple translation units, it can differ across the translation units if it is within anonymous namespaces in each translation unit.

ex.
namespace {
// code here
}

Question 22

good design practice - using declarations:

Answer 22

using declarations and directives complicate header file inclusions.

Since we cannot determine the order in which header files will be included within another source file, we qualify all names within the header file with their namespace’s identifiers and the scope resolution operator. It is good design practice to avoid the using directive or declaration in any header file.

Question 23

The storage duration of a variable or object defines its lifetime within a program. Storage duration may be one of the following:

Answer 23

automatic - lasts from its declaration to the end of its scope - no keyword

static - lasts the entire lifetime of the program - use keyword static

dynamic - created using the keyword new - last until deallocated using the keyword delete

thread - lasts the lifetime of the thread - use keyword thread_local

Question 24

Three stages of the compilation process:

Answer 24

Pre-Processing Stage - the pre-processor creates a separate translation unit from the original source files for each module by inserting the header files into the implementation file and replacing or expanding any macros (lines starting with #)

Compilation Stage - the compiler creates a separate binary file from each translation unit

Linking Stage - the linker creates a single relocatable file from the binary files for all translation units and the binary files for any referenced libraries.

Question 25

Compiler options:

Answer 25

/c compile only without a link stage - create a .obj binary file. /E pre-process only - send the output to stdout. /P pre-process only - send the output to *.i file. /Wall enable all warnings.

Question 26

Linux GCC compiler options:

Answer 26

- c pre-process and compile without a link stage - create a .o binary file. - E pre-process only - send the output to stdout. - g produce information for the debugger (gdb).

Question 27

What are the optional command-line arguments the function 'int main()'

Answer 27

int main(int argc, char *argv[]); The first parameter (argc) in the command-line-arguments version of the main() function receives the number of arguments supplied on the command line from the operating system. This number includes the name of the relocatable file. The second parameter (argv) receives the address of an array of pointers to C-style null-terminated strings. Each pointer holds the address of a string that holds one command-line argument. argv[0] holds the address of the name of the relocatable file. argv[i] holds the address of the C-style null-terminated string that holds the i-th command-line argument.

Question 28

What is the keyword 'constexpr' used for?

Answer 28

The constexpr keyword declares that the value of its identifier is a run-time constant and can be evaluated at compile time. ex. constexpr int N = 8; // constant variable constexpr int factorial(int i) { // constant function return i > 1 ? i * factorial(i - 1) : 1;

Question 29

What is the keyword 'static_assert' used for?

Answer 29

The static_assert() mechanism generates a custom compiler error message if the specified condition is not met. static_assert(bool condition, const char* message); ex. static_assert(N > 0, "N <= 0");