Errata

floating = (1/2) + (1/2) assign floating 1.0 now reads floating = (1/2) +
(1/2) assign floating 0.0.

main()
{
...
floating = (1 / 2) + (1 / 2); //assign floating 0.0
...
return(0);
}

The floating assignment now reads 1.0

The x is missing.

NN

should be:

xNN

Note from the Author or Editor:
Reader is correct.

const int first_part = 3;
const int second_part = 7;

should be:

const int FIRST_PART = 3;
const int SECOND_PART = 7;

10010100 base 2 now reads 1001 0100 (not 1000 0100), which is 94 base 16 (not
84).

changed "5.0" to "50"

cin >> oper_char >> value;

into:

cin >> oper_char;
cin >> value;

Example 7-1. calc/calc.cc
should be:
Example 7-1. calc1/calc.cc

Note from the Author or Editor:
Reader is correct.

in text

cin >> value >> operator;

into:

cin >> value;
cin >> oper_char;

and changed "operator" to "oper_char" in the third line from the end
of that code example

replaced with oper_char (three times).

cin >> oper_char >> value;

to:

cin >> oper_char;
<in between them goes the "if" line)
cin >> value;

The filename now reads calc3.cc (not calc3.c).

## after cin +
## after if +

is missing after the line:

Enter operator amd number: + 123

The alignment on the right side of the example has been fixed.

In Example 8-4.seven/seven.cc. the first line "include <iostream.h>" is missing the
"#" in front of include.It should be "#include <iostream.h>. Program will not compile
if "#" is left out.

Note from the Author or Editor:
include -> #include

The last brace in the highlighted block faces the wrong way.

Note from the Author or Editor:
Page 130, Figure 9-2, last shaded { should be }.

The second 'Block' is now closed with a "}"
(formerly a "{")

In the first line, "Chapter 4, Basic Declarations and Expressions" now reads
"Chapter 5, Arrays, Qualifiers, and Reading Numbers."

const int ARRAY_SIZE = 5 // Size of the array
int item_array[ARRAY_SIZE] = {1, 2, 5000, 3, 4}; // An array

int &biggest(void)
{
int index; // Current index
int biggest; // Index of the biggest element

// Assume the first is the biggest
biggest = 0;
for (index = 1; index < ARRAY_SIZE; ++index) {
if (item_array[biggest] < item_array[index])
biggest = index;
}
return (item_array[biggest]);
}

cout << biggest(item_array, 5) << '
':

with

cout << biggest() << '
';

The 3rd line in the first block of code now reads:

biggest(item_array, 5) << '
';

The 5th paragraph now reads:

The function biggest returns a reference to item_array[2].
Remember that in the following code, biggest() is
item_array[2]. The following three code sections all
perform equivalent operations. The actual variable,
item_array[2], is used in all three:

The last line of the 3rd code block now reads:

biggest() = 0

Also, the last line of code on the page now reads:

biggest() = 0

In the first coding example it read:

"cout << "The biggest element is " <<
biggest(item_array, 5) << '
'; "

It now reads:

"cout << "The biggest element is " <<
biggest( ) << '
'; "

// Using a simple reference

the line:

int big_reference = &item_array[2];

should be:

int &big_reference = item_array[2];

Note from the Author or Editor:
Reader is correct.

"...[10][]"

...(const rectangle &rectangle...

now reads:

...(const int width, const int height...

and:

draw(big_rectangle...

now reads:

draw(3,5...

In example 10-4, line 5 now reads:

#define MAX = 10

Line 5 did read
#include MAX = 10
Now it reads
#include MAX =10

#define MAX=10
to
#define MAX 10

const box pink_box(1.0, 4.5);

now reads:

const box pink_box(1, 4);

from italics to regular.

void exit();

was removed.

Answer 10-5 now reads:

The problem is that the preprocessor does not understand C++ syntax. The
macro call

SQR(counter+1)

expands to

(counter+1 * counter+1)

The result is not the same as ((counter+1) * (counter+1)).

To avoid this problem, use inline functions instead of parameterized macros.

inline int SQR(int x) { return (x*x);}

If you must use parameterized macros, enclose each use of the parameter in
parnetheses.

#define SQR(x) ((x) * (x))

are not broken up.

been placed under 0x71. It was too far left.

The "&" has been placed above the line.

The "|" has been placed above the line.

The"^" has been placed above the line.

The line:

graphics[(x)/8][y] |= (0x80 >> ((x)%8))

now reads:

graphics[x/8][y] |= (0x80 >> (x%8));

The line:

graphics[(x)/8][y] |= (0x80 >> ((x)%8))

now reads:

graphics[x/8][y] |= (0x80 >> (x%8));

Finally, at the heart ...

now follows the table as introduction for the programming code.

field-type field-name

now reads:

field-type field-name; (x2)

main()
{
data.f_value ...
data.i_value ...
...
data.f_value ...
i = data.i_value ...
}

typedef type-declaration

now reads:

typedef type-declaration;

the page now reads:

enum day_of_the_week today = TUESDAY;

enum enum-name {tag-1, tag-2, . . .} variable-name

now reads:

enum enum-name {tag-1, tag-2, . . .} variable-name;

The code at the top of this page did read:

stack::~stack(void)
now reads:
inline stack::~stack(void) {

2nd box should read:

a_stack.stack() called

call_type first_var
now reads:
class_type first_var

int small_set::test(void);

now reads:

int small_set::test(int item);

void init_array_1(int data[])
{
int index;

for (...){
....
}

should be

void int_array_1(int data[])
{
int index;

for (...){
....
}
}

"If you put the const after the *, we tell C++ that the data is constant."

now reads

"If you put the const after the *, we tell C++ that the pointer is constant."

(changed "data" to "pointer")

command options file1 file1 file3 ...

should be:

command options file1 file2 file3 ...

Note from the Author or Editor:
Reader is correct, but page is 242

changed "<line feed><carriage return>" to
"<carriage return><line feed>"

(cerr << "Cannot open output file
");

were removed.

out_file << cur_char;

now reads:

out_file.put(cur_char);

if (argc != 3) {
to
if (argc != 2) {

Cast (unsigned int) is not necessary and it is not the recommended C++ style,
so it has been removed.

The declaration reads:

int lookup(char *);

The author recommends the use of variables in declarations. It now reads:

int lookup(char *name);

The line:

istream &extended_getline(char *line, int size, ifstream &file)

now reads:

istream &extended_getline(char *line, int size, istream &file)

At the bottom of the page the line:

istream result; /* Result of gets */

now reads:

istream result; /* Result of getline */

The line:

char *extended_getline...

now reads:

void *extended_getline...

The line:

return (*result);

should be removed.

The code should read:

* (normally stdin) *
************************************************
void &extended_getline(char *line, int size, istream &file)
{

if (playback_file_open) {
&playback_file.getline(line, size);
if (file == cin)
// Echo the input to the standard out
// so the user sees it
cout << line << '
';
) else
file.getline(line, size);

//Did someone ask for a save file?
if (save_file_open)
save_file << line << '
';

}

4th line now reads:

ifstream playback_file...

and the 9th line now reads:

void *extended_getline...

in the list"; in the last para., line 2: changed "PVCS" to "PCVS"

The lines:

main(argc, argv)
int argc;
char *argv[];

should read:

int // ... main(int argc, char *argv[])

"C++ allows you to" to "The shell or command-line interpreter
allows you to"

The last sentence before "Runtime Errors" now reads:

...break 49 if point_number == 735...

2nd line of code at top of page now reads:

complex operator +(real v1, real v2); // Illegal

not been defined yet.

number.set(real, imaginary);

now reads:

number.set_real(real);
number.set_imaginary(imaginary);

The following was added to the end of the section:

Unfortunately, this only solves part of the problem. Now
we don't call the copy constructor going into the operator
= function. But when we return (*this), the return value
has to be copied, so we still call the copy constructor.
The solution is to return a reference to the class instead
of a copy of the class. Thus our declaration of the operator
= function should be:

trouble &trouble::operator = (const trouble &old_trouble) {

33000.0

now reads:

330000.0

+1.3200E+0

now reads:

+1.320E+0

1/3 as floating point is 3.333-1

now reads:

1/3 as floating point is 3.333E-1

Mine reads:
struct person *new_ptr;

Should read:
class person *new_ptr;

since it was declared as a class in the 2nd block of code.

Note from the Author or Editor:
Code should be

person* new_ptr;

delete []pointer;

should be:

delete[] pointer;

It is better to use only one form.

5th line of code now reads:

int data; //Data in this element

1st line of code now reads:

(*new_ptr).data = item

name -- name to look for in the list

now reads:

value -- value to look for in the list

and:

int linked_list::find(char *name)

now reads:

int linked_list::find(int value)

and:

while ((strcmp(current_ptr->data, name != 0) &&

now reads:

while (current_ptr->data == value) &&

The lines:

linked_list_item *before_ptr; // Insert before this element
linked_list_item *after_ptr; // Insert after this element

now reads:

linked_list_item *before_ptr; // Insert after this element
linked_list_item *after_ptr; // Insert before this element

of "insert_ptr" to "after_ptr"

result = strcmp(node->word, word);

now reads:

result = strcmp(node->data, word);

void tree::enter_one(node *&tree_node, char *word)
{
int result; // Result of strcmp

// See if we have reached the end
if (tree_node == NULL) {
tree_node = new node;

tree_node->left = NULL;
tree_node->right = NULL;
tree_node->word = strdup(word);
}
result = strcmp(node->word, word);
if (result == 0)
return;

if (result < 0)
enter_one(tree_node->right, word);
else
enter_one(tree_node->left, word);
}

(changed "*&node" to "*&tree_node" in line 1, changed
"node" to "tree_node" in subsequent lines.)

"print_tree" to "print_one"

sentence: changed "print_tree" to "print_one"
(still in constant-width font.)

for (index = 1; index < sizeof(word); ++index) {

now reads:

for (index = 1; index < sizeof(word) -1; ++index) {

b_stack::b_stack(cont unsigned ...

now reads:

b_stack::b_stack(const unsigned ...

The line:

letter.send();

now reads:

letter.send_it();

(Compare class mail definition on page 388).

The sentence:

The trouble is that letter is a mail class, so when
we call letter.send() we call the send of the base
class mail.

now reads:

The trouble is that letter is a mail class, so when
we call letter.send_it() we call the send_it of the
base class mail.

In the second comment block, the Parameters explanation is senseless because
there is no parameter in the function.

Parameters
the stack -- stack to initialize

should be removed.

In the comment block, the function declaration:

int &operator [](int index)

should read:

int &operator [](const unsigned int index)

BLOCK_SIZE = 100

should be:

BLOCK_SIZE = 10

The right side of the first comment box should be realigned.

((HIGH_BOUND - LOW_BOUND) / (float) (NUMBER_OF_LINES);

a parenthesis is missing before ;.

- the #define make_max(type) line (first line) now reads:
#define define_max(type)

- the statement "return (d1)" now appears on the blank line in the
middle of each function in the "generated code" column.

if (strcmp(d1, d2) < 0

should read:

if (strcmp(d1, d2) > 0

(Compare same function on page 440).

The 3rd line should read:

#else /* __MSDOS__ */

and the 5th line should read:

#endif /* __MSDOS__ */

A semicolon is missing at the end of line:

char *name = "Test"

$(CCFLAGS)=-g

should read:

$(CCFLAGS) = -g

A semicolon is missing at the end of line:

cout << b_sample.*data_ptr << '
'

INDEX: