C++ Programming
Multiple Choice Questions

Dennis Ritchie

Bjarne Stroustrup

James Gosling

Guido van Rossum

// comment

/* comment */

Both A and B

# comment

#include <stdio.h>

#include <iostream>

#include <stdlib.h>

#include <cstdio>

.c

.cpp

.java

.py

std

iostream

c++

standard

cout << 'Hello World';

cout << 'Hello World';

print('Hello World');

System.out.println('Hello World');

int

float

string

char

1 byte

2 bytes

4 bytes

8 bytes

char

string

int

bool

1 byte

2 bytes

4 bytes

8 bytes

int

float

struct

char

-128 to 127

0 to 255

-32768 to 32767

0 to 65535

malloc

new

alloc

create

free

delete

dealloc

remove

2.5

2

3

2.0

&

&&

|

||

Access global variables

Access namespace members

Define functions outside class

All of the above

.

->

::

*

break

continue

exit

return

for

while

do-while

None

if (condition) { } else { }

if condition { } else { }

if (condition) { } elif { }

if (condition) then { } else { }

break

continue

goto

return

Yes

No

YesNo

Error

int

char

enum

All of the above

void

int

float

None (must specify)

int &a

int *a

int a

const int a

Multiple functions with the same name but different parameters

Multiple functions with same name and same parameters

Function that calls itself

Function that returns multiple values

0

NULL

Depends on type (undefined)

No default; it's an error

inline

static

virtual

extern

A non-member function that can access private members of a class

A member function of a class

A function that is declared in a namespace

A function that cannot be overloaded

0

1

-1

Depends on declaration

strlen()

length()

size()

strlength()

int arr[10];

array int[10];

int[10] arr;

arr int[10];

string

String

std::string

Both A and C

5

6

4

Error

strcat

strcpy

strcmp

strlen

A variable that stores the address of another variable

A variable that stores a value

A reference to a function

A type of array

&

*

->

::

&

*

->

.

Pointer that points to address 0

Pointer that points to garbage value

Pointer that points to a valid memory location

Pointer that is not initialized

Pointer that stores the address of another pointer

Pointer that stores a value

Pointer that is declared as void

Pointer that cannot be dereferenced

4 bytes

8 bytes

2 bytes

16 bytes

A user-defined data type that encapsulates data and functions

A built-in data type

A function that operates on data

A namespace

An instance of a class

A function of a class

A data member of a class

A type of pointer

public

protected

private

internal

A special member function that initializes objects

A function that destroys objects

A function that copies objects

A function that assigns objects

A special member function that cleans up before object destruction

A function that creates objects

A function that copies objects

A function that overloads operators

Pointer to the current object

Pointer to the base class

Pointer to the derived class

Pointer to the class itself

Deriving a new class from an existing class

Creating multiple objects of a class

Combining multiple classes

Overloading functions

Single inheritance

Multiple inheritance

Multilevel inheritance

Hierarchical inheritance

To solve the diamond problem

To override functions

To define abstract classes

To create templates

public

protected

private

default

Base class constructor first, then derived class

Derived class constructor first, then base class

Both execute simultaneously

Depends on the compiler

Derived class destructor first, then base class

Base class destructor first, then derived class

Both execute simultaneously

Depends on the compiler

Ability to take many forms

Ability to inherit from multiple classes

Ability to overload operators

Ability to create templates

virtual

override

final

abstract

A virtual function with no implementation in base class

A virtual function that is overridden

A function that cannot be overridden

A function that is declared as static

A class that has at least one pure virtual function

A class that cannot be inherited

A class that has no data members

A class that is declared as final

Achieved via virtual functions and inheritance

Achieved via function overloading

Achieved via templates

Achieved via operator overloading

Achieved via function overloading and templates

Achieved via virtual functions

Achieved via inheritance

Achieved via abstract classes

A blueprint for creating generic classes and functions

A class that cannot be instantiated

A function that cannot be overridden

A type of inheritance

template

typename

class

Both A and B or C

No difference; they are interchangeable

typename is used for types, class for classes

class is used for types, typename for classes

typename is used for templates, class for classes

Defining a specific implementation for a particular type

Defining a template with multiple parameters

Defining a template without parameters

Defining a template as virtual

A template that defines a generic function

A template that defines a generic class

A template that defines a variable

A template that defines a namespace

A template that defines a generic class

A template that defines a generic function

A template that defines a variable

A template that defines a namespace

Standard Template Library

Standard Type Library

System Template Library

Standard Tool Library

vector

list

deque

set

vector

list

deque

stack

std::sort

std::find

std::reverse

std::copy

An object that points to an element in a container

A container type

An algorithm

A function object

set

map

unordered_set

multiset

throw

catch

try

exception

catch

try

throw

finally

To enclose code that might throw an exception

To handle exceptions

To throw exceptions

To define custom exceptions

Yes, catches any exception

No, not allowed

Only if no other catch is used

Only for standard exceptions

std::exception

std::error

std::runtime_error

Both A and C

Program terminates with an error

Program continues execution

Exception is ignored

Compiler gives an error

#include <fstream>

#include <iostream>

#include <file>

#include <stdio.h>

ifstream

ofstream

fstream

filebuf

ifstream

ofstream

fstream

filebuf

ios::app

ios::out

ios::in

ios::binary

file.is_open()

file.open()

file.good()

Both A and C

file.close()

file.end()

file.exit()

file.stop()

main()

Main()

int main()

void main()

8 bytes

10 bytes

16 bytes

4 bytes

1

2

0

2.5

for

while

do-while

All are equally suitable

A function that calls itself

A function that is overloaded

A function that is virtual

A function that is inline

1

2

3

0

int (*func)()

int *func()

int func*()

function pointer

Encapsulation

Inheritance

Polymorphism

Procedural abstraction

Composition

Aggregation

Inheritance

Association

Prevents a class from being inherited or function overridden

Marks a function as virtual

Marks a function as abstract

Marks a function as inline

template <typename T = int>

template <class T = int>

Both A and B

template <T = int>

std::stack

std::queue

std::deque

std::list

Yes, any type can be thrown

No, only derived from std::exception

Only built-in types

Only user-defined types

ios::in | ios::out

ios::in

ios::out

ios::app

To bring a namespace into scope

To define a new type

To create a pointer

To allocate memory

2 bytes

4 bytes

1 byte

Depends on compiler

:: (scope resolution)

+

->

[]

012

123

0123

0 1 2

A function that belongs to a class but can be called without an object

A function that cannot be changed

A function that is not accessible outside

A function that returns void

std::string is a class with methods; C-style is character array

C-style is faster

std::string uses null terminator

No difference

A pointer that automatically manages memory

A pointer that is faster

A pointer that is global

A pointer that cannot be dereferenced

Default constructor

Parameterized constructor

Copy constructor

All of the above

They change the access levels of base class members in derived class

They change the speed of inheritance

They change the number of base classes

They are all the same

To explicitly mark a function as overriding a virtual function

To define a new function

To prevent overriding

To make a function pure virtual

Yes, e.g., template <int N>

No, only types

Only for classes, not functions

Only for functions, not classes

std::find

std::search

std::binary_search

All of the above

Indicates that a function does not throw exceptions

Indicates that a function always throws

Indicates that a function can throw any exception

Indicates that a function is virtual

getline(file, line)

file >> line

file.readline(line)

Both A and B

<> searches system paths, '' searches local directories first

'' searches system paths, <> searches local

Both are the same

<> is for C, '' for C++

8 bytes

4 bytes

16 bytes

2 bytes

new

malloc

alloc

create

Yes

No

Error

Undefined

An anonymous function

A named function

A function template

A virtual function

5

6

4

Error

A pointer that stores the address of a function

A pointer that points to a variable

A pointer that points to a class

A pointer that cannot be dereferenced

In the order they are defined

In reverse order

Random order

Depends on compiler

A base class that is inherited virtually to avoid duplication

A base class with virtual functions

A base class that is abstract

A base class that cannot be inherited

set

vector

list

deque