C++

Question 1

What does C++ add to C?

Answer 1

• Classes
• Exception handling
• Function & operator overloading
• Default values for parameters
• Pass by reference

Question 2

What is ::?

Answer 2

Scope resolution operator

Question 3

What removes the need for the scope resolution operator?

Answer 3

“using namespace std”

Question 4

What does cout and cerr do?

Answer 4

cout: goes to stdout
cerr: goes to stderr

Question 5

Why must two functions that are identical in all but input types be created?

Answer 5

They may result in different return types

Question 6

In a .hpp class, what are the two key elements that define a class?

Answer 6

• Private class variables
• Public member function prototypes

Question 7

What are the three access specifiers in a class?

Answer 7

• Private (default): can only be accessed within the class
• Public: can be accessed by any part of the program
• Protected: To do with inheritance

Question 8

Where are functions for a class defined?

Answer 8

In a .cpp file with the same name as the .hpp file

Question 9

How is a class used in a C++ file?

Answer 9

include <headerfilename.hpp></headerfilename.hpp>

Question 10

What can be done if you have a class that can take a varying number of parameters?

Answer 10

Use overloading:
NewClass(int, int)
NewClass(int)
This is valid as there are a differing number of arguments

Question 11

What values can be defaulted in a class function?

Answer 11

Only the trailing parameters
void NewClass::someFunction(int i, int j=0) (VALID)
void NewClass::someFunction(int i=1, int j=0) (VALID)
void NewClass::someFunction(int i=1, int j) (INVALID)

Question 12

How has malloc been replaced in C++?

Answer 12

Instead of:
“int *p = (int )malloc(sizeof(int)25);
free(p);
It is now:
int *p = new int; // a single integer, uninitialised
int *p = new int(43); // a single integer, initialised to value 43
int *p = new int[25]; // an array of 25 integers
delete p; // free the single value p
delete[] p; // free the array p

Question 13

What are constructors and destructors of a class?

Answer 13

They can be implicitly called when a object of the class type has been created or destroyed (i.e. when return 0 is stated). The constructor malloc memory to pointers and the destructor frees memory allocated to pointers.

Question 14

What is a reference?

Answer 14

A reference is an alias for a variable
int num = 43;
int &ref = num;
ref = 43;

Question 15

What is ‘this’?

Answer 15

‘this’ is a pointer to a current object and used to avoid ambiguities if you want to pass the object to a function or tor return a reference to the calling object

Question 16

What is a copy constructor?

Answer 16

A member function that initialises an object using another object of the same class
MyClass (const MyClass &)
MyClass c, d;
MyClass e = c; // calls the copy constructor
d = e; // calls an assignment operator not the copy constructor

Question 17

What is a static member variable?

Answer 17

• They are shared by all objects of the same class
• Can be accessed even if no objects exist

Question 18

What is inheritance?

Answer 18

When a class uses another class’s protected and public functions/attributes as well as its own

Question 19

What effect do access specifiers have on inherited classes?

Answer 19

If either the base class or inheritance member access specifier is protected then the derivied class effect is protected. The same for private.

Question 20

What are the rules for constructors and destructors?

Answer 20

• Constructors are executed in order of derivation
• Destructors are executed in reverse order of derivation

Question 21

What is the diamond problem?

Answer 21

It is do with multiple inheritance. If there are two derived classes from the same class, and a class that derives from both of them, what happens if this class tries to access a variable from the original class.

Question 22

What are the two solutions to the diamond problem?

Answer 22

• Apply the scope resolution operator
• Prevent two copies of the base class being included in the bottom class (this can be done using a virtual class)

Question 23

What is a friend function in relation to a class?

Answer 23

• A non-member function (not a member of the class)
• Has access to the private and protected elements of the class
• It is preceded by ‘friend’ in the public modifier

Question 24

What is friendship NOT?

Answer 24

• Inherited
• Transitive

Question 25

What can friend functions be used for?

Answer 25

Operator overloading

Question 26

What is function overloading?

Answer 26

More than one function with the same name

Question 27

What is operator overloading?

Answer 27

More than one ‘meaning’ of an operator

Question 28

What is the aim of operator overloading and how does it achieve this?

Answer 28

Make like easier for the users of a class, not the developer of the class. Easier means:
- Easier to understand the code
- Fewer code defects

Question 29

Which operators cannot be overloaded?

Answer 29

.
sizeof
?:
::
.*

Question 30

How is overloading + achieved?

Answer 30

class MyInteger
{
int i;
public:
MyInteger (int i) { this->i = i; }

  int   operator+(MyInteger); };

// This function represents <MyInteger> + <MyInteger>
int MyInteger::operator+ (MyInteger m)
{
return this->i + m.i;
}
int main ()
{
MyInteger a(4);
MyInteger b(3);
MyInteger c;</MyInteger></MyInteger>

c = a + b;

return 0;
}

Question 31

What are some considerations to have in mind when overloading operators?

Answer 31

• At least one of the operands of an overloaded operator must be of a user-defined type
• Overloaded operators are just function calls, so cannot preserve associativity or precedence rules of the operator, according to its built-in semantics
• Just because you can does not mean you should

Question 32

What are the uses of overloaded functions?

Answer 32

They are so generic that they can be applied to almost any datatype, otherwise separate functions would have to be created for each datatype

Question 33

What is a function template?

Answer 33

Instructions for how to build a family of similar looking functions. Begins with:
template<dataname></dataname>

Question 34

What is a class template?

Answer 34

Helps to build a family of similar looking classes. Begins with:
template<typename></typename>

Question 35

What are the four main components of the standard template library?

Answer 35

• Containers (vector, queue, stack)
• Iterators (objects that enable a program to traverse a container)
• Algorithms (binary_search)
• Functions

Question 36

What is an exception?

Answer 36

An anomalous or exceptional condition

Question 37

What do exceptions do C++?

Answer 37

• Enable error trapping
• Allow the transfer of program execution to another part of the code
• During execution of the program, i.e. at runtime

Question 38

How can exceptions be thrown?

Answer 38

• Automatically
• Programmatically

Question 39

What happens if an uncaught exception is thrown?

Answer 39

terminate called after throwing an instance of […]
Abort(coredump)

Question 40

How do you find type identification information at run time?

Answer 40

include <typeinfo></typeinfo>

typeid(class).name()

Question 41

It terms of streams, what does &laquo_space;and&raquo_space; do?

Answer 41

«: the insertion operator because it inserts characters into a stream (output)
»: the extraction operator because it extracts characters from a stream

Question 42

What does ifstream, ofstream and fstream do in terms of files?

Answer 42

ifstream: read access
ofstream: write access
fstream: read/write access

Question 43

How do you open a file?

Answer 43

f.open(<filename>, <mode>)
#include <fstream>
ifstream inFile;
ofstream outFile;
inFile.open("myFile.txt"); // ifstream: default mode is ios::in
outFile.open("myFile2.txt"); // ofstream: default mode is ios::out
if ( !inFile.is_open() || !outFile.is_open() )
// do some error processing
inFile.close();
outFile.close();</fstream></mode></filename>

Question 44

What are some stream state flags?

Answer 44

bad(): returns true if a reading or writing operation fails
fail(): returns true in the same cases as bad(), but also when a format error happens
eof(): returns true if a file open for reading has reached the end
good(): returns where any of the above return true
clear(): resets the state flags