C++

Question 1

What does the C++ compiler do when it encounters the “#include” preprocessor directive?

Answer 1

It literally copies and pasted the contents of the included file into the program (this process is called “macro expansion”)
-The file contents are pasted at the location of the corresponding “#include”
-That’s why you only need to include a file ONCE in your set of source code files

The compiler searches for the specified file in a predefined set of directories, including the standard system directories and any additional directories specified by the user or the build system (you can even build custom search paths)

Question 2

Purpose of “#ifndef”

Answer 2

Can use #ifndef and #define to make sure that the code is only included one time. The #ifdef guard is used to prevent the machine from unnecessarily using memory for redundent copies of the same code

Question 3

Referring to the location in which a particular function is stored

Answer 3

‘std’ is a popular location (it refers to the “standard library of C++
The location can also be used to identify whether you are talking about data/operations stored in the base class

Question 4

Passing something by value versus Passing something by reference

Question 5

Object Slicing Problem

Answer 5

-You wish to pass an object of a derived class by value to a function
-The function parameter data type is that of the base class (not the derived class)
-Since the base class does not have the extra members that were added to the derived class, only the subject of derived class memeber shared with the base class are passed
THIS CAN BE AVOIDED BY PASSING BY REFERENCE

Question 6

“virtual” reserved word

Answer 6

We can use a virtual function to make write() a polymorphic operation and ensure that the correct version of the function is invoked
-Using “virtual” with a function from the base class guarantees dynamic binding, meaning that the decision for which function (base or derived) is invoked is delayed until run time
-At runtime, the data type of the argument determined which version of the function is invoked
-If virtual appears in the function prototype, it does not appear in the heading of the function definition
-by declaring a member function of the base class as virtual, any redefined versions of the function in derived classes are also virtual

Question 7

Arguments

Answer 7

Arguments are needed when the function is CALLED. They represent actual variable names so that you can pass actual values to the function. They do not require datatypes
[when the function is virtual, the datatype of the arguments will determine whether the base class’ function or the derived class’ function]

Question 8

Parameters

Answer 8

Parameters are needed in the function header. It is a DECLARATION of variables that you can expect to find in that function. They require datatypes just like any declaration
[when the function is NOT virtual, the data type of the parameter will determine whether the base class’ function or the derived class’ function]

Question 9

Pure Virtual Functions

Answer 9

Functions are made pure virtual by typing “virtual” before the function AND typing “=0;” at the end
At least one of these must be included in each abstract class.
The derived class MUST overwrite this function

Question 10

Static Allocation

Answer 10

Performed at compile time

Question 11

Indirect Addressing

Answer 11

Accessing a variable in two-steps by first using a pointer that gives the location memory (the address of the variable.
Means you are accessing the variable using a pointer.

Question 12

Addresses in memory

Answer 12

Every byte is counted. It has it’s own number that represents it. That number is it’s address

Question 13

Pointer

Answer 13

A variable which contains the address or location of other variables.
Pointers use INDIRECT addressing.
The * operator declares the variable a pointer.
If you use a pointer, you can represent any.
ALWAYS an integer value (4 bytes), no matter the datatype of the variable you are pointing to: because it is referencing the ADDRESS of that variable.

Question 14

Using a star * before the name of your integer variable

Answer 14

Treats the value as a POINTER. You are directing the machine the memory address associated with that particular number

Question 15

Using an ampersand & before the name of your integer variable

Question 16

Advantage of using pointers

Answer 16

If you use a pointer (which is always 4 bytes) you can reduce the amount of memory needed to have an array of values
-An array of 20 different 4 byte pointers is better than an array of 20 different 24 byte structures

Question 17

Using an arrow in a code -> (with respect to pointers)

Answer 17

This means that you are dereferencing the pointer

Question 18

Dynamic Allocation

Answer 18

Allocation of memory space at run time

Question 19

The Heap (Free store)

Answer 19

Basically sandbox-mode memory, with a limited
Pool of memory locations reserved for allocation and de-allocation of dynamic.
The data created heap cannot be deleted automatically; you have to actually create a command to delete the data you no longer need

Question 20

Dynamic allocation Operator: “new”

Answer 20

“New” allocates memory to hold an int and stores the address into the variable

Question 21

“The Stack”

Question 22

Memory Leak

Answer 22

Too much “garbage” taking up space in the Heap until you run out of memory
Loss of available memory space when that memory is dynamically allocated but not deallocated.
THIS IS WHY IT IS SO IMPORTANT TO DELETE ALL THE VARIABLES THAT YOU ARE NOT USING

Question 23

Garbage

Answer 23

Memory locations that can no longer be accessed.
This is created when you update what a pointer is pointing toward

Question 24

Inaccessible object

Answer 24

A dynamic variable on the free store without any pointer pointing to it

Question 25

Dangling Pointer

Answer 25

A pointer that points to a variable that has been deallocated

Question 26

deallocation operator: “delete”

Question 27

Stack overflow v. Memory Leak

Question 28

Robustness

Answer 28

The ability of a program to recover following an error

Question 29

Four Types of Errors

Answer 29

1. A user may accidently or deliberately (hackers) enter incorrect inputs
2. Hardware does not actually have the resources that you need to actually execute what you need to execute (disk drives and random access memory have size limits)
3. Hardware devices may fail or becomes inaccessible
4. Software components may contain defects (bugs)

Question 30

Six options for handling errors

Answer 30

1. Assume errors will not occur (not an option)
2. Print a descriptive error message
3. Return an unusual value to indicate an error has occurred
4. Alter a status variable’s value
5. Use assertions to block further execution
6. Use exception handlers

Question 31

Exception

Answer 31

Basically an anomaly.
An unusual event, detectable by software or hardware, that requires special processing

Question 32

Exception Handler

Answer 32

A section of program code that is executed when a particular exception occurs

Question 33

try-throw-catch

Answer 33

Used for testing for an exception
Try command is used to run statements that could cause an exception.
The catch command is used to contain “exception handler” statements. THE CATCH IS ONLY EXECUTED IF THE EXCEPTION IS DETECTED

Question 34

What happens if your catch statement is passed the wrong datatype?

Answer 34

the compiler will generate an error message

Question 35

Difference between a string and a character array in C++

Question 36

What happens what something that is thrown is never caught

Answer 36

It gets passed back up the call stack to see if you

Question 37

Why exception handling is important

Question 38

“bad_alloc”

Answer 38

An exception from the ____
Means “Insufficient memory”

Question 39

Instantiating datatypes with dynamic allocation

Answer 39

means that “new” needs to be inside of a try block

Question 40

Purpose of gcov

Answer 40

Tool used for code coverage analysis in C and C++ programs. Code coverage analysis is a technique to determine which parts of the code are executed during program execution, helping developers assess the thoroughness of their testing.
Particularly useful for understanding how much of the code is being exercised by test cases.

Question 41

gcov for Code Coverage Analysis

Answer 41

The primary purpose of gcov is to provide information on the percentage of code that has been executed during testing. It generates a detailed report indicating which lines of code have been executed and how many times.

Question 42

gcov for Identifying untested code

Answer 42

gcov helps in identifying areas of the code that have not been covered by test cases, allowing developers to focus on writing additional tests to achieve higher code coverage.

Question 43

gcov for Improving Testing Strategies

Answer 43

By visualizing the parts of the code that are exercised by the tests, developers can refine their testing strategies to ensure more comprehensive coverage, leading to more robust and reliable software.

Question 44

gcov for integration with build systems

Answer 44

is often integrated into the build process, allowing automated code coverage analysis as part of the build or testing workflow. It can be invoked alongside a test suite to generate coverage reports.

Question 45

gcov for testing frameworks

Answer 45

gcov is used in conjunction with testing frameworks (e.g., Google Test, Catch2) to assess the coverage of the test cases and to guide the creation of additional tests for untested parts of the code.

Question 46

gcov for assessing quality and maintenance

Answer 46

Code coverage analysis is a useful metric for evaluating the quality of the software and estimating its maintainability. High code coverage indicates that a substantial portion of the code has been tested.

Question 47

The rule for 100% statement coverage

Answer 47

100% Statement Coverage Testing is necessary but not sufficient to ensure a high-quality software product

Question 48

Command Line Arguments

Answer 48

Parameters provided to a program when it is invoked from the command line or terminal. - Allow users to pass input values or options to the program, influencing its behavior or providing necessary data for processing.
- Essential for creating flexible and interactive applications.

Question 49

‘struct’ in C++

Answer 49

A datatype that represents a record of data
Each new piece of information in a struct is called a member.

Question 50

Selecting a particular member in a struct

Answer 50

[struct_name].[member name]

Question 51

Symbol for a line comment in C++

Answer 51

//this text is commented out

EXAMPLE:
std::cout &laquo_space;“Hello World!\n”; //say hello

Question 52

Symbol for a block comment in C++

Answer 52

/* this text is commented out*/

EXAMPLE:
std::cout &laquo_space;“Hello World!\n”;
/* the machine should print the phrase “Hello World”.
This is a standard introductory program in any programming language */

Question 53

Static Variable v. Automatic Variable

Question 54

Purpose of a Header Guard

Answer 54

Helps make sure that you are only doing you “macro expansion” once for each of the files that you need to execute your program

EXAMPLE:
#ifdef header_file
#define header_file
/Contents of the header file/
#endif

Question 55

Purpose of the #include preprocessor directive

Answer 55

Allows you to add the contents of another file to your source file
#include is always followed by the name of the file that must be included

Question 56

Purpose of #ifndef (with the ‘n’)

Answer 56

Means “If Not Defined”:

• # ifndef is used to check if a specified identifier has not been defined previously in the code.
• It evaluates to true if the specified identifier is not defined, allowing the subsequent code to be included.
• It’s commonly used for include guards to prevent a header file from being included multiple times.

EXAMPLE:
#ifndef MY_HEADER_H
#define MY_HEADER_H
// Content of the header file
#endif // MY_HEADER_H

Question 57

Purpose of #ifdef (without the ‘n’)

Answer 57

Means “If Defined”

• # ifdef is used to check if a specified identifier has been defined previously in the code.
• It evaluates to true if the specified identifier is defined, allowing the subsequent code to be included.
• It’s used when conditional compilation is needed based on whether a specific feature or macro is defined.

EXAMPLE:
#ifdef debugging_file
//debugging code
#endif

Question 58

What does the compiler do when it encounters #ifndef?

Answer 58

The compiler begins a “conditional compilation” process:
1) The compiler check to see if the mentioned marco/symbol has already been defined in the code
2) If it has NOT been defined, the preprocessor includes the code located between the #ifndef and #endif

Question 59

Macros in C++

Answer 59

A macro is a fragment of code in a program that has been given a name. It’s a mechanism to perform textual replacement in the source code. Macros provide a way to perform text substitution in the source code before the actual compilation takes place.
- Macros are typically defined using #define preprocessor directive and are often used to define constants or perform simple operations.
EXAMPLE (PI and SQUARE are macros that get replaced with their respective values or code fragments during preprocessing):
#define PI 3.14159
#define SQUARE(x) ((x) * (x))
int radius = 5;
double area = PI * SQUARE(radius);

Question 60

Symbols in C++

Answer 60

A symbol is a name that represents a particular piece of data or a memory location in a program. It can be a variable, function, type, or any other named entity in the program.
- Symbols are used throughout the code to refer to specific elements such as variables, functions, types, etc.

EXAMPLE (num and foo are symbols representing an integer variable and a function, respectively):

Question 61

Macros v. Symbols in C++

Answer 61

• A macro is a mechanism to perform textual replacement of code, while a symbol represents a named entity in the program.
• Macros are often defined using #define and are used for simple text substitutions or operations, while symbols represent various program elements like variables, functions, types, etc.
• Macros are usually used for constants or simple operations, while symbols encompass a broader range of programming constructs.

Question 62

Six purposes of #define preprocessor directive?

Answer 62

Used to define “macros”. By using the #define directive, programmers can create more maintainable and flexible code by centralizing definitions and providing meaningful names to values and code fragments. However, it’s important to use macros judiciously, considering potential pitfalls like macro-related errors and side effects.

Six main uses:
1) Defining constants: One of the primary purposes of #define is to define constants, allowing you to assign a meaningful name to a value and use it throughout the code. This improves code readability and makes it easier to update values in one central place:
#define PI 3.14159
#define MAX_VALUE 100

2) Defining Expressions: Macros can define expressions, making it easier to handle complex or repetitive calculations or operations:
#define SQUARE(x) ((x) * (x))

3) Creating Code Fragments: Macros can define code fragments or functions, making it easier to reuse blocks of code:
#define PRINT_HELLO() std::cout &laquo_space;“Hello, world!” &laquo_space;std::endl;

4) Conditional Compilation: Macros are often used to conditionally include or exclude sections of code, providing a way to create feature flags or customize program behavior at compile time.
#define DEBUG_MODE
#ifdef DEBUG_MODE
// Debugging code
#endif

5) Enhancing Code Reliability: Macros can enhance code readability by giving meaningful names to numeric or cryptic values, improving the understanding of the code.
#define SPEED_LIMIT_KMH 120

6) Avoiding Magic Numbers: Macros help avoid the use of “magic numbers” (unexplained constants) in the code by providing named constants.

Question 63

Why you should minimize your use of Macros in C++

Answer 63

To mitigate these eight pitfalls, it’s advisable to minimize the use of macros and prefer alternatives like const variables, enum, inline functions, and template functions, which provide type safety, better maintainability, and improved code readability. When using macros, follow best practices such as proper naming conventions, parentheses for safe macro expansion, and avoiding complex expressions within macros.

1) Symbol Clashes and Unexpected Behavior: Macros replace text globally, which can lead to unintended replacements and unexpected behavior if the macro name coincides with a variable, function, or other identifier in the code.

2) Lack of Type Checking: Macros do not undergo type checking since they are simply text substitutions. This can result in type-related errors that are hard to detect and debug.

3) Evaluation of Arguments Multiple Times: Macro arguments are often evaluated multiple times, which can lead to unintended side effects, especially when arguments have side effects.

4) Difficulty in Debugging: Debugging code that heavily relies on macros can be challenging, as macros obscure the actual code and can expand into complex and verbose expressions.

5) Readability and Maintainability: Overuse of macros can lead to reduced code readability and maintainability, as macros can hide the true intention and logic of the code.

6) Macros with Multiple Statements: Macros containing multiple statements without proper grouping can lead to unexpected behavior and errors.

7) Scope Issues: Macros are expanded globally, potentially causing unintended replacements across different parts of the code.

8) Non-Standard Behavior: Some compilers may implement macros differently or have extensions that behave in a non-standard way, leading to portability issues.

Question 64

Language and structure in C++ v. Python

Answer 64

C++: C++ is a statically typed, compiled language with a C-style syntax that requires explicit variable declarations, types, and memory management.
Python: Python is a dynamically typed, interpreted language with a clean and concise syntax that emphasizes readability and reduces the cost of program maintenance.

Question 65

“Typing” in C++ v. Python

Answer 65

C++: C++ uses static typing, where variable types are determined at compile time and type checking is performed during compilation.
Python: Python uses dynamic typing, allowing variables to hold values of any type, and type checking is performed at runtime.

Question 66

Memory Management in C++ v. Python

Answer 66

C++: In C++, memory management is explicit and requires developers to handle memory allocation and deallocation (e.g., using new and delete).
Python: Python employs automatic memory management and a garbage collector to handle memory allocation and deallocation, reducing the risk of memory leaks.

Question 67

Paradigms in C++ v. Python

Answer 67

C++: C++ supports both procedural and object-oriented programming paradigms and allows low-level memory manipulation.
Python: Python supports multiple programming paradigms, including procedural, object-oriented, and functional programming, emphasizing code simplicity and high-level abstractions.

Question 68

Libraries and Ecosystems in C++ v. Python

Answer 68

C++: C++ has a rich set of libraries and frameworks, often focused on system-level programming, game development, and performance optimization.
Python: Python boasts a vast ecosystem of libraries and frameworks for a wide range of applications, including web development, data science, artificial intelligence, machine learning, and more.

Question 69

Compilation and Interpretation in C++ v. Python

Answer 69

C++: C++ code is compiled into machine-level instructions using a compiler, resulting in an executable file.
Python: Python code is interpreted and executed by the Python interpreter, without the need for compilation, resulting in .pyc (compiled bytecode) files.

Question 70

Development in C++ v. Development in Python

Answer 70

C++: C++ often requires more lines of code to achieve the same functionality, making development comparatively slower.
Python: Python’s concise syntax allows for faster development and easier prototyping of ideas

Question 71

Error Handling in C++ v. Python

Answer 71

C++: Error handling in C++ typically involves using return values, exceptions, or error codes.
Python: Python emphasizes exception handling as a standard way to deal with errors, making error handling more consistent and expressive.

Question 72

C++ Use Cases v. Python Use Cases

Answer 72

C++: C++ is commonly used for systems programming, embedded systems, high-performance applications, game development, and performance-critical applications.
Python: Python is widely used for web development, data analysis, machine learning, artificial intelligence, automation, scientific computing, and prototyping.

Question 73

Language and structure in C++ v. Java

Answer 73

C++: C++ is a statically typed, compiled language with a C-style syntax, requiring explicit variable declarations, types, and memory management.
Java: Java is a statically typed, compiled (to bytecode) language with a C-style syntax, emphasizing object-oriented programming and platform independence.

Question 74

Memory Management in C++ v. Java

Answer 74

C++: In C++, memory management is explicit, and developers are responsible for manual memory allocation and deallocation using new and delete.
Java: Java uses automatic memory management with garbage collection, relieving developers from explicit memory management concerns.

Question 75

Platform Independence in C++ v. Java

Answer 75

C++: C++ code is compiled to machine-specific binaries, making it platform-dependent and requiring recompilation for different platforms.
Java: Java code is compiled to platform-independent bytecode, which can run on any device with a Java Virtual Machine (JVM), enabling platform independence.

Question 76

Garbage Collection in C++ v. Java

Answer 76

C++: C++ does not have built-in garbage collection. Memory deallocation is performed explicitly by the programmer.
Java: Java has automatic garbage collection, freeing developers from managing memory deallocation manually.

Question 77

Pointers and References in C++ v. Java

Answer 77

C++: C++ allows the use of pointers, enabling direct memory manipulation and efficient low-level operations.
Java: Java does not have explicit pointers and does not allow direct memory manipulation for safety and security reasons.

Question 78

Multiple Inheritance in C++ v. Java

Answer 78

C++: C++ supports multiple inheritance, allowing a class to inherit from more than one base class.
Java: Java does not support multiple inheritance through classes, but it allows multiple inheritance of interfaces.

Question 79

Exception Handling in C++ v. Java

Answer 79

C++: C++ uses try-catch blocks for exception handling.
Java: Java also uses try-catch blocks for exception handling, and it enforces exception checking at compile time.

Question 80

Standard Libraries in C++ v. Java

Answer 80

C++: C++ has a rich set of standard libraries, known as the Standard Template Library (STL), providing data structures and algorithms for various tasks.
Java: Java’s standard library offers a comprehensive set of classes and methods, providing a wide range of functionalities for various programming needs.

Question 81

Use Cases for C++ v. Use Cases for Java

Answer 81

C++: C++ is commonly used for systems programming, game development, high-performance applications, and performance-critical applications.
Java: Java is widely used for web and mobile application development, enterprise applications, Android app development, backend development, and large-scale applications.