Week 11 - Gemini

Question 1

What is the main purpose of ‘output formatting’ in C++?

Answer 1

To control how data (numbers, strings, etc.) is displayed on an output stream (like the console or a file), ensuring it’s readable, aligned, and presented in a specific style (e.g., number of decimal places, base).

Question 2

Which C++ header file must typically be included to use output manipulators that take arguments (e.g., setw, setprecision)?

Answer 2

<iomanip>

Question 3

What is the difference between using endl and '\n' for newlines with cout? What additional action does endl perform?

Answer 3

Both endl and '\n' insert a newline character. However, endl also flushes the output buffer, ensuring the output is immediately displayed. '\n' typically does not force a flush on its own.

Question 4

What is the purpose of the flush manipulator (e.g., cout << flush;)? In what scenario might it be particularly useful?

Answer 4

flush forces the contents of the output buffer to be written to the output device immediately. It can be useful in debugging (to ensure print statements appear before a potential crash) or when immediate output is critical, though cerr is often preferred for error messages as it’s unbuffered.

Question 5

What is the cerr output stream, and how does it differ from cout in terms of buffering?

Answer 5

cerr is the standard error stream, typically directed to the console. Unlike cout, output to cerr is usually unbuffered or flushed automatically after each insertion, making it suitable for error messages that should appear immediately.

Question 6

Explain the setw(n) manipulator. Does its effect persist for subsequent output operations?

Answer 6

setw(n) sets the minimum field width for the next item to be printed to n characters. If the item is shorter, it’s padded (usually with spaces). If longer, the field expands. Its effect is not persistent; it only applies to the immediately following output.

Question 7

What is the default justification for output within a field set by setw(n)? Which manipulators can change this?

Answer 7

The default justification is usually right-justified. std::left changes it to left-justified. std::right explicitly sets it back to right-justified. These justification manipulators are persistent.

Question 8

What is the purpose of the showpos and noshowpos manipulators?

Answer 8

showpos forces a plus sign (+) to be displayed before positive numerical values. noshowpos (the default) omits the plus sign for positive values (negative values always show a minus sign).

Question 9

Which manipulators are used to change the numerical base for printing integer values? What are the common bases supported?

Answer 9

std::dec (decimal - base 10, default), std::oct (octal - base 8), and std::hex (hexadecimal - base 16). These only affect integer output, not floating-point numbers.

Question 10

Are floating-point values affected when std::oct or std::hex manipulators are active?

Answer 10

No, floating-point values are always printed in decimal format, regardless of the active integer base manipulator.

Question 11

Describe the three floating-point output formats in C++ and the manipulators to select them.

Answer 11

1. General (default): Mix of fixed and scientific; uses fixed for small numbers, scientific for large. 2. Fixed (std::fixed): Always displays a number, decimal point, and fractional part (e.g., 123.450). 3. Scientific (std::scientific): Always displays in scientific notation (e.g., 1.234500e+02).

Question 12

How can you revert the floating-point output format to ‘general’ after setting it to fixed or scientific?

Answer 12

Using cout.unsetf(std::ios::fixed | std::ios::scientific); (requires using namespace std; or qualifying ios). There isn’t a single ‘general’ manipulator.

Question 13

What does the setprecision(n) manipulator control for floating-point numbers in (a) general format and (b) fixed or scientific format?

Answer 13

(a) General format: n is the maximum number of significant digits displayed. (b) Fixed/Scientific format: n is the number of digits displayed after the decimal point.

Question 14

What is the default output precision for floating-point numbers if not set by setprecision?

Answer 14

The default precision is typically 6.

Question 15

What is the purpose of the showpoint and noshowpoint manipulators, especially in ‘general’ floating-point format?

Answer 15

showpoint forces the decimal point and any trailing zeros (up to the current precision) to be displayed for floating-point numbers, even if they are whole numbers (e.g., 4.00000). noshowpoint (default) omits unnecessary trailing zeros and the decimal point for whole numbers (e.g., 4).

Question 16

What is a ‘namespace’ in C++, and what is its primary purpose?

Answer 16

A namespace provides a scope for identifiers (names of types, functions, variables, etc.). Its primary purpose is to prevent name collisions that can occur when different libraries or parts of a large project use the same identifier for different things.

Question 17

How do you define a namespace MyLibrary containing a function void func();?

Answer 17

namespace MyLibrary { void func(); /* other declarations/definitions */ }

Question 18

How can you access func() from the MyLibrary namespace? (Show two ways)

Answer 18

1. Using the scope resolution operator: MyLibrary::func(); 2. With a using directive: using namespace MyLibrary; func(); (the latter brings all names from MyLibrary into the current scope).

Question 19

Why is it generally discouraged to use using namespace std; (or any other namespace) in header files?

Answer 19

Because header files can be included in many translation units. A using namespace directive in a header file pollutes the global namespace for all files that include it, increasing the risk of name collisions and making it harder to see where names originate.

Question 20

What are the two primary ways C++ handles strings, as mentioned in ‘Last_week.docx’?

Answer 20

1. The C-style character string (a null-terminated array of characters). 2. The std::string class type (part of the C++ Standard Library).

Question 21

What is the key characteristic of a C-style character string in terms of its storage in memory?

Answer 21

It is a one-dimensional array of characters that is terminated by a null character (\0).

Question 22

How does the std::string class (from <string> header) generally improve upon C-style strings?

Answer 22

std::string objects manage their own memory, automatically handle resizing, provide many useful member functions (e.g., .size(), .length(), .append(), .find()), and support intuitive operations like concatenation with + and assignment with = without the risks of buffer overflows common with C-style string functions.

Question 23

How do you declare a std::string variable message and initialize it with “Hello, C++”? How do you get its length?

Answer 23

#include <string> std::string message = "Hello, C++"; int len = message.size(); (or message.length();)

Question 24

How do you concatenate two std::string objects, s1 and s2, into a new string s3?

Answer 24

std::string s3 = s1 + s2;

Question 25

What is a `struct` (structure) in C++? What is its main purpose?

Answer 25

A `struct` is a user-defined data type that groups together variables of potentially different data types under a single name. Its main purpose is to represent a record or a collection of related data fields as a single logical unit.

Question 26

Provide the basic syntax for defining a structure named `StudentRecord` with members for name (string) and ID (int).

Answer 26

`struct StudentRecord { std::string name; int studentID; };`

Question 27

If `student1` is a variable of type `StudentRecord`, how do you access its `name` member?

Answer 27

`student1.name` (using the dot `.` operator).

Question 28

If `studentPtr` is a pointer to a `StudentRecord` object (`StudentRecord* studentPtr = &student1;`), how do you access its `name` member using the pointer?

Answer 28

`studentPtr->name` (using the arrow `->` operator).

Question 29

Can structures be passed as arguments to functions? Can they be returned from functions?

Answer 29

Yes, structures can be passed to functions by value or by reference, and functions can return structure types.

Question 30

What is the `typedef` keyword often used for in conjunction with `struct` declarations (especially in C-style C++)?

Answer 30

`typedef` can be used to create an alias for the structure type, avoiding the need to write `struct StructName` every time a variable of that type is declared. E.g., `typedef struct { ... } MyStructType; MyStructType var;` In C++, `struct StructName var;` is already valid without `typedef`.

Question 31

What is the purpose of the `printf()` function in C/C++, and which header is typically required?

Answer 31

`printf()` is used for formatted output to the standard output stream (usually the console). It allows printing characters, strings, integers, floating-point numbers, etc., according to specified format specifiers. Header: `` (C++) or `` (C).

Question 32

Name three common format specifiers used with `printf()` and the data types they correspond to.

Answer 32

`%d` or `%i` for signed integers. `%f` for floating-point numbers (doubles are often promoted). `%s` for C-style strings (null-terminated char arrays). `%c` for single characters. `%lf` for `double` (though `%f` often works for `double` arguments to `printf`).

Question 33

What is the purpose of the `scanf()` function in C/C++, and which header is typically required?

Answer 33

`scanf()` is used for formatted input from the standard input stream (usually the keyboard). It reads data according to specified format specifiers and stores it into variables. Header: `` (C++) or `` (C).

Question 34

When using `scanf()` to read into a variable (e.g., an `int`), why is the address-of operator (`&`) typically used before the variable name (e.g., `scanf("%d", &myInt);`)?

Answer 34

`scanf()` needs the memory address of the variable where it should store the input value. The `&` operator provides this address. (Not needed for C-style string character arrays, as the array name itself decays to a pointer).

Question 35

What is a key difference in type safety between C++ iostreams (`cin`/`cout`) and C-style `scanf`/`printf`?

Answer 35

C++ iostreams are generally more type-safe because the type of the data is known from the variable itself, and operations are often overloaded. With `scanf`/`printf`, the programmer is responsible for ensuring the format specifiers match the actual types of the arguments; mismatches can lead to runtime errors or undefined behavior.

Question 36

What is a 'stream' in the context of C++ file handling?

Answer 36

A stream is an abstraction that represents a flow of data to or from a device (like a file, console, or even memory). It allows programmers to perform I/O operations in a consistent way regardless of the actual device.

Question 37

What is the main difference between `ios::out` and `ios::app` when opening a file for writing with `ofstream`?

Answer 37

`ios::out`: If the file exists, its contents are typically truncated (deleted). If it doesn't exist, it's created. Writing starts at the beginning. `ios::app` (append): If the file exists, new data is written to the end of the file, preserving existing content. If it doesn't exist, it's created.

Question 38

How can you represent a C-style string in memory using an array of characters? What is crucial about its termination?

Answer 38

A C-style string is represented as an array of `char` elements. It is crucial that the sequence of characters is terminated by a null character (`\0`) to mark the end of the string.