Ccac C++ 001 - 010 Quizzes

Front 1

C++ not only supports OOP but also supports other programming styles.

Back 1

T

Front 2

Before a variable in C++ is used, it must be

Back 2

defined

Front 3

The person responsible for the initial development of C++ was

Back 3

Bjarne Strousrup

Bjarne Stroustrup initially developed C++ at AT&T Bell Labs in the 1980s.

Front 4

A l-value

Back 4

is assigned a value

Front 5

OOP is an acronym that means Object Oriented Programming.

Back 5

T

Front 6

Which of the following does the C++ language not support?

Back 6

automatic garbage collection

Front 7

In C++ the variables Alpha, ALPHA, and AlphA are the same identifier.

Back 7

F

Front 8

The namespace facility is a tool that assists in the study of genealogy.

Back 8

F

The namespace facility helps prevent the libraries from "preempting all the good names," and allows us to use names we want whether the library has used them.

Front 9

Which of the following types are not built into the C++ language?

Back 9

real

There is no "real" type in C++.

Front 10

In C++ the compiler will infer the type intended for a variable from the context in which the variable occurs.

Back 10

F

C++ requires every identifier to be declared prior to use. The type is specified in the declaration.

Front 11

The if, while, and for statements control only one statement.

Back 11

T

The one statement may be a block (statements that are enclosed with curly braces { }) or a simple statement.

Front 12

Suppose we have these declarations,

int x = -1, y = 0, z = 1;

This Boolean expression is correct and it does what the programmer intends:

x < y < z

Back 12

F

Unfortunately, the expression compiles without error and runs. The < operator associates (groups) left to right, so the expression evaluates as

(x < y) < z

The left hand expression evaluates to true, which, if compared to a numeric type, converts to 1. When compared to 1, this is false. What the programmer intends, expressed as mathematics might, is -1 < 0< 1, a result that is clearly true.

Front 13

The value of count is 0; limit is 10. Evaluate:

(count == 0)&&(limit < 20)

Back 13

T

Front 14

What is the value of the bool valued expression, 1 < x < 10? Does the value of this depend on the value of x? Explain and give the expression that the programmer probably meant.

Back 14

The value is always true, and the value does not depend on x.

This expression is always true. The value does not depend on x. This is the mathematicians' shorthand for what the programmer probably meant:

(1 < x)&&(x < 10).

The < operator associates (groups) left to right, so the expression evaluates as (1 < x) < 10. The expression (1 < x) evaluates to either false or true, regardless of x. These bool values convert to int values 0 or 1 when compared to int value 10. The expression evaluates to true for all values of x.

Front 15

In a switch statement, when a break statement is encountered, an immediate transfer of control is made to

Back 15

the statement beyond the end of the switch statement.

Front 16

Which of the following determines the operator that is processed prior to another operator?

Back 16

operator precedence

Front 17

A switch statement must have

Back 17

none of the above

Front 18

You want to determine whether time has run out. The following code correctly implements this:

!time > limit

Back 18

F

The expression always evaluates to false. This cannot be what the programmer intended. The compiler doesn't catch the problem because the code is legal, correct C++. Corrected code is

!(time > limit)

Code execution proceeds as follows: The operator ! takes a bool argument. It returns the opposite bool value. The value of time is converted to a bool. The value of time is certainly nonzero, hence !time is !true, i.e., false. The > compares this result with a numeric value, limit, (an int or perhaps some kind of floating point). The value on the left (false) is converted to a 0 value of that type. The value of limit is unlikely to be a negative number and we are concerned about time running out, so it is unlikely that time is zero. Consequently, the inequality becomes 0>limit, where limit is nonzero. This is false.

Front 19

Given the declaration

int x = 0;

the following expression causes a divide by zero error:

(x !=0) || (2/x < 1);

Back 19

F

The || operator uses short-circuit evaluation. The first member of this expression is true; the truth value of the complete expression can be determined from this; consequently, the second expression is not evaluated. There is no divide-by-zero error.

Front 20

Which of the following loop statements is guaranteed to iterate the body of the loop at least once?

Back 20

do body while(control);

Front 21

It is legal to replace the prototype

double totalCost(int numberParam, double priceParam);

with the more terse, alternate form

double totalCost(int, double);

Back 21

T

The alternate form applies only to function declarations. You will see this form in manuals. It is possible to omit variable names that will not be used in function definitions, but the text does not do this.

Front 22

What do the calls to exit(...) do? When exit(0) and exit(1) are called, what receives these arguments and what is done with them?

Back 22

The exit( ) function stops the program. The argument is passed to the operating system which uses it for an error code.

The other answers are foils, with nothing to recommend them except that they might sound good to some students who have not adequately prepared.

Front 23

Every programmer must know all the details of what that programmer's team mates are doing in their projects to do the work assigned. Why or why not?

Back 23

F

Only the client programmer needs to know the use to which a function is put. Only the author of the function needs to know the internals. The only thing these two share is the contract or specification of the function.

Front 24

Code after a return or a call to the exit function is executed will not be executed.

Back 24

T

Control returns to the caller if return is executed out of a called function, and returns to the operating system if return is executed out of main. If exit is executed anywhere, the program is terminated and control is returned to the operating system.

Front 25

A call to a C++ function is

Back 25

the name of the function followed by exactly the number of arguments as there are parameters in the definition.

Front 26

Procedural abstraction involves information hiding in that only the "contract" between the programmer using the function (the client) and author of a function is known to either.

Back 26

T

Under procedural abstraction, the author (or programmer) of a given function should know about how the application programmer (or the client) will use the function in the "contract." The contract is what the function is to do, and the conditions set on the parameters to guarantee that the function can do IT. The author need not know how the function is to be used by the client programmer. The client programmer only needs to know what the function does, the requirements on the parameters, but not how the function carries out the task. This way each can do his job independently of the other.

Front 27

A void function can have

Back 27

as many arguments as the programmer wishes.

The other answers are foils. This is the only correct answer, as many as the programmer wishes.

Front 28

A sequence of calls to the library function rand() generates mathematically correct random number sequences.

Back 28

F

The sequence is called pseudorandom because it appears to be random. The results are good enough to obtain usable answers with computer simulation.

Front 29

Which of the following code fragments give(s) a random double value between 2 and 5 inclusive? You can assume that the random number seed has been set and any needed definitions and initializations have been made.

Back 29

((RAND_MAX-rand())/static_cast<double>(RAND_MAX))*3 + 2

Divide and multiply associate left to right, so the expression

(RAND_MAX-rand())/static_cast<double>(RAND_MAX)

gives a double between 0.0 and 1.0. Multiplying by 3 scales this to 0.0 to 3.0, adding 2 gives 2.0 to 5.0 as required, without overflow.

Front 30

Which of the following are not names of a C++ library function?

Back 30

random

The closest library function name to random is rand, which returns pseudorandom numbers, or perhaps srand, which seeds the rand random number generator.

Front 31

There is only one kind of parameter passing in C++, namely call-by-value. Explain.

Back 31

F

There is also call-by-reference. Call-by-value makes a copy of the argument then uses that, hence does not make changes to the argument. Call-by-reference effectively passes the argument, hence can make changes to the argument.

Front 32

A call-by-value parameter may pass data only into a function.

Back 32

T

The value parameter is essentially a local variable initialized to the value of the argument at the time of a call.

Front 33

Given the following function, and the main function calling it, which, if any, of the choices below is the output of the following code? What does this function do?

#include <iostream>
using namespace std;

void func ( int& x, int & y)
{
int t = x;
x = y;
y = t;
}
int main()
{
int u = 3;
v = 4;
// ...
cout << u << " " << v << endl;
func ( u, v )
cout << u << " " << v << endl;
// ...
}

Back 33

3 4 4 3

The code swaps the values stored in the caller's arguments.

Front 34

A program should have all of its functions written before testing can begin.

Back 34

F

Functions that call other functions can be tested independently of the called functions by writing stub functions. Stub functions are very simple functions that do nothing much more than sending just enough data to the caller to allow testing.

Front 35

Functions that call other functions can be tested independently of the called functions.

Back 35

T

Functions that call other functions can be tested independently of the called functions by writing stub functions. Stub functions are substitute functions that are as simple as possible yet send data enough back to the caller to allow testing of the caller.

Front 36

The call-by-reference mechanism is specified in the function declaration and definition, using a $ between the type and the parameter.

Back 36

F

The character is an ampersand, &, not a $. It is placed between the type and the parameter to indicate a call-by-reference parameter.

Front 37

A call-by-reference parameter may pass data only out of a function.

Back 37

F

The reference parameter is an alias for the caller's argument. The mechanism is to pass the address of the argument which is used where the parameter occurs. Hence, a reference parameter makes available to the function the initial and ongoing values of the caller's argument as well as providing a mechanism for the function to change the caller's argument.

Front 38

The position of the ampersand in the function header is of no importance to the proper compiling and execution of code that uses call-by-reference parameters.

Back 38

T

It makes no difference whether the ampersand appears next to the type or the variable.

Front 39

Call-by-reference is restricted to void functions.

Back 39

F

There is no connection between the return mechanism and the parameter passing mechanism.

Front 40

Consider the following function and code segment.

void One( int first, int & second )
{
first = 17;
second = first + 1;
}
int main()
{
// other code ...
int j = 4;
int k = 3;
One(j, k);
// other code ...
}

After the call to One(j, k); what are the values of j and k? Why?

Back 40

j == 4, k == 18

The first parameter is called by value, so the parameter first is assigned 4 by the call. The parameter first is immediately assigned in the function, but the first argument is not changed, hence, j==4. The second parameter is call-by-reference, so when first + 1 is computed to be 18, and is assigned to second, second is changed, and the corresponding argument, k is changed, hence, k==18.

Front 41

No special syntax is necessary to define a function that uses a structure parameter. (This is unlike using an array parameter.)

Back 41

T

Once the structure definition has been made, a structure tag is a type that may be used in any way that a built-in type such as int or double can be used. For example, given the structure definition

struct S {/*…*/};

here is a definition of the void function func that has an S structure parameter:

void func(S y);

This is unlike using an array parameter, which requires square brackets, as well as an additional size parameter, such as

void bar(Y[] x, int size);

Front 42

There is no aggregate initialization available for structure variables. You must declare structure variables then use assignment to initialize the members.

Back 42

F

A struct can be initialized by using a sequenced of initializers very much like arrays:

struct A { int a; int b; double d;}; A x = { 1, 2, 3.0};

Front 43

Structure definitions are usually global (defined outside any functions).

Back 43

T

A structure definition is a type that, like const definitions, we usually want to be available everywhere in a program that follows the structure definition.

Front 44

Consider these hierarchical structures:

struct Date
{
int year;
//members
};
struct Person
{
Date birthDay;
//other members
};
Person Bill;

The year of Bill's birthday may be accessed as Bill.year;

Back 44

F

To access the year of Bill's birthday one must specify the Person's Date structure variable, as Bill.birthDay.year.

Front 45

The following definition of the structure variables of type myStruct s and t could be made using several definitions using the structure tag.

struct myStruct
{
int i;
double d;
} s, t;

Back 45

T

This possibility is why the semicolon is necessary at the end of a structure definition. Here is how the definitions may be rewritten.

struct myStruct
{
int i;
double d;
};
myStruct s;
myStruct t;

Front 46

A structure member is accessed using the index operator [ ], with the member name as index.

Back 46

F

Access to structure members is made by giving the structure tag, followed by a dot followed by the member name.

Front 47

A C++ structure, or struct, like the C++ array, is a homogeneous data structure (i.e., all data is of the same type).

Back 47

F

The struct provides a mechanism to define a collection of values that may be of several different types.

Front 48

A class is a type similar to a structure type that normally has member functions as well as member variables.

Back 48

T

We have treated the structure as a data members-only aggregate, as C does, and we treat the class as having function members and data members.

Front 49

A structure variable can be defined directly in the same statement that defines a structure definition.

Back 49

T

The variables s and t are structure variables of structure type myStruct under the following definitions:

struct myStruct
{
int i;
double d;
} s, t;

Front 50

A structure can have a member whose type is another structure.

Back 50

T

Structures collect, name, and give a type to related data. A subcollection of data from a structure may be so closely related that we want to make a struct of the subcollection. Example: A struct containing personal data may contain a birth date of struct type, in turn composed of day, month, and year.

Front 51

With arrays, indices start at any number the programmer chooses to indicate in the definition.

Back 51

F

Index values start at 0, not any other number, and run to one less than the declared size.

Front 52

If we want to find the median of 100 scores, we need 100 separate variables to hold the data.

Back 52

F

We can (much more easily) use an array of 100 of the type of the scores to find the median.

Front 53

Which of the following are correct? Why are the others incorrect? When a function having an array formal parameter is called, the formal array parameter

Back 53

is passed the address of the argument, and the function needs further information about the array size to safely use an array parameter.

Front 54

If you need an array with more than one index, you can use a multidimensional array, which is actually an array of arrays. In the explanation, declare an array of doubles with 2 rows and 5 columns.

Back 54

T

Perhaps the easiest way to see this is to think of a two dimensional array as an array of lines on a page. The requested declarations is

double array[2][5];

The first index is the row, or line number, and the second index is the column position within that row.

Front 55

Consider the array declaration, int x[20]; There is no memory allocated for x[20].

Back 55

T

There is memory allocated for x[0] through x[19] but not for x[20]

Front 56

In a sorting an array, the items in the array are rearranged so that for all j and k, if j < k, then array[j]<=array[k]

Back 56

T

This is sorting into increasing order. This ignores sorting into decreasing order. Care should be taken not to compare elements with index values out of the range 0 to declared_size-1

Front 57

C++ arrays check for out-of-range index values.

Back 57

F

C++ array access is directly to memory through addresses, and is designed to be as efficient as possible. The C++ Standard does not require a mechanism to detect out-of-range index values. Finally, no version of C++ this writer is aware of provides this feature.

Front 58

Given the array declaration int a[20]; the first element is written as:

Back 58

a[0]

Front 59

When using an array, it is perfectly legal to access indexed variables with index values less than 0 or greater than or equal to the declared size of the array.

Back 59

F

These index values are out of range, or simply illegal. The compiler cannot catch this. Unless you access protected memory doing this, the C++ runtime system will not catch this mistake either. The programmer has the obligation of detecting illegal index values or assuring there will be none.

Front 60

Given the two C++ array declarations: int a[10], b[10]; You can successfully compute one array, say a, then assign b to a: a = b;

Back 60

F

You cannot assign arrays in C++. Some compilers allow this, but the Standard says this is illegal, and most compilers forbid it. To do this you need to write a loop or otherwise copy individual indexed variables.

Front 61

A class member that is to be shared among all objects of a class is called

Back 61

a static member.

Static function members do not need a calling object. They provide the usefulness of global data members without the abuses that are usually associated with global members in part because the static data member is local to the class. A static member variable must be initialized outside the class (by the class author). A static member function does not use data from any object, so in that sense it is shared by all members. Static member functions act as global functions for the class without affecting the rest of the program. Like real global functions, they do not have access to data in the any object. The association of a static member function with the class is explicit and obvious, but for real global functions this is not true.

Front 62

You can write a class that is useful with all its constructors in the private section.

Back 62

F

Apart from friend of the class (something you will see later in this course) a class with all private constructors cannot create an object of the class. It seems useless to have a class for which you can have no objects.

Front 63

A constructor

Back 63

can do anything any other method can do.
usually initializes all, or most, member variables.

Front 64

A constructor is a special kind of member function. It is automatically called when an object of that class is declared.

Back 64

T

The purpose of a constructor is to automatically do any needed initialization.

Front 65

A constructor is like a function. It can return any type value needed.

Back 65

F

A constructor may not return any value, not even void. There can be no return type in front of the name.

Front 66

A constructor can be called implicitly or explicitly. (Implicitly means the compiler did it for you.) (In the interest of uniformity in answers, please use class A; for your examples.)

Back 66

T

A constructor can be implicitly called with the declaration A x;. The default constructor called explicitly with syntax is A x = A();

Front 67

Which of the following are correct?

Back 67

A class can have only one default constructor.

Front 68

Concerning nested classes, which of the following are true?

Back 68

You can define a class within a class.
The inner class is within the scope of the outer class.
Qualification by the outer class name with the scope resolution operator is necessary to use the inner class outside the outer class.

Front 69

Any use of the keyword const is a promise to the compiler, and a request to the compiler to enforce the promise. (If true, what promises?)

Back 69

T

We have seen several uses of const. A const call-by-reference parameter promises not to write code that could change the parameter, hence not to write code that could change the argument. A const identifier definition promises not to write code that could change the identifier. Finally, a const member function promises not to write code in the member function that could change the state of the calling object.

Front 70

Which of the following are accurate comparisons between call-by-value and const call-by-reference?

Back 70

Both protect against changing the caller's argument.
Call-by-value uses more memory than const call-by-reference in making the copy.
Call-by-value copies the argument whereas const call-by-reference does not.

Front 71

We reproduce the class Money here, in part:

class Money
{
public:
Money( );
Money(int theDollar, int theCents);
Money(int theDollars);
Money(double amount);
// other public members
int getCents( ) const;
int getDollars( ) const;
private:
int dollars;
int cents;
// other private members
};

Note that * is not overloaded in the class, but operator+ is overloaded using an operator function with the following declaration:
Money const operator+(const Money& amt1, const Money& amt2)

The question is, given the declarations
Money baseAmount(100, 60); // $100.60
Money fullAmount;
which of the following operations are legal? Why or why not?

Back 71

baseAmount+baseAmount.
25 + BaseAmount;
BaseAmount + 25;

Front 72

Consider this operator overloading for class Money (modified from Display 8.1 by omitting the const modifier on the return type):

Money operator+(const Money& amt1,const Money& amt2);

The following expression is legal. (If true, what could it mean, and where does the information that is assigned go?)

Money m1(17.99), m2(23.57) m3(15, 22);
(m1 + m2) = m3;

Back 72

T

Though legal, this bit of code does not mean much. What actually happens is that C++ makes an anonymous Money object to hold the results of m1+m2. This object is assigned from m3, then discarded. The const, which we removed from the return type, would make this strange assignment illegal.

Front 73

An overloaded operator= function must be a non-static class member.

Back 73

T

Front 74

You can change the behavior of + for the int type using operator overloading.

Back 74

F

Overloading any operator requires that one or more of the operands be a class object. This prevents changing the behavior of operators on primitive types.

Front 75

The rules for using operator [] are different from other operators. Which of the following statements are correct? Explain.

Back 75

Operator [] may be overloaded only as a static member function.
When writing an overloaded function for operator [], the [] follows the keyword operator, followed by one index parameter declaration between parentheses.

Front 76

A friend function has access only to the private members and member functions of the class (and all objects of that class) of which it is a friend.

Back 76

F

A friend function, like every other function, has access to any public members of any class, the class of which it is a friend included. Friendship gives the function access to all public and private members.

Front 77

One can guarantee left to right evaluation of the arguments to a comma expression overloading.

Back 77

F

Invocations of overloaded operators are function calls. All the arguments of function calls are evaluated before the function is called, but there is no guarantee that any two compilers will generate code with left to right evaluation. It is better not to overload the comma operator.

Front 78

When overloading an operator, you cannot change the number of arguments an operator takes.

Back 78

T

The compiler recognizes the operators and expects them have the usual number of arguments.

Front 79

Overloading a binary operator as a stand-alone function requires two arguments.

Back 79

T

Consider a use of the operator _:

leftAObject + rightAObject;

This translates to

operator+(rightAObject, leftAObject);

requiring two arguments.

Front 80

Operator overloading is essentially a function that uses a different syntax for invocation.

Back 80

T

Front 81

To read a character at a time, or to write a character at a time, declare a character variable ch and write this:

cin >> ch;

Back 81

F

The problem with this code is that by default, cin>>ch discards whitespace. (This default behavior can be changed, but we have a different solution.) To read a character at a time, no matter what it is, even a space, use the member functions get. The get function is a member of cin's class, and has a type char call-by-reference parameter.

Front 82

A C-string variable with a something in it is always filled with characters.

Back 82

F

A C-string is a partially filled array. If a C-string is stored in a C-string variable, the null character marks the position one beyond the last used character position.

Front 83

A C-string variable is an array, so it can be indexed to access individual character positions (indexed variables of type character).

Back 83

T

Front 84

The C-string library functions use the null terminator to decide when to stop processing.

Back 84

T

Front 85

The C-string library function strcmp compares two strings for equal length.

Back 85

F

This library function compares the first characters of the two strings with each other. In strcmp(s1, s2) if the first character of s1 is less than the first character of s2, then strcmp returns a result > 0. The reverse yields a value < 0. If characters are equal, the successive characters are examined. If the end of the strings is reached at the same index, the strings are equal, and strcmp returns 0.

Front 86

The header file that you must #include to have access to the Standard Library string class is

Back 86

string

There is no .h extension on C++ header files, nor the ones that C++ has inherited from C and then converted. C++ uses the <cstring> header. The string.h include file is a header file used by C++ prior to the C++ Standard. It is still provided by some C++ compilers for backward compatibility but its use is discouraged. String.h is an outdated header for a proprietary string library.

Front 87

C-string literals are written 'Hello'.

Back 87

F

C-string literals are spelled with the so-called double quote: "Hello"

Front 88

The preprocessor symbol NULL and the C-string terminator, the null character, share the value 0.

Back 88

T

NULL is #defined in the preprocessor to be 0. The value of the null character is '\0', which is the character that is encoded 0.

Front 89

If you want to examine an input value without actually removing it from the input stream, you can apply a member function of cin to the variable ch, which you are to assume is a char type variable. Which of these does this task?

Back 89

cin.peek(ch);

cin.peek(ch) returns the next character from the input stream without removing it from the input stream.

Front 90

It is legal to assign C-string variables.

Back 90

F

C-string variables are arrays. It is illegal to assign arrays of any kind.

Front 91

A function can return an array.

Back 91

F

A function can return a pointer to an object whose lifetime is longer than the function's lifetime, which can be a dynamic array, but arrays may not be returned by a function. Specifically, the object must not be a local variable.

Front 92

The declaration below declares three pointer variables of type pointer to double, that is, a pointer of type (double*)

double* p1, p2, p3;

Back 92

F

This declares one pointer variable, p1, and twodouble variables, p2 and p3. The * binds more closely to the variable, not to the type. In spite of this, the usually style puts the asterisk against the type. To get three pointer variables, one must write

double *p1, *p2, *p3;

or better, declare the three pointer variables on separate lines:

double *p1;
double *p2;
double *p3;

Front 93

The Big Three consists of which three from this list?

Back 93

operator=
copy constructor
destructor

Front 94

Dangling pointers present no problem in C++.

Back 94

F

A dangling pointer occurs when several pointers point to the same chunk of allocated freestore memory. If one of the pointers has had the delete pointer applied to it, releasing the freestore memory, the other pointers are said to be dangling. Because the pointer that had delete applied to it most of the time isn't
changed by the delete operation (though this is not guaranteed by any means), a deleted pointer is frequently called a 'dangling pointer.'

Front 95

Dynamic variables or dynamically allocated variables in C++ are created and destroyed according to the program's needs.

Back 95

T

Dynamic variables are unaffected by function calls or function return. This is not true of local pointer variables that may point to dynamic variables. Consequently, in a poorly written program, a local pointer can go out of scope and the dynamic variable to which the pointer points may be lost.

Front 96

When declaring several pointer variables, there must be one pointer declarator * for each pointer variable.

Back 96

T

Consider this definition of p1, p2, and p3 as pointer to doubles:

double *p1, *p2, *p3;

There must be one * for each pointer variable defined.

Front 97

The default copy constructor and default operator = provide deep copy.

Back 97

F

The default copy constructor and operator = just copy the members. This is the definition of shallow copy.

Front 98

You can get a pointer value to initialize a pointer variable from an object of an appropriate type with the "address-of" operator, &.

Back 98

T

Every object has a value and an address. The &"address-of" operator extracts the address to make it available to initialize a pointer variable of appropriate type. Example: int x; int *ptrX = &x;

Front 99

If a class is named MyClass, what must the destructor be named?

Back 99

~MyClass

That is a language design decision that several languages that support classes made.

Front 100

A pointer is a variable that holds the address of some other location in memory.

Back 100

T

Computer memory is composed of addressable chunks of information called bytes. A pointer value is the memory address stored in a pointer variable.