Programming exam

Question 1

Declaration/ header (.h)

Answer 1

In the header file, a developer provides the declaration of a class’ interface. In essence, this gives the “shape” of the class

Question 2

Definition/Implementation (.cpp)

Answer 2

In the definition file, a developer provides the code that is run each time a function member is called.

Question 3

Use/ Driver (.cpp)

Answer 3

In a driver file, an external program references the header file using a #include statement and uses the class members (via objects or instances of that class) to solve a problem.

Question 4

Class Declaration

Answer 4

A class declaration takes this general form
class <class>{
private:
//a series of private data and function member declarations
public:
//a series of public data and function member declaration</class>

Question 5

Class Definition

Answer 5

The definition of a class provides definitions for functions that are declared in the class declaration. This linking is performed using the scope resolution operator “::” between the class name and the member name. An example definition would look like this:

<return> <class>::<function> (<parameter>) {

//code goes here

}
</parameter></function></class></return>

Question 6

Using a Class

Answer 6

In a driver program, one would first create instances of a class by declaring a variable of the appropriate type:

Employee e;

After the variable is declared, the programmer now has access to all of the public data and function members using the class member access operator, also known as the “dot” operator:

e.Inactivate()

Question 7

Compiling a Class and Driver

Answer 7

While one could use a single command approach to compilation, it is better to use a multi-step approach that separates the header file from compiled source code. An example compilation of a class and driver with the three files outlined above would be:

Step 1: g++ -c <class>.cpp
Step 2: g++ -c <driver>.cpp
Step 3: g++ <class>.o <driver>.o -o <desired>.exe
In English:</desired></driver></class></driver></class>

Step 1: compile the class source code into consumable object code
Step 2: compile the driver class into object code
Step 3: link the class object code with the driver object code to create an executable file

Question 8

Private class members

Answer 8

can only be accessed within the definition of a class. That is, any attempt to reference a private data or function member from a function or code location that is not associated with the same class using the scope resolution operator (::) is a syntax error.

Question 9

Public class members

Answer 9

can be accessed from anywhere an object of the appropriate type is available. The most common example would be a driver program using public function members from an object of a class declared as a local variable within that driver program.

Question 10

Constructors

Answer 10

Constructors are special function members that are used to create objects or instances of a class. These functions contain behavior that is run when a driver program creates a variable with the type of your class.
Initialization: Initialize the object’s attributes when it is created.
Same Name as Class: It has the exact same name as the class.
No Return Type: Constructors do not have a return type, not even void.
Automatically Called: It gets called automatically when an object is created.

Question 11

Accessors

Answer 11

are public function members used to access the private value

Question 12

Mutators

Answer 12

are public function members used to change the private value.

Question 13

Getters

Answer 13

are accessors that only provide access to a private data member.

Question 14

Setters

Answer 14

are mutators that set a private data member to a value specified as a passed in parameter

Question 15

A(n) ___________ function has access to both public and private data members of a class but is NOT a member function:

Answer 15

friend

Question 16

Classes encapsulate two types of members: function members that define business logic and ______ members that define the state of a class.

Answer 16

data

Question 17

_______ is a keyword used to ensure that conversion constructors are NOT used implicitly.

Answer 17

explicit

Question 18

The _______ operator is used to link a member function to a class.

Answer 18

::

Question 19

The _____ design methodology is used when creating a C++ program or class.

Answer 19

DDU

Question 20

When creating an operator override, the keyword _______ is used to name the implementation method:

Answer 20

operator

Question 21

The name of a destructor must begin with the special character:

Answer 21

~

Question 22

A(n) ________ is used to set constant data members of a class:

Answer 22

Initialization list

Question 23

++ is a(n) _______ operator.

Answer 23

Unary

Question 24

The keyword “friend” is used in a functions’s:

Answer 24

Declaration

Question 25

Conversion constructors can accept multiple paramters (T/F)

Answer 25

False (can only have one parameter, its the type its converting from)

Question 26

Destructors accept only one parameter (T/F)

Answer 26

False

Question 27

A class can have only one implementation of an override for a given operator (T/F)

Answer 27

True

Question 28

A driver program cannot access private data or function members. (T/F)

Answer 28

True

Question 29

Constant member functions can call other non-constant functions. (T/F)

Answer 29

False

Question 30

A class can have an arbitrary number of constructors. (T/F)

Answer 30

True

Question 31

The -c flag is used to create object code from a source cpp file with g++. (T/F)

Answer 31

True

Question 32

Classes are instances of objects. (T/F)

Answer 32

False

Question 33

A driver program can create an arbitrary number of objects from a class. (T/F)

Answer 33

True

Question 34

A setter should always be marked const. (T/F)

Answer 34

False

Question 35

A ________ member can be accessed outside of the class implementation but a ______ member cannot.

Answer 35

public, private

Question 36

Getters are a special type of ______ that provide access to _____ state.

Answer 36

accessor, private

Question 37

A _________ is a special function member that specifies defaulting logic for a class’ data members.

Answer 37

Constructor

Question 38

Which of the following is TRUE about constructors?

Answer 38

They are a function with the same name as the class

Question 39

The header file is responsible for declaring the ________ for a class

Answer 39

interface

Question 40

What are the two steps in the compilation process for C++?

Answer 40

Compile step and linking step

Question 41

What is the correct g++ flag to perform only the compile step of compilation?

Answer 41

-c

Question 42

Which of the following file extensions is used to declare a programming interface in C++?

Answer 42

.h

Question 43

A programming ___________ provides a public menu of behavior and state that can be used by a consuming piece of code

Answer 43

interface

Question 44

What is the C++ operator that is used to “connect” a function definition to a class declaration( i.e, the scope resolution operator)?

Answer 44

::

Question 45

A _________ class is another name for a main class that consumes a piece of code.

Answer 45

driver

Question 46

To create a friend function, the “friend” keyword is used in the definition of the function. (T/F)

Answer 46

False

Question 47

True or False: The scope resolution operator is NOT needed when defining a friend function.

Answer 47

True

Question 48

True or False: All conversion constructors are parameterized constructors but not all parameterized constructors are conversion constructors.

Answer 48

True

Question 49

True or False: Only one class can be declared within a header file.

Answer 49

False

Question 50

True or False: Friend functions must always be public.

Answer 50

False

Question 51

True or False: Const member functions can only call other const functions.

Answer 51

True

Question 52

How many times would the word “const” appear in the declaration of a constant function that returns a constant value and takes in two constant parameters by value?

Answer 52

4

Question 53

True or False: In C++, you can create a non-constant object that contains constant data members and constant function members.

Answer 53

True

Question 54

What is the naming convention for a destructor in C++?

Answer 54

A destructor should always be named with a tilde (~) followed by the class name. For example: ~ClassName().

Question 55

Where should destructors be declared and can they have parameters?

Answer 55

Destructors should always be declared in the public section of the class and they do not take any parameters.

Question 56

How many destructors can a class have and do they need to be explicitly called?

Answer 56

A class can only have a single destructor. Destructors are called implicitly when an object instance falls out of scope, so they do not need to be explicitly called.

Question 57

When is it necessary to define a custom destructor for a class?

Answer 57

It’s necessary to define a custom destructor if the class contains an unmanaged resource like a database connection, a file handle, or contains a pointer to memory allocated within the class definition. Otherwise, the default destructor is often sufficient

Question 58

What is the primary purpose of a destructor?

Answer 58

The primary purpose of a destructor is to release resources and perform cleanup when an object is destroyed, which occurs when it goes out of scope, such as when a function returns or a conditional code block containing the declaration of the object ends.

Question 59

True/False: All objects are given a default destructor in C++

Answer 59

True. All objects are provided a default destructor in C++, which in many cases is all that is needed, especially when the class doesn’t manage any external resources or allocate dynamic memory.

Question 60

What are some scenarios in which a destructor is called?

Answer 60

A destructor is called implicitly when an object falls out of scope, such as when a function returns, a conditional code block containing the declaration of the object ends, or when the program execution leaves the scope in which the object is defined.

Question 61

What are the three main components of operators in C++?

Answer 61

Operators in C++ have three main components: a return type, a name, and a list of parameters.

Question 62

Can you change the precedence, associativity, or the number of parameters of an operator in C++?

Answer 62

No, you cannot change the precedence, associativity, or the number of parameters of an operator in C++ during operator overloading

Question 63

What is “arity” in the context of operators, and what are its types?

Answer 63

“Arity” refers to the number of parameters that an operator accepts. Unary operators accept one parameter, binary operators accept two, and (although rare and not directly supported in C++) tertiary operators would theoretically accept three.

Question 64

How must operators be named when being overloaded in C++?

Answer 64

When overloading operators in C++, they must be named using the keyword “operator” followed by the operator symbol being overloaded. For example, overloading the plus operator would be named “operator+”.

Question 65

Can you create new operators or change the behavior of operators on primitive or built-in types in C++?

Answer 65

No, you cannot create new operators or change the behavior of operators on primitive or built-in types in C++.

Question 66

Can operator overloads be implemented as both member and friend functions, and is there a general rule on which to use?

Answer 66

Yes, operator overloads can be implemented as either member or friend functions. There’s no hard and fast rule, but member function operator overloads are typically used unless the left operand needs to be converted, which requires a friend function.

Question 67

What is encapsulation in the context of classes in C++?

Answer 67

Encapsulation is a core coding practice where different data types (like int, string, etc.) are bundled together into a user-defined type (e.g., a class named “Employee”). This allows for easier storage and retrieval of data related to specific entities and also enables associating behavior (functions) with data (data members).

Question 68

What are the data members in a class and what do they represent?

Answer 68

Data members in a class, often referred to simply as “members” in C++, are variables declared within a class. They represent the state of an object, holding values that define properties or attributes of objects created from that class.

Question 69

What are function members in a class and how do they relate to encapsulation?

Answer 69

Function members, or member functions, in a class encapsulate behavior that is directly related to objects of the class. They perform operations on the object’s data members or interact in some way with the object’s state, ensuring that behavior relevant to the data is kept together with the data itsel

Question 70

If classes are considered blueprints, what are objects in C++?

Answer 70

Objects in C++ are instances of classes. If a class provides the blueprint (defining properties and behaviors), an object is an individual instantiation of that class, with its own specific state defined by the values of the data members. For example, if Employee is a class, empl1 could be an object of type Employee.

Question 71

What is the distinction between private and public class members in C++?

Answer 71

Private class members can only be accessed within the class’s definition, whereas public class members can be accessed from any location where an object of the class type is available, including from functions in a driver program.

Question 72

In general, how should data members and function members be designated in terms of access modifiers, and why?

Answer 72

Data members should mostly be private to prevent unintended states by external code and to maintain encapsulation.
Function members should be public if they offer functionality meant to be accessed externally.
Function members should be private if they are meant for internal use within the class, and not to be used by external or driver code.

Question 73

Can one instance of a class access private members of another instance of the same class in C++?

Answer 73

Yes, one instance of a class can access private members of another instance of the same class because they share the same definition. However, this can be considered unsafe practice in many cases, especially when internal data validation standards need to be met through public accessors.

Question 74

Why might it be considered unsafe or unwise to directly access private members of another instance of the same class?

Answer 74

Direct access to private members might bypass internal data validation which is often implemented through public accessors, potentially allowing the object to enter an invalid state. Using public accessors, even within the class definition, ensures that all interactions with the data adhere to the validation and manipulation rules defined by the class.

Question 75

What is the role of a constructor in C++?

Answer 75

Constructors are special function members in C++ used to create objects or instances of a class, initializing their state, and executing any behavior that needs to occur when an object is created.

Question 76

Are constructors typically public or private, and why?

Answer 76

Constructors are typically declared public because they need to be accessible to driver programs or other code outside the class, enabling them to create objects of the class type.

Question 77

Can you have multiple constructors and how are they typically used?

Answer 77

Yes, a class can have multiple constructors, including the default constructor and parameterized constructors that accept arguments to initialize the object in specific ways. Parameterized constructors allow objects to be initialized with specific data at the time of creation.

Question 78

What is a conversion constructor and how is it used in C++?

Answer 78

A conversion constructor is a constructor that takes a single parameter and allows implicit conversion from the type of its parameter to the class type.Example:
Employee(int code);
allows
Employee e = 10101; // implicit call to the conversion constructor
It converts the int value 10101 into an Employee object, using that value to initialize the object.

Question 79

What is the explicit keyword in the context of constructors and why might it be used?

Answer 79

The explicit keyword prevents implicit conversions and requires that the constructor be called explicitly. If explicit is used in the declaration like:

explicit Employee(int code);

then implicit calls like Employee e = 10101; would result in a syntax error at compile time, and only explicit calls like Employee e(10101); would be allowed.

Question 80

How are objects instantiated using constructors?

Answer 80

Objects can be instantiated by calling the constructor explicitly, like:

Employee e1, e2, e3;
// Default constructor
Employee e(10101);
// Parameterized constructor

or, if no explicit keyword is used with a single-parameter constructor, via implicit conversion, like Employee e = 10101;.

Question 81

What is the primary purpose of accessors and mutators in a class?

Answer 81

Accessors are public function members used to access private data members, while mutators are used to modify them. They are utilized to implement encapsulation and data protection in a class, ensuring that data is accessed and modified in a controlled and safe manner.

Question 82

Define getters and setters, and how do they specialize accessors and mutators?

Answer 82

Getters are a specialized type of accessor that solely provide access to a private data member.
Setters are a type of mutator that specifically set a private data member to a provided value.
Thus, all getters are accessors and all setters are mutators, but not vice versa due to the specialized use.

Question 83

What is the typical naming convention for getters and setters?

Answer 83

The generally accepted naming convention for getters and setters is Get<PrivateMemberName> and Set<PrivateMemberName>, respectively. However, these names are related to their behavior, not strictly the function name, and alternative naming can be used.</PrivateMemberName></PrivateMemberName>

Question 84

Why use getters and setters instead of directly accessing class members?

Answer 84

Getters and setters are utilized to enforce validation on private data members. While a public member can be set to any value, setters enable the implementation of logic that validates or modifies input before altering a private member. Similarly, getters can provide a validated or adjusted value upon read, ensuring controlled access to the internal state of an object and maintaining encapsulation.

Question 85

What is a side effect in the context of object-oriented programming, and why is it significant in the context of getters and setters?

Answer 85

A side effect occurs when a function member modifies the state of an object in a manner not anticipated by the caller. It is generally considered undesirable in good class design. Getters and setters should ideally avoid side effects, focusing on singular responsibilities: getters should only retrieve values, and setters should only set values, both potentially with validation or transformation logic.

Question 86

How can setters and getters ensure that the data members of an object maintain valid states?

Answer 86

Setters can incorporate validation logic to check and possibly modify input values before they are assigned to private data members, ensuring the object does not enter an invalid state. Getters can validate or adjust the stored data before providing it, ensuring that the value retrieved is valid or meets certain criteria, even if the internal state doesn’t.

Question 87

Are mutators and setters the same?

Answer 87

No. While setters are a type of mutator, they are distinct in that setters specifically assign a provided value to a private data member. In contrast, mutators might modify private data members in varied ways, not limited to assigning a specific value. All setters are mutators, but not all mutators are setters.

Question 88

How can getters be implemented to “clean” data upon a read?

Answer 88

Getters can implement logic that validates, transforms, or adjusts the private data before it is returned. This ensures that even if the internal state of the object is invalid or non-optimal, the value provided by the getter adheres to defined valid or safe parameters.

Question 89

What is the distinction between private and public members in a class declaration?

Answer 89

Private members are only accessible within the class definition, while public members are accessible from outside the class definition, such as in a driver program.

Question 90

How do you correctly call a member function of a class using an object of that class?

Answer 90

You need to instantiate an object of the class and then use the object to call the member function. For example:
Fraction(1,2).Add(Fraction(1,2));
Here, Add() is called on a Fraction object and another Fraction object is passed as a parameter.

Question 91

What is a friend function in C++ class definition and how does it access class members?

Answer 91

A friend function is not a member of the class but is allowed to access its private and protected members. It is declared within the class using the “friend” keyword but is not considered a class member, so it doesn’t adhere to the public/private access controls.

Question 92

Describe the metaphor of private possessions, public possessions, and friends in relation to class members and friend functions.

Answer 92

Private possessions (private members) are only available to you (the class). Public possessions (public members) are accessible to anyone you invite (any function or class). Friends (friend functions) can access your private possessions because of trust and closeness (they can access private and protected members of the class).

Question 93

Why doesn’t the friend function use the scope resolution operator in its definition?

Answer 93

Friend functions do not use the scope resolution operator because they are not members of the class. They are defined without being scoped to the class, even though they are declared inside the class with the “friend” keyword

Question 94

In the context of C++ coding, provide an example of defining a member function and a friend function to illustrate the difference in syntax.

Answer 94

Member function:
Fraction Fraction::Add(Fraction f) {}
Friend function:
Fraction Add(Fraction f1, Fraction f2) {}
The member function uses the scope resolution operator :: because it is a part of the class, whereas the friend function does not.

Question 95

How is dot syntax utilized in member functions versus friend functions when accessing data members?

Answer 95

In a member function, the “current” instance accesses members directly or using this->, while parameters use dot syntax. In friend functions, dot syntax is used to access members of all objects passed as parameters since there is no “current” instance.

Question 96

How do you declare a friend function within a class and what is its access level to the class members?

Answer 96

A friend function is declared within a class using the “friend” keyword and is placed outside of the public/private blocks since it is not truly a member and thus is not bound by the private/public access specifiers. It can access both private and protected members of the class.

Question 97

How are parameters accessed within a member function versus a friend function when dealing with class instances?

Answer 97

In a member function, the “current” instance doesn’t require a specific object or the . operator to access its members. For the parameter objects, you would use dot syntax (e.g., f.numerator). In a friend function, since it is not bound to an instance of the class, all parameter objects would utilize dot syntax to access their members (e.g., f1.numerator, f2.numerator).