Download to read offline
![i
i
“main” — 2011/1/13 — 9:10 — page 8 — #30
i
i
i
i
i
i
8 Chapter 1. A C++ Primer
only to fundamental types, such as char and int—they may also point to complex
types and even to functions. Indeed, the popularity of C++ stems in part from its
ability to handle low-level entities like pointers.
It is useful to have a pointer value that points to nothing, that is, a null pointer.
By convention, such a pointer is assigned the value zero. An attempt to dereference
a null pointer results in a run-time error. All C++ implementations define a special
symbol NULL, which is equal to zero. This definition is activated by inserting the
statement “#include <cstdlib>” in the beginning of a program file.
We mentioned earlier that the special type void is used to indicate no type
information at all. Although we cannot declare a variable to be of type void, we
can declare a pointer to be of type void*. Such a pointer can point to a variable of
any type. Since the compiler is unable to check the correctness of such references,
the use of void* pointers is strongly discouraged, except in unusual cases where
direct access to the computer’s memory is needed.
Beware when declaring two or more pointers on the same line. The * operator
Caution binds with the variable name, not with the type name. Consider the following
misleading declaration.
int* x, y, z; // same as: int* x; int y; int z;
This declares one pointer variable x, but the other two variables are plain integers.
The simplest way to avoid this confusion is to declare one variable per statement.
Arrays
An array is a collection of elements of the same type. Given any type T and a
constant N, a variable of type T[N] holds an array of N elements, each of type T.
Each element of the array is referenced by its index, that is, a number from 0 to
N − 1. The following statements declare two arrays; one holds three doubles and
the other holds 10 double pointers.
double f[5]; // array of 5 doubles: f[0], . . ., f[4]
int m[10]; // array of 10 ints: m[0], . . ., m[9]
f[4] = 2.5;
m[2] = 4;
cout << f[m[2]]; // outputs f[4], which is 2.5
Once declared, it is not possible to increase the number of elements in an array.
Also, C++ provides no built-in run-time checking for array subscripting out of
bounds. This decision is consistent with C++’s general philosophy of not intro-
ducing any feature that would slow the execution of a program. Indexing an array
outside of its declared bounds is a common programming error. Such an error of-
ten occurs “silently,” and only much later are its effects noticed. In Section 1.5.5,](https://image.slidesharecdn.com/26841941-250513054829-3af4882c/75/Data-Structures-And-Algorithms-In-C-Michael-T-Goodrich-Roberto-Tamassia-36-2048.jpg)
![i
i
“main” — 2011/1/13 — 9:10 — page 9 — #31
i
i
i
i
i
i
1.1. Basic C++ Programming Elements 9
we see that the vector type of the C++ Standard Template Library (STL) provides
many of the capabilities of a more complete array type, including run-time index
checking and the ability to dynamically change the array’s size.
A two-dimensional array is implemented as an “array of arrays.” For example
“int A[15][30]” declares A to be an array of 30 objects, each of which is an array
of 15 integers. An element in such an array is indexed as A[i][j], where i is in the
range 0 to 14 and j is in the range 0 to 29.
When declaring an array, we can initialize its values by enclosing the elements
in curly braces ({...}). When doing so, we do not have to specify the size of the
array, since the compiler can figure this out.
int a[ ] = {10, 11, 12, 13}; // declares and initializes a[4]
bool b[ ] = {false, true}; // declares and initializes b[2]
char c[ ] = {’c’, ’a’, ’t’}; // declares and initializes c[3]
Just as it is possible to declare an array of integers, it is possible to declare an
array of pointers to integers. For example, int* r[17] declares an array r consist-
ing of 17 pointers to objects of type int. Once initialized, we can dereference an
element of this array using the * operator, for example, *r[16] is the value of the
integer pointed to by the last element of this array.
Pointers and Arrays
There is an interesting connection between arrays and pointers, which C++ inher-
ited from the C programming language—the name of an array is equivalent to a
pointer to the array’s initial element and vice versa. In the example below, c is
an array of characters, and p and q are pointers to the first element of c. They all
behave essentially the same, however.
char c[ ] = {’c’, ’a’, ’t’};
char* p = c; // p points to c[0]
char* q = &c[0]; // q also points to c[0]
cout << c[2] << p[2] << q[2]; // outputs “ttt”
This equivalence between array names and pointers can be confusing, but it helps
Caution to explain many of C++’s apparent mysteries. For example, given two arrays c and
d, the comparison (c == d) does not test whether the contents of the two arrays are
equal. Rather it compares the addresses of their initial elements, which is probably
not what the programmer had in mind. If there is a need to perform operations
on entire arrays (such as copying one array to another) it is a good idea to use the
vector class, which is part of C++’s Standard Template Library. We discuss these
concepts in Section 1.5.5.](https://image.slidesharecdn.com/26841941-250513054829-3af4882c/75/Data-Structures-And-Algorithms-In-C-Michael-T-Goodrich-Roberto-Tamassia-37-2048.jpg)
![i
i
“main” — 2011/1/13 — 9:10 — page 10 — #32
i
i
i
i
i
i
10 Chapter 1. A C++ Primer
Strings
A string literal, such as "Hello World", is represented as a fixed-length array of
characters that ends with the null character. Character strings represented in this
way are called C-style strings, since they were inherited from C. Unfortunately,
this representation alone does not provide many string operations, such as concate-
nation and comparison. It also possesses all the peculiarities of C++ arrays, as
mentioned earlier.
For this reason, C++ provides a string type as part of its Standard Template
Library (STL). When we need to distinguish, we call these STL strings. In order
to use STL strings it is necessary to include the header file <string>. Since STL
strings are part of the standard namespace (see Section 1.1.4), their full name is
std::string. By adding the statement “using std::string,” we inform the compiler
that we want to access this definition directly, so we can omit the “std::” prefix.
STL strings may be concatenated using the + operator, they may be compared with
each other using lexicographic (or dictionary) order, and they may be input and
output using the >> and << operators, respectively. For example:
#include <string>
using std::string;
// . . .
string s = "to be";
string t = "not " + s; // t = “not to be”
string u = s + " or " + t; // u = “to be or not to be”
if (s > t) // true: “to be” > “not to be”
cout << u; // outputs “to be or not to be”
There are other STL string operations, as well. For example, we can append one
string to another using the += operator. Also, strings may be indexed like arrays
and the number of characters in a string s is given by s.size(). Since some library
functions require the old C-style strings, there is a conversion function s.c str(),
which returns a pointer to a C-style string. Here are some examples:
string s = "John"; // s = “John”
int i = s.size(); // i = 4
char c = s[3]; // c = ’n’
s += " Smith"; // now s = “John Smith”
The C++ STL provides many other string operators including operators for ex-
tracting, searching for, and replacing substrings. We discuss some of these in Sec-
tion 1.5.5.
C-Style Structures
A structure is useful for storing an aggregation of elements. Unlike an array, the
elements of a structure may be of different types. Each member, or field, of a](https://image.slidesharecdn.com/26841941-250513054829-3af4882c/75/Data-Structures-And-Algorithms-In-C-Michael-T-Goodrich-Roberto-Tamassia-38-2048.jpg)
![i
i
“main” — 2011/1/13 — 9:10 — page 12 — #34
i
i
i
i
i
i
12 Chapter 1. A C++ Primer
For example, suppose that in our airline system we encounter a new passenger.
We would like to dynamically create a new instance using the new operator. Let
p be a pointer to a Passenger structure. This implies that *p refers to the actual
structure; hence, we could access one of its members, say the mealPref field, using
the expression (*p).mealPref. Because complex objects like structures are often
allocated dynamically, C++ provides a shorter way to access members using the
“->” operator.
pointer name->member is equivalent to (*pointer name).member
For example, we could allocate a new passenger object and initialize its members
as follows.
Passenger *p;
// . . .
p = new Passenger; // p points to the new Passenger
p−>name = "Pocahontas"; // set the structure members
p−>mealPref = REGULAR;
p−>isFreqFlyer = false;
p−>freqFlyerNo = "NONE";
It would be natural to wonder whether we can initialize the members using the curly
brace ({...}) notation used above. The answer is no, but we will see another more
convenient way of initializing members when we discuss classes and constructors
in Section 1.5.2.
This new passenger object continues to exist in the free store until it is explicitly
deleted—a process that is done using the delete operator, which destroys the object
and returns its space to the free store.
delete p; // destroy the object p points to
The delete operator should only be applied to objects that have been allocated
through new. Since the object at p’s address was allocated using the new operator,
the C++ run-time system knows how much memory to deallocate for this delete
statement. Unlike some programming languages such as Java, C++ does not pro-
vide automatic garbage collection. This means that C++ programmers have the
responsibility of explicitly deleting all dynamically allocated objects.
Arrays can also be allocated with new. When this is done, the system allocator
returns a pointer to the first element of the array. Thus, a dynamically allocated
array with elements of type T would be declared being of type *T. Arrays allocated
in this manner cannot be deallocated using the standard delete operator. Instead,
the operator delete[ ] is used. Here is an example that allocates a character buffer
of 500 elements, and then later deallocates it.
char* buffer = new char[500]; // allocate a buffer of 500 chars
buffer[3] = ’a’; // elements are still accessed using [ ]
delete [ ] buffer; // delete the buffer](https://image.slidesharecdn.com/26841941-250513054829-3af4882c/75/Data-Structures-And-Algorithms-In-C-Michael-T-Goodrich-Roberto-Tamassia-40-2048.jpg)
![i
i
“main” — 2011/1/13 — 9:10 — page 14 — #36
i
i
i
i
i
i
14 Chapter 1. A C++ Primer
Constants and Typedef
Good programmers commonly like to associate names with constant quantities.
By adding the keyword const to a declaration, we indicate that the value of the
associated object cannot be changed. Constants may be used virtually anywhere
that literals can be used, for example, in an array declaration. As a hint to the
reader, we will use all capital letters when naming constants.
const double PI = 3.14159265;
const int CUT OFF[ ] = {90, 80, 70, 60};
const int N DAYS = 7;
const int N HOURS = 24*N DAYS; // using a constant expression
int counter[N HOURS]; // an array of 168 ints
Note that enumerations (see Section 1.1.2) provide another convenient way to de-
fine integer-valued constants, especially within structures and classes.
In addition to associating names with constants, it is often useful to associate a
name with a type. This association can be done with a typedef declaration. Rather
than declaring a variable, a typedef defines a new type name.
typedef char* BufferPtr; // type BufferPtr is a pointer to char
typedef double Coordinate; // type Coordinate is a double
BufferPtr p; // p is a pointer to char
Coordinate x, y; // x and y are of type double
By using typedef we can provide shorter or more meaningful synonyms for
various types. The type name Coordinate provides more of a hint to the reader
of the meaning of variables x and y than does double. Also, if later we decide
to change our coordinate representation to int, we need only change the typedef
statement. We will follow the convention of indicating user-defined types by capi-
talizing the first character of their names.
Local and Global Scopes
When a group of C++ statements are enclosed in curly braces ({...}), they define
a block. Variables and types that are declared within a block are only accessible
from within the block. They are said to be local to the block. Blocks can be nested
within other blocks. In C++, a variable may be declared outside of any block.
Such a variable is global, in the sense that it is accessible from everywhere in the
program. The portions of a program from which a given name is accessible are
called its scope.
Two variables of the same name may be defined within nested blocks. When
this happens, the variable of the inner block becomes active until leaving the block.](https://image.slidesharecdn.com/26841941-250513054829-3af4882c/75/Data-Structures-And-Algorithms-In-C-Michael-T-Goodrich-Roberto-Tamassia-42-2048.jpg)
![i
i
“main” — 2011/1/13 — 9:10 — page 16 — #38
i
i
i
i
i
i
16 Chapter 1. A C++ Primer
The Using Statement
If we are repeatedly using variables from the same namespace, it is possible to
avoid entering namespace specifiers by telling the system that we want to “use” a
particular specifier. We communicate this desire by utilizing the using statement,
which makes some or all of the names from the namespace accessible, without
explicitly providing the specifier. This statement has two forms that allow us to
list individual names or to make every name in the namespace accessible as shown
below.
using std::string; // makes just std::string accessible
using std::cout; // makes just std::cout accessible
using namespace myglobals; // makes all of myglobals accessible
1.2 Expressions
An expression combines variables and literals with operators to create new values.
In the following discussion, we group operators according to the types of objects
they may be applied to. Throughout, we use var to denote a variable or anything
to which a value may be assigned. (In official C++ jargon, this is called an lvalue.)
We use exp to denote an expression and type to denote a type.
Member Selection and Indexing
Some operators access a member of a structure, class, or array. We let class name
denote the name of a structure or class; pointer denotes a pointer to a structure or
class and array denotes an array or a pointer to the first element of an array.
class name . member class/structure member selection
pointer −> member class/structure member selection
array [ exp ] array subscripting
Arithmetic Operators
The following are the binary arithmetic operators:
exp + exp addition
exp − exp subtraction
exp * exp multiplication
exp / exp division
exp % exp modulo (remainder)
There are also unary minus (–x) and unary plus (+x) operations. Division be-
tween two integer operands results in an integer result by truncation, even if the
www.allitebooks.com](https://image.slidesharecdn.com/26841941-250513054829-3af4882c/75/Data-Structures-And-Algorithms-In-C-Michael-T-Goodrich-Roberto-Tamassia-44-2048.jpg)
![i
i
“main” — 2011/1/13 — 9:10 — page 17 — #39
i
i
i
i
i
i
1.2. Expressions 17
result is being assigned to a floating point variable. The modulo operator n%m
yields the remainder that would result from the integer division n/m.
Increment and Decrement Operators
The post-increment operator returns a variable’s value and then increments it by
1. The post-decrement operator is analogous but decreases the value by 1. The
pre-increment operator first increments the variables and then returns the value.
var ++ post increment
var −− post decrement
++ var pre increment
−− var pre decrement
The following code fragment illustrates the increment and decrement operators.
int a[ ] = {0, 1, 2, 3};
int i = 2;
int j = i++; // j = 2 and now i = 3
int k = −−i; // now i = 2 and k = 2
cout << a[k++]; // a[2] (= 2) is output; now k = 3
Relational and Logical Operators
C++ provides the usual comparison operators.
exp < exp less than
exp > exp greater than
exp <= exp less than or equal
exp >= exp greater than or equal
exp == exp equal to
exp != exp not equal to
These return a Boolean result—either true or false. Comparisons can be made
between numbers, characters, and STL strings (but not C-style strings). Pointers
can be compared as well, but it is usually only meaningful to test whether pointers
are equal or not equal (since their values are memory addresses).
The following logical operators are also provided.
! exp logical not
exp && exp logical and
exp | | exp logical or
The operators && and | | evaluate sequentially from left to right. If the left
operand of && is false, the entire result is false, and the right operand is not eval-
uated. The | | operator is analogous, but evaluation stops if the left operand is true.
This “short circuiting” is quite useful in evaluating a chain of conditional ex-
pressions where the left condition guards against an error committed by the right](https://image.slidesharecdn.com/26841941-250513054829-3af4882c/75/Data-Structures-And-Algorithms-In-C-Michael-T-Goodrich-Roberto-Tamassia-45-2048.jpg)
![i
i
“main” — 2011/1/13 — 9:10 — page 20 — #42
i
i
i
i
i
i
20 Chapter 1. A C++ Primer
to lowest. For example, the expression 0 < 4 + x * 3 would be evaluated as if it
were parenthesized as 0 < (4 + (x * 3)). If p is an array of pointers, then *p[2] is
equivalent to *(p[2]). Except for && and | |, which guarantee left-to-right evalua-
tion, the order of evaluation of subexpressions is dependent on the implementation.
Since these rules are complex, it is a good idea to add parentheses to complex
expressions to make your intent clear to someone reading your program.
Operator Precedences
Type Operators
scope resolution namespace name :: member
selection/subscripting class name.member pointer−>member array[exp]
function call function(args)
postfix operators var++ var−−
prefix operators ++var −−var +exp −exp ˜exp !exp
dereference/address *pointer &var
multiplication/division * / %
addition/subtraction + −
shift << >>
comparison < <= > >=
equality == !=
bitwise and &
bitwise exclusive-or ^
bitwise or |
logical and &&
logical or | |
conditional bool exp ? true exp : false exp
assignment = += −= *= /= %= >>= <<= &= ^= |=
Table 1.1: The C++ precedence rules. The notation “exp” denotes any expression.
1.2.1 Changing Types through Casting
Casting is an operation that allows us to change the type of a variable. In essence,
we can take a variable of one type and cast it into an equivalent variable of another
type. Casting is useful in many situations. There are two fundamental types of
casting that can be done in C++. We can either cast with respect to the fundamental
types or we can cast with respect to class objects and pointers. We discuss casting
with fundamental types here, and we consider casting with objects in Section 2.2.4.
We begin by introducing the traditional way of casting in C++, and later we present
C++’s newer casting operators.](https://image.slidesharecdn.com/26841941-250513054829-3af4882c/75/Data-Structures-And-Algorithms-In-C-Michael-T-Goodrich-Roberto-Tamassia-48-2048.jpg)
![i
i
“main” — 2011/1/13 — 9:10 — page 25 — #47
i
i
i
i
i
i
1.3. Control Flow 25
the current array element.
int a[100];
// . . .
int i = 0;
int sum = 0;
while (i < 100 && a[i] >= 0) {
sum += a[i++];
}
The do-while loop is similar to the while loop in that the condition is tested at
the end of the loop execution rather than before. It has the following syntax.
do
loop body statement
while ( condition )
For Loop
Many loops involve three common elements: an initialization, a condition under
which to continue execution, and an increment to be performed after each execution
of the loop’s body. A for loop conveniently encapsulates these three elements.
for ( initialization ; condition ; increment )
loop body statement
The initialization indicates what is to be done before starting the loop. Typ-
ically, this involves declaring and initializing a loop-control variable or counter.
Next, the condition gives a Boolean expression to be tested in order for the loop to
continue execution. It is evaluated before executing the loop body. When the con-
dition evaluates to false, execution jumps to the next statement after the for loop.
Finally, the increment specifies what changes are to be made at the end of each
execution of the loop body. Typically, this involves incrementing or decrementing
the value of the loop-control variable.
Here is a simple example, which prints the positive elements of an array, one
per line. Recall that ’n’ generates a newline character.
const int NUM ELEMENTS = 100;
double b[NUM ELEMENTS];
// . . .
for (int i = 0; i < NUM ELEMENTS; i++) {
if (b[i] > 0)
cout << b[i] << ’n’;
}
In this example, the loop variable i was declared as int i = 0. Before each iteration,
the loop tests the condition “i < NUM ELEMENTS” and executes the loop body](https://image.slidesharecdn.com/26841941-250513054829-3af4882c/75/Data-Structures-And-Algorithms-In-C-Michael-T-Goodrich-Roberto-Tamassia-53-2048.jpg)
![i
i
“main” — 2011/1/13 — 9:10 — page 26 — #48
i
i
i
i
i
i
26 Chapter 1. A C++ Primer
only if this is true. Finally, at the end of each iteration the loop uses the statement
i++ to increment the loop variable i before testing the condition again. Although
the loop variable is declared outside the curly braces of the for loop, the compiler
treats it as if it were a local variable within the loop. This implies that its value is
not accessible outside the loop.
Break and Continue Statements
C++ provides statements to change control flow, including the break, continue,
and return statements. We discuss the first two here, and leave the return state-
ment for later. A break statement is used to “break” out of a loop or switch state-
ment. When it is executed, it causes the flow of control to immediately exit the
innermost switch statement or loop (for loop, while loop, or do-while loop). The
break statement is useful when the condition for terminating the loop is determined
inside the loop. For example, in an input loop, termination often depends on a
specific value that has been input. The following example provides a different
implementation of an earlier example, which sums the elements of an array until
finding the first negative value.
int a[100];
// . . .
int sum = 0;
for (int i = 0; i < 100; i++) {
if (a[i] < 0) break;
sum += a[i];
}
The other statement that is often useful for altering loop behavior is the con-
tinue statement. The continue statement can only be used inside loops (for, while,
and do-while). The continue statement causes the execution to skip to the end of
the loop, ready to start a new iteration.
1.4 Functions
A function is a chunk of code that can be called to perform some well-defined task,
such as calculating the area of a rectangle, computing the weekly withholding tax
for a company employee, or sorting a list of names in ascending order. In order to
define a function, we need to provide the following information to the compiler:
Return type. This specifies the type of value or object that is returned by the func-
tion. For example, a function that computes the area of a rectangle might re-
turn a value of type double. A function is not required to return a value. For
example, it may simply produce some output or modify some data structure.
www.allitebooks.com](https://image.slidesharecdn.com/26841941-250513054829-3af4882c/75/Data-Structures-And-Algorithms-In-C-Michael-T-Goodrich-Roberto-Tamassia-54-2048.jpg)
![to the south of the Forth and Clyde, while the Northern Picts
occupied the whole district to the north of these estuaries. The best
authorities, however, are of opinion that both divisions dwelt to the
north of Antonine’s wall, and were divided from each other by the
Grampians.
What more immediately concerns our present purpose is a
passage in Adamnan’s work in which he speaks of Columba
preaching to the Picts through an interpreter. Now Columba was an
Irish Scot, whose native tongue was Gaelic, and it is from this
argued that the Picts to whom he preached must have spoken a
different language, or at least dialect, and belonged to a different
race or tribe from the saint himself. Mr. Skene,[44]
who ably
advocates the Gaelic origin of the Picts, perceiving this difficulty,
endeavours to explain away the force of the passage by making it
mean that Columba “interpreted or explained the word of God, that
is, the Bible, which, being written in Latin, would doubtless require
to be interpreted to them.” The passage as quoted by Skene is,
“Verbo Dei per interpretorem recepto.” Garnett, however, one of the
most competent and candid writers on this question in its
philological aspect, and who maintains, with the greatest clearness
and ability, the Cymric origin of the Picts, looks at the passage in a
different light. The entire passage, he says,[45]
as it stands in
Colganus, is as follows:—“Alio in tempore quo sanctus Columba in
Pictorum provincia per aliquot demorabatur dies, quidam cum tota
plebeius familia, verbum vitæ per interpretorem, Sancto prædicante
viro, audiens credidit, credensque baptizatus est.”[46]
“Here it will be
observed,” continues Garnett, “Adamnan does not say, ‘verbum Dei,’
which might have been construed to mean the Scripture, but
‘verbum vitæ, Sancto prædicante viro,’ which can hardly mean
anything but ‘the word of life, as it was preached by the Saint.’”
Certainly, we think, the unprejudiced reader must admit that, so far
as this point is concerned, Mr. Garnett has the best of it. Although at
that time the Gaelic and Cymric dialects may have had much more in
common than they have at the present day, nevertheless it appears](https://image.slidesharecdn.com/26841941-250513054829-3af4882c/75/Data-Structures-And-Algorithms-In-C-Michael-T-Goodrich-Roberto-Tamassia-56-2048.jpg)
![to be beyond a doubt that the difference between the two was so
great that a Gael would be unintelligible to a speaker of Cymric.[47]
The next and most important authority of this class on this
quæstio vexata is the Venerable Bede, who, considering the age in
which he lived, exercised so much caution and discrimination, that
he deserves to be listened to with respect. Bede was born about
673. He was educated in the Monastery of Wearmouth, whence he
removed to Jarrow, where he was ordained deacon in his nineteenth
year, and priest in his thirtieth, and where he spent the rest of his
days, dying in 735. He wrote many works, but the most important is
the Historia Ecclesiastica Gentis Anglorum, the materials for which
he obtained chiefly from native chronicles and biographies, records
and public documents, and oral and written communications from
contemporaries.
We shall transcribe most of the passage in which Bede speaks of
the ancient inhabitants of Britain; so that our readers may be able to
judge for themselves of the nature and value of the testimony borne
by this venerable author. It must, however, be kept in mind that
Bede does not pretend to give any but the ecclesiastical history of
the English nation, everything else being subsidiary to this.
“This island at present, following the number of the books in
which the Divine law was written, contains five nations, the English,
Britons, Scots, Picts, and Latins, each in its own peculiar dialect
cultivating the sublime study of Divine truth. The Latin tongue is, by
the study of the Scriptures, become common to all the rest. At first
this island had no other inhabitants but the Britons, from whom it
derived its name, and who coming over into Britain, as is reported,
from Armorica, possessed themselves of the southern parts thereof.
When they, beginning at the south, had made themselves master of
the greatest part of the island, it happened, that the nation of the
Picts coming into the ocean from Scythia, as is reported, in a few tall
ships, were driven by the winds beyond the shores of Britain and
arrived off Ireland, on the northern coasts, where, finding the nation
of the Scots, they requested to be allowed to settle among them,](https://image.slidesharecdn.com/26841941-250513054829-3af4882c/75/Data-Structures-And-Algorithms-In-C-Michael-T-Goodrich-Roberto-Tamassia-57-2048.jpg)
![but could not succeed in obtaining their request. The Scots
answered, that the island could not contain them both; but ‘we can
give you good advice,’ said they, ‘what to do; we know there is
another island, not far from ours, to the eastward, which we often
see at a distance, when the days are clear. If you will repair thither,
you may be able to obtain settlements; or if they should oppose you,
you may make use of us as auxiliaries.’ The Picts accordingly sailing
over into Britain, began to inhabit the northern parts thereof, for the
Britons were possessed of the southern. Now the Picts having no
wives, and asking them of the Scots, they would not consent to
grant them upon any other terms, than that when any difficulty
should arise, they should rather choose themselves a king from the
female royal race than from the male; which custom, as is well
known, has been observed among the Picts to this day. In process of
time, Britain, besides the Britons and the Picts, received a third
nation, the Scots, who, departing out of Ireland under their leader
Reuda, either by fair means, or by force of arms, secured to
themselves those settlements among the Picts which they still
possess. From the name of their commander, they are to this day
called Dalreudins; for in their language Dal signifies a part.... It is
properly the country of the Scots, who, migrating from thence, as
has been said, added a third nation in Britain to the Britons and the
Picts. There is a very large gulf of the sea, which formerly divided
the nation of the Picts from the Britons; which gulf runs from the
west very far into the land, where, to this day, stands the strong city
of the Britons, called Alcluith. The Scots arriving on the north side of
this bay, settled themselves there.”[48]
Here then Bede informs us that in his time the common report
was that the Picts came into Scotland from Scythia, which, like the
Germania of Tacitus, may be taken to mean the northern countries
of Europe generally. This is substantially the same statement as that
of the author of the Historia Britonum, commonly called Nennius,
who lived in the 9th century, and who informs us that the Picts
coming to Scotland about 300 B.C., occupied the Orkney Islands,
whence issuing, they laid waste many regions, and seized those on](https://image.slidesharecdn.com/26841941-250513054829-3af4882c/75/Data-Structures-And-Algorithms-In-C-Michael-T-Goodrich-Roberto-Tamassia-58-2048.jpg)
![the left-hand side, i.e. the north of Britain, where they still remained
in the writer’s time, keeping possession of a third part of Britain.[49]
Supposing that Bede’s report was quite in accordance with truth,
still it gives us but small help in coming to a conclusion as to the
place of these Picts among the families of men. It is certain that by
far the greater part of Europe had at one time a Celtic population
who preceded, but ultimately gave way to another wave of
emigrants from the east. Now, if we knew the date at which this so-
called migration of the Picts took place it might be of considerable
assistance to us; but as we cannot now find out whether these
emigrants proceeded from a Celtic or a Teutonic stock, the
statement of Bede, even if reliable, helps us not at all towards a
solution of the question as to the race of the Picts. Innes[50]
remarks
very justly on this point—“Now, supposing that there were any good
ground for the opinion of these two writers, which they themselves
give only as a conjecture or hearsay, and that we had any certainty
of the Caledonians, or Picts, having had their origin from the more
northern parts of the European continent, it were an useless, as well
as an endless discussion, to examine in particular from which of all
the northern nations of the continent the first colony came to
Caledonia; because that these nations of the north were almost in
perpetual motion, and changing habitations, as Strabo remarks; and
he assigns for it two reasons: the one, because of the barrenness of
the soil, they tilled not the ground, and built habitations only for a
day; the other, because being often overpowered by their
neighbours, they were forced to remove. Another reason why it is
impossible to know from which of those nations the northern parts
of Britain, (supposing they came from thence) were at first peopled,
is because we have but very lame accounts of these northern
nations from the Greek or Roman writers, (from whom alone we can
look for any thing certain in those early times) especially of those of
Scandia, to the north of the Baltic sea, as the same Strabo observes.
Besides, it appears that Caledonia was peopled long before the
inhabitants of these northern parts of the continent were mentioned,
or even known by the most ancient writers we have; and perhaps](https://image.slidesharecdn.com/26841941-250513054829-3af4882c/75/Data-Structures-And-Algorithms-In-C-Michael-T-Goodrich-Roberto-Tamassia-59-2048.jpg)
![conclusion we are forced to is, that from this passage nothing can be
gained to help us out of our difficulty.
There is a statement at the end of the passage quoted to which
we would draw the reader’s attention, as being Bede’s way, and no
doubt the universal way in his time, of accounting for a peculiar law
which appears to have regulated the succession to the Pictish
throne, and which ultimately, according to some, was the means of
placing on that throne a Scottish monarch; thus accounting to some
extent for the sudden disappearance and apparent destruction of the
Pictish people and language.
We shall here refer to one other passage in the same historian,
which has perhaps given rise to greater and more acrimonious
contention than any other point in connection with this wordy
discussion. The only word that has come down to us, which, with
the exception of the names of the Pictish kings, we can be sure is a
remnant of the Pictish language, is the name said by Bede to have
been given to the eastern termination of the wall of Antonine. Bede,
[51]
in speaking of the turf wall built by the Britons of Valentia in the
beginning of the 5th century, says, “it begins at about two miles
distance from the monastery of Abercorn on the west, at a place
called in the Pictish language Peanfahel, but in the English tongue
Penneltum.” This statement of Bede’s is straightforward and clear
enough, and has never been disputed by any writer on any one of
the three sides of the question. Nevertheless it has been used by the
advocates respectively of the Gothic, Gaelic, and Cymric origin of the
Picts, as an undoubted proof of the correctness of each of these
theories. Pinkerton, whose dishonesty and acrimoniousness are well
known, and must detract considerably from the force of his
arguments, claims it as being entirely Gothic or Teutonic. “The
Pictish word,” he says,[52]
“is broad Gothic; Paena ‘to extend,’ Ihre;
and Vahel, a broad sound of veal, the Gothic for ‘wall,’ or of the Latin
vallum, contracted val; hence it means ‘the extent or end of the
wall.’” This statement of Pinkerton’s may be dismissed as too far-
fetched and awkward to merit much consideration, and we may
safely regard the word as capable of satisfactory explanation only in](https://image.slidesharecdn.com/26841941-250513054829-3af4882c/75/Data-Structures-And-Algorithms-In-C-Michael-T-Goodrich-Roberto-Tamassia-61-2048.jpg)
![Celtic. Innes, who upholds the British, i.e. the Cymric, origin of the
Picts, says,[53]
“we nowhere find a clearer proof of the Pictish
language being the same as the British [Welsh], than in Bede, where
he tells us that Penuahel in Pictish signifies the head of the wall,
which is just the signification that the same two words Pen and
Uahel have in the British.” In this opinion Chalmers and other
advocates of the Cymric theory coincide. Mr. Garnett, who essentially
agrees with Innes and Chalmers as to the Cymric origin of the Picts,
lays little stress upon this word as furnishing an argument in support
of his theory. “Almost the only Pictish word given us by an ancient
writer is the well-known Pen val (or as it appears in the oldest MSS.
of Bede (Peann fahel)), the name given by the Picts to the Wall’s
End, or eastern termination of the Vallum of Antoninus. It is scarcely
necessary to say the first part of the word is decidedly Cymric; pen,
head, being contrary to all Gaelic analogy. The latter half might be
plausibly claimed as the Gaelic fal; gwall being the more common
termination in Welsh for a wall or rampart. Fal, however, does occur
in Welsh in the sense of inclosure, a signification not very
remote.”[54]
The two most recent and able supporters[55]
of the Gaelic theory
are of much the same mind as Garnett, and appear to regard this
tantalizing word as affording no support to either side. Burton[56]
cannot admit that anything has been made out of this leading to a
historical conclusion.
We may safely conclude, then, that this so called Pictish word, or,
indeed, any information which we find in Bede, affords us no key to
the perplexing question of the origin and race of the Picts.
We learn, however, one fact from Bede[57]
which is so far
satisfactory, viz., that in his time there were two divisions of the
Picts, known as the Northern and Southern Picts, which were
separated from each other by steep and rugged mountains. On
reading the passage in Bede, one very naturally supposes that the
steep and rugged mountains must be the Grampians, to which the
expression applies more aptly than to any other mountain-chain in](https://image.slidesharecdn.com/26841941-250513054829-3af4882c/75/Data-Structures-And-Algorithms-In-C-Michael-T-Goodrich-Roberto-Tamassia-62-2048.jpg)
![Scotland. Even this, however, has been made matter of dispute, it
being contended by some that the locality of the Southern Picts was
in the south-west and south of Scotland, where some writers set up
a powerful Pictish kingdom. Mr. Grub,[58]
however, has clearly shown
that the locality of the Southern Picts was to the north of the Forth
and Clyde, and to the south of the Grampians. “The mistake
formerly so common in regard to the country of the Southern Picts
converted by St. Ninian, was in part owing to the situation of
Candida Casa. It was supposed that his see must have been in the
country of those whom he converted.” He clearly proves that it was
not so in reality, and that there was nothing so unusual in the
situation as to justify the conclusion which was drawn from it. “It
was, no doubt, the case that the teachers by whom the chief Celtic
and Teutonic nations were converted generally fixed their seat
among those whom they instructed in the faith. But there was no
necessity for this, especially when the residence of the teacher was
in the neighbourhood of his converts. St. Columba was primate of all
the churches of the Northern Picts, but he did not permanently
reside among that nation. St. Ninian had ready access to his Pictish
converts, and could govern them as easily from his White Church on
the Solway, as Columba could instruct and rule the Northern Picts
from his monastery in Iona.”[59]
Other authorities appealed to by the upholders of each of the
Celtic theories are the Welsh traditions, the Irish Annals, the
Chronicles of the Picts and Scots, and various legendary documents
of more or less value and authenticity. As these are of no greater
authority than the writers with whom we have been dealing, and as
the partisans of each theory claim the various passages as either
confirming, or, at any rate, not contradicting their views, we shall not
further trouble the reader with specimens of the manner in which
they are dealt with. There is one passage, however, in the Welsh
Triads, which the advocates of the Gaelic hypothesis claim as
strongly confirmatory of their theory. After referring to the coming in
of the Cymry, the Britons, etc., the Triads[60]
go on to say, “Three
tribes came, under protection, into the Island of Britain, and by the](https://image.slidesharecdn.com/26841941-250513054829-3af4882c/75/Data-Structures-And-Algorithms-In-C-Michael-T-Goodrich-Roberto-Tamassia-63-2048.jpg)
![consent and permission of the nation of the Cymry, without weapon,
without assault. The first was the tribe of the Caledonians in the
north. The second was the Gwyddelian Race, which are now in Alban
(Scotland). The third were the men of Galedin, who came into the
Isle of Wight. Three usurping tribes came into the Island of Britain
and never departed out of it. The first were the Coranied, who came
from the land of Pwyl. The second were the Gwyddelian Ffichti, who
came into Alban over the sea of Llychlyn (Denmark). The third were
the Saxons.” “The Triads,” says Skene[61]
in connection with this,
“appear distinctly to have been written previous to the Scottish
conquest in the ninth century, and they mention among the three
usurping tribes of Britain the ‘Gwyddyl Ffichti,’ and add immediately
afterwards, ‘and these Gwyddyl Ffichti are in Alban, along the shore
of the sea of Llychlyn.’ In another place, among the treacherous
tribes of Britain, the same Triads mention the ‘Gwyddyl coch o’r
Werddon a ddaethant in Alban,’ that is ‘the Red Gwyddyl from
Ireland, who came into Alban,’ plainly alluding to the Dalriads, who
were an Irish colony, and who have been acknowledged by all to
have been a Gaelic race. It will be observed from these passages
that the Welsh Triads, certainly the oldest and most unexceptionable
authority on the subject, apply the same term of Gwyddyl to the
Picts and to the Dalriads, and consequently they must have been of
the same race, and the Picts a Gaelic people. Farther, the Welsh
word ‘Gwyddyl,’ by which they distinguish that race, has been
declared by all the best authorities to be exactly synonymous with
the word Gael, the name by which the Highlanders have at all times
been distinguished, and the Welsh words ‘Gwyddyl Ffichti’ cannot be
interpreted to mean any thing else than ‘The Gaelic Picts,’ or ‘Pictish
Gael.’”
The following is the substance of the information given by the
Irish writers as to the origin, race, and early history of the Picts. The
greater part of it is, of course, mere tradition, accumulating as it
grew older, and heightened by the imagination of the writers
themselves.[62]
The Picts were called by the Irish writers Cruithnidh,
which O’Brien considers to be the same as Britneigh, or Britons; but](https://image.slidesharecdn.com/26841941-250513054829-3af4882c/75/Data-Structures-And-Algorithms-In-C-Michael-T-Goodrich-Roberto-Tamassia-64-2048.jpg)
![the principal battle-ground on which to fight out this endless and
profitless strife. Most of them take for granted that if the language
spoken by any people can be found out, a sure indication is afforded
of the race to which that people belonged; and that the topography
of a country must necessarily have been imposed by the earliest
inhabitants of whom we have record; and that, if so, the limits of
their territory must have been co-extensive with the limits of such
topography. This, however, is going too far. All the length to which
we are permitted in fairness to go, when we find in any district or
country an abundance of names of natural objects, as rivers and
mountains, which can with certainty be traced to any particular
language, is, that at one time or other, a race of people speaking
this language must have passed over and dwelt for some time in
that particular district or country. We find Celtic names of rivers and
mountains scattered all over Europe, in the midst of peoples who are
admitted on all hands to have little or none of the Celtic element in
them.[63]
So that an unprejudiced judge must admit that the fact of
Cymric and Gaelic words being found in certain districts of the north
of Scotland argues only that at one time people speaking these
dialects must have dwelt in these districts. It affords no proof by
itself that the people whom we first meet with in these districts are
the people who spoke these dialects, and who imposed these
names; nor indeed, if we could be sure that the people whom we
first meet with as inhabitants also spoke the dialect to which such
names belong, does it prove that they were the imposers of these
names, that the dialect was their native and original tongue, and
that they had not acquired it either as conquerors or conquered. Nor
can it be adduced as a proof of sameness of race, that the present
inhabitants of any particular district speak the same language as
those who inhabited that district 1800 years ago or less. “He who
trusts to language, and especially to written language, alone, as an
index to race, must be prepared to maintain that the Gallic nation
emigrated from the seven hills of Rome, and that the Franks came
with them; that the Romans extirpated the Celts and Iberians of
Spain, and that the Goths and Moors spoke nearly the same](https://image.slidesharecdn.com/26841941-250513054829-3af4882c/75/Data-Structures-And-Algorithms-In-C-Michael-T-Goodrich-Roberto-Tamassia-66-2048.jpg)
![language as the Romans; that the Negroes of the United States and
Jamaica were exported from England when in their infancy. So would
Philology, if left to herself, interpret phenomena, of which we know,
from other sources of information, that the causes are totally
different.”[64]
“The clearest proof that a mountain or river has a Celtic
name, only shows that at some time or other Celts had been there;
it does not tell us when they were there. Names, as the experience
of the world amply shows, live after the people who bestowed them
have long disappeared, and that through successive races of
occupants.”[65]
The materials which have been wrought up into a linguistic
argument by the upholders of each of the three Pictish theories,
Gothic, Gaelic, and Cymric, are chiefly a list of Pictish kings which,
we believe, may be depended on as authentic, and the topography
of the country to the east and south-east of the Grampians, together
with the single so-called Pictish word Peanfahel, which we have
already considered. The theorists differ as much in their
interpretation of the significance of what remains of the Pictish
language, as we have seen they do in their interpretation of any
references to the subject in dispute in ancient chronicles. The names
of the kings, and the names of places have been traced by the
disputants to Gothic, Gaelic and Cymric roots. As an amusing
specimen of the ingenuity displayed in this hunt after roots, we give
below a small table from Burton, comparing the different
etymologies of names of kings given by Pinkerton, Chalmers, and
Jamieson.[66]
It is, however, generally admitted at the present day, that so far as
language is concerned, the Gothic theory has not the remotest
chance; that names of places and of kings are most satisfactorily
and straightforwardly explained by Cymric roots. As the Gothic or
Teutonic theory cannot stand the test of modern criticism, we shall
content ourselves with giving specimens of the manner in which the
linguistic, or, more strictly, topographical argument is used by the
advocates of the Cymric and Gaelic hypotheses respectively.](https://image.slidesharecdn.com/26841941-250513054829-3af4882c/75/Data-Structures-And-Algorithms-In-C-Michael-T-Goodrich-Roberto-Tamassia-67-2048.jpg)
![The Cymric argument is clearly, ably, and succinctly stated by Mr.
Garnett in his essay on “The Relation of the Pict and Gael;” he,
however, it must be remembered, looked at the whole question
mainly in its philological aspect. In stating the argument we shall use
chiefly his own words.[67]
“That the Picts were actually Celts, and not
of Teutonic race, is proved to a demonstration by the names of their
kings; of whom a list, undoubtedly genuine from the fifth century
downwards, was published by Innes, from a manuscript in the
Colbertine library. Some of those appellations are, as far as we know
at present, confined to the Pictish sovereigns; but others are well-
known Welsh and Gaelic names. They differ, however, slightly in their
forms, from their Cymric equivalents; and more decidedly so from
the Gaelic ones; and, as far as they go, lead to the supposition that
those who bore them spoke a language bearing a remote analogy to
the Irish with its cognates, but a pretty close one to the Welsh.
“In the list furnished by Innes the names Maelcon, Elpin, Taran
(i.e. thunder), Uven (Owen), Bargoit, are those of personages well
known in British history or tradition. Wrgust, which appears as
Fergus in the Irish annals, is the Welsh Gwrgust. Talorg, Talorgan,
evidently contain the British word Tal, forehead, a common element
in proper names; ex. gr. Talhaiarn, Iron Forehead; Taliesin, splendid
forehead, &c. Taleurgain would signify in Welsh golden or splendid
front. Three kings are represented as sons of Wid, in the Irish annals
of Foit or Foith. In Welsh orthography it would be Gwydd, wild; a
common name in Brittany at the present day, under the form of
Gwez. The names Drust, Drostan, Wrad, Necton (in Bede Naitan),
closely resemble the Welsh Trwst, Trwstan, Gwriad, Nwython. It will
be sufficient to compare the entire list with the Irish or Highland
genealogies, to be convinced that there must have been a material
distinction between the two branches. Most of the Pictish names are
totally unknown in Irish or Highland history, and the few that are
equivalent, such as Angus and Fergus, generally differ in form. The
Irish annalists have rather obscured the matter, by transforming
those names according to their national system of orthography; but
it is remarkable that a list in the ‘Book of Ballymote,’ partly given by](https://image.slidesharecdn.com/26841941-250513054829-3af4882c/75/Data-Structures-And-Algorithms-In-C-Michael-T-Goodrich-Roberto-Tamassia-68-2048.jpg)
![Lynch in his ‘Cambrensis Eversus,’ agrees closely with Innes, even
preserving the initial w or u where the Gaelic would require f. The
philological inferences to be deduced from this document may be
thus briefly summed up:—1. The names of the Pictish kings are not
Gaelic, the majority of them being totally unknown both in the Irish
and Highland dialects, while the few which have Gaelic equivalents
decidedly differ from them in form. Cineod (Kenneth) and Domhnall
or Donnel, appear to be the only exceptions. 2. Some of them
cannot be identified as Welsh; but the greater number are either
identical with or resemble known Cymric names; or approach more
nearly to Welsh in structure and orthography than to any other
known language. 3. There appears nevertheless to have been a
distinction, amounting, at all events, to a difference in dialect. The
Pictish names beginning with w would in Welsh have gw, as Gwrgust
for Wrgust, and so of the rest. There may have been other
differences sufficient to justify Bede’s statement that the Pictish
language was distinct from the British, which it might very well be
without any impeachment of its claim to be reckoned as closely
cognate.”
We have already referred to the use made of the Pictish word
Peannfahel, preserved by Bede, and to the phrase in Adamnan
concerning Columba’s preaching by means of an interpreter. It is
contended by the upholders of the Cymric theory that the ancient
topographical appellations of the Pictish territory can in general only
be explained by the Cymric dialects, one strong point being the
number of local names beginning with the Welsh prefix aber, which,
according to Chalmers, was in several instances subsequently
changed by the Gael into inver. Skene,[68]
who felt the force of this
argument, tried to get rid of it by contending that aber is essentially
a Gaelic word, being compounded of ath, ford, and bior, water.
Garnett thinks this explanation utterly gratuitous, and observes that
the term may be much more satisfactorily accounted for by a
different process. “There are,” he observes,[69]
“three words in Welsh
denoting a meeting of waters—aber, cynver, and ynver,—
respectively compounded of the particles a, denoting juxtaposition,](https://image.slidesharecdn.com/26841941-250513054829-3af4882c/75/Data-Structures-And-Algorithms-In-C-Michael-T-Goodrich-Roberto-Tamassia-69-2048.jpg)
![cyn (Lat. con), and yn, with the root ber, flowing, preserved in the
Breton verb beri, to flow, and all virtually equivalent to our word
confluence. Inver is the only term known in any Gaelic dialect, either
as an appellative or in proper names; and not a single local
appellation with the prefix aber occurs either in Ireland or the
Hebrides, or on the west coast of Scotland. Indeed, the fact that
inver was substituted for it after the Gaelic occupation of the Pictish
territories, is decisive evidence on the point; for, if aber was a term
familiar to the Gael, why should they change it?”
“In Scotland,” says Isaac Taylor,[70]
who upholds the Cymric
hypothesis, “the invers and abers are distributed in a curious and
instructive manner. If we draw a line across the map from a point a
little south of Inverary, to one a little north of Aberdeen, we shall
find that (with very few exceptions) the invers lie to the north west
of the line, and the abers to the south-east of it. This line nearly
coincides with the present southern limit of the Gaelic tongue, and
probably also with the ancient division between the Picts and Scots.
Hence we may conclude that the Picts, a people belonging to the
Cymric branch of the Celtic stock, and whose language has now
ceased to be anywhere vernacular, occupied the central and eastern
districts of Scotland, as far as the Grampians; while the Gadhelic
Scots have retained their language, and have given their name to
the whole country. The local names prove, moreover, that in
Scotland the Cymry did not encroach on the Gael, but the Gael on
the Cymry. The intrusive names are invers, which invaded the land
of the abers. Thus on the shore of the Frith of Forth we find a few
invers among the abers. The Welsh word uchel, high, may also be
adduced to prove the Cymric affinities of the Picts. This word does
not exist in either the Erse or the Gaelic languages, and yet it
appears in the name of the Ochil Hills, in Perthshire. Again, the Erse
bally, a town, occurs in 2,000 names in Ireland; and, on the other
hand, is entirely absent in Wales and Brittany. In Scotland this most
characteristic test-word is found frequently in the inver district, while
it never appears among the abers. The evidence of these names](https://image.slidesharecdn.com/26841941-250513054829-3af4882c/75/Data-Structures-And-Algorithms-In-C-Michael-T-Goodrich-Roberto-Tamassia-70-2048.jpg)
![makes it impossible to deny that the Celts of the Scottish Lowlands
must have belonged to the Cymric branch of the Celtic stock.”
We infer from what Mr. Taylor says, that he is of opinion that at
one time the language of the whole of the north of Scotland was
Cymric, but that the district in which the Scots obtained a settlement
afterwards underwent a change of topography. But it is admitted on
all hands that the Scottish Dalriada comprehended no more than the
modern Argyllshire, extending no farther north than Loch Leven and
Loch Linnhe; and that the Irish Scots had little influence on the
people or their language to the north-west of the Grampians.
Indeed, Skene[71]
maintains that this district, in which he places the
Northern Picts, was never subjected to the Scots, and that it was
only the Southern Picts who latterly came under their sway. Yet we
find that the abers here are few and far between, or, indeed, any
indications of Cymric possession such as we find in the southern
district. Is it possible that the Northern and Southern Picts were
representatives of the two great divisions of the Celts,—the former
claiming a Gaelic origin, and the latter a Cymric? Perhaps after all
the Welsh Triads may in course of time be of some help in the
solution of this dark problem, as, according to them, there was more
than one Celtic settlement in Scotland before the migration of the
Scots. The passages above quoted are, to all appearance, much
more favourable to the Gaelic than to the Cymric hypothesis, and
have been made much of by Skene and other supporters of that side
of the question.
The Cymric origin of the Picts, besides Garnett and Taylor, is
supported by such names as Innes, Chalmers, Ritson, Whittaker,
Grub, and others.
Pinkerton, it is well known, is the great and unscrupulous upholder
of the Gothic origin of the Picts; while the Gaelic theory has for its
supporters such writers, of undoubted ability and acuteness, as
Skene, E. W. Robertson, Forbes-Leslie, &c. Burton[72]
is of opinion
that the Highlanders of the present day are the true representatives
of the Dalriadic Scots of the West.](https://image.slidesharecdn.com/26841941-250513054829-3af4882c/75/Data-Structures-And-Algorithms-In-C-Michael-T-Goodrich-Roberto-Tamassia-71-2048.jpg)
![We shall, as we have done in the case of the other side, allow the
upholders of the Gaelic hypothesis to state for themselves the Gaelic
topographical argument. We shall use the words of Colonel Forbes-
Leslie, who, in his invaluable work on the “Early Races of
Scotland,”[73]
says, “The Celtic words Inver and Aber have nearly the
same meaning; and the relative position in which they occur in
names of places has been employed as if it were a sufficient
argument for defining the presence or preponderance of the British
or Gaelic Celts in certain districts. In this way Aber, prefixed to
names of places, has been urged as adequate proof that the Picts of
Caledonia were Celts of the British branch. The value of these and
some other words requires examination. Inver is to be found in
names of places in Wales. It may possibly be a British word. It
certainly is a Gaelic one. Aber, although undoubtedly British, is also
Gaelic—compounded of the two words Ath and Bior—and signifying
the same as Inver, viz., the confluence of two streams, or the
entrance to a river. If the word Aber had been unknown to the Gaelic
scholars of modern days, its former existence in that language might
have been presumed from the ancient names of places in the
districts of Caledonia, where it occurs most frequently, being
generally Gaelic and not British.
“Beyond the limits of Caledonia on the south of the Forth and
Clyde, but within the boundary of modern Scotland, the word Inver,
generally pronounced Inner, is of common occurrence, and bears
witness to a Gaelic nomenclature. Thus, Inner or Inverkip, in the
county of Renfrew; Innerwell, in the county of Wigton; Innerwick, in
the county of Haddington; Innerleithen, in the county of Peebles;
Inverleith and Inveresk, in the county of Edinburgh, derive their
names from their situation in regard to the rivers Kip, Leithen, Esk,
&c. &c.
“From the Moray Frith to the Forth, in the eastern counties of
Caledonia, the prefix Inver or Aber is used indiscriminately in
contiguous places. At the confluence of lesser streams with the river
Dee, in Aberdeenshire, we find Inverey, Abergeldie, Invercauld,
Invercanny, Aberdeen. Yet in those counties—viz., Aberdeen,](https://image.slidesharecdn.com/26841941-250513054829-3af4882c/75/Data-Structures-And-Algorithms-In-C-Michael-T-Goodrich-Roberto-Tamassia-72-2048.jpg)
![upwards of one hundred with Ard; and the number might easily be
doubled.”
Mr. E. W. Robertson, one of the latest and ablest upholders of this
theory, thinks[74]
there is scarcely sufficient evidence to justify any
very decided conclusion as to the pre-existence of a Cymric
population; and that, whilst it would be unquestionably erroneous to
ascribe a Cymric origin to the Picts, the existence of a Celtic element
akin to the Cymri, amongst the population of Alban before the arrival
of the Gwyddel Ffichti, must remain to a certain extent an open
question.
Of all a priori theories that have hitherto been advanced as to how
Scotland was likely to have been at first peopled, that of Father
Innes, the first writer who investigated the subject thoroughly and
critically, appears to us to be the most plausible and natural,
although even it is beset with many difficulties. It appears to him
more natural and probable that the Caledonian Britons, or Picts,
were of the same origin as the Britons of the south; that as these
came in originally from the nearest coast of Gaul, as they multiplied
in the island, they advanced to the north and settled there, carrying
with them the customs and language of the South Britons.[75]
We have thus endeavoured to lay before the reader, as fully as
space permits, and as clearly and unprejudicedly as possible, the
materials at present existing by means of which to form an opinion
on the Pictish question, and the arguments pro and con, mainly in
their own words, urged by the partisans of the different theories. It
appears to us that the data within reach are far too scanty to justify
any one in coming to a settled conclusion, and that we must wait for
more light before we can be justified in finally making up our minds
on this perplexing subject.[76]
At the present day we find that nearly the whole of the territory
said to have been originally occupied by the Picts, is inhabited, and
has been for centuries, by a population which in appearance is far
more Teutonic than Celtic, and which undoubtedly speaks a broad
Teutonic dialect.[77]
And even in the district where the Gaelic](https://image.slidesharecdn.com/26841941-250513054829-3af4882c/75/Data-Structures-And-Algorithms-In-C-Michael-T-Goodrich-Roberto-Tamassia-74-2048.jpg)
![language has been triumphant for ages, it is acknowledged even by
the most devoted partisans of the Gaelic theory, that among the
population there is a very considerable intermixture of the Teutonic
element. Burton thinks, from a general view of the whole question,
that the proportion of the Teutonic race that came into the use of
the Gaelic, was much greater than the proportion of the Gaelic that
came into the use of the Teutonic or Saxon, and that this may
account for the contrasts of physical appearance to be seen in the
Highlands.
We certainly have not exhausted the statement of the question,
have not stated fully and completely all the points in dispute; nor do
we pretend to have given with fulness all the arguments pro and con
on the various sides. We have, however, given as much as will
enable any ordinary reader to form for himself a fair idea of the
present state of the Pictish question, and indicated the sources
whence more information may be derived, should any one wish to
pursue the subject farther. In the words of the latest and greatest
Scottish historian “this brief survey of the great Pictish controversy
leaves nothing but a melancholy record of wasted labour and
defeated ambition. It has been more fruitless than a polemical or a
political dispute, for these leave behind them, either for good or evil,
their marks upon the conduct and character of the populations
among whom they have raged; while here a vast outlay of learning,
ingenuity, enthusiasm, and, it must be added, temper, have left no
visible monument but a pile of forbidding volumes, in which should
any one who has not studied the matter fundamentally expect to
find instructive information, he will assuredly be led into a tangled
maze of unintelligible pedantry, from which he will come forth with
no impression but a nightmare feeling of hopeless struggle with
difficulties.”[78]](https://image.slidesharecdn.com/26841941-250513054829-3af4882c/75/Data-Structures-And-Algorithms-In-C-Michael-T-Goodrich-Roberto-Tamassia-75-2048.jpg)
![FOOTNOTES:
[24] Garnett’s Philological Essays, p. 196.
[25] Agricola xi.
[26] The wall of Antonine.
[27] Dio L. 76, c. 12, as quoted in Ritson’s Annals, p. 11.
[28] Critical Essay, ch. ii.
[29] Highlanders.
[30] Book iii.
[31] “Scotti per diversa vagantes, multa populabantur.” Am. Mar. xxvii.
8.
[32]
“—— Nec falso nomine Pictos
Edomuit.”
[33]
“Venit et extremis legio prætenta Britannis
Quæ Scoto dat fræna truci, ferroque notatas
Perlegit exangues Scoto moriente figuras.”—
De bello Getico, v. 416.
Thus rendered by Ritson:—
The legion came, o’er distant Britains placed,
Which bridles the fierce Scot, and bloodless figures
With iron marked, views in the dying Pict.
[34] The name given by the Irish Annalists to the Picts is Cruithne,
said by some to mean “variegated.”
[35] The only important exception is Ritson, whose arguments, like
those of his opponent Pinkerton, consist mostly of virulent language
and vehement assertion.
[36] In Amm. Mar.
[37] It is a curious fact that these latter are, among the peasantry of
Scotland, the distinctive characteristics of the Picts or Pechts, who,
however, it is not unlikely, may be popularly confounded with the
Brownies, especially as, in Perthshire at any rate, they are said always
to have done their work while others were asleep.](https://image.slidesharecdn.com/26841941-250513054829-3af4882c/75/Data-Structures-And-Algorithms-In-C-Michael-T-Goodrich-Roberto-Tamassia-76-2048.jpg)
![[38] Skene’s Highlanders, vol. i. p. 2.
[39] L. O. Pike, The English and their Origin, ch. i.
[40] Biographia Britannica Literaria, vol. i.
[41] Gildas, 1.
[42] Id., 19.
[43] Gildas, 14.
[44] Highlanders, vol. i. p. 72.
[45] Garnett’s Philological Essays, p. 199.
[46] Adam. ap. Colganum, 1. ii. c. 32.
[47] On the subject in question the recently published Book of Deer
cannot be said to afford us any information. It gives a short account of
the landing of Columba and a companion at Aberdour in the north of
Aberdeenshire, and the founding of a monastery at Deer. But although
the entries are in Gaelic, they do not tell us what language Columba
spoke, nor whether ‘Bede the Pict,’ the mormaer of Buchan,
understood him without an interpreter. The name of the saint—
Drostan—whom Columba left behind him to prosecute the work, is
Pictish, at any rate not Irish, so that nothing can be inferred from this.
Since much of the first part of this book was written, Mr. Skene has
advanced the theory, founded partly on four new Pictish words he has
managed to discover, that the language of the Picts was neither pure
Gaelic nor Cymric, ‘but a sort of low Gaelic dialect partaking largely of
Welsh forms.’ This theory is not new, but was distinctly put forth by Dr.
Maclauchlan some years ago in his able and learned work, The Early
Scottish Church, p. 29: if true, it would certainly satisfy a great many
of the demands which any hypothesis on the subject must do.
[48] Bede’s Eccles. Hist., Book 1. c. i.
[49] Nennius 12, Vatican MS.
[50] Critical Essay on Scotland, vol. i. p. 68.
[51] Book i., c. 12.
[52] Inquiry into the Hist. of Scot., vol. i. p. 357, ed. 1814.
[53] Crit. Essay, vol. i. p. 75.
[54] Garnett’s Phil. Essays, p. 198.
[55] Robertson’s Scotland under her Early Kings, vol. ii. p. 380. Forbes-
Leslie’s Early Races of Scotland, vol. i. p 35.](https://image.slidesharecdn.com/26841941-250513054829-3af4882c/75/Data-Structures-And-Algorithms-In-C-Michael-T-Goodrich-Roberto-Tamassia-77-2048.jpg)
![[56] Hist. of Scot., vol. i. p. 187.
[57] Book iii. ch. 4.
[58] Eccl. Hist. of Scot., vol. i. p. 15, &c.
[59] Eccl. Hist. of Scot., vol. i. p. 17.
[60] Davies’ Celtic Researches, p. 155.
[61] Highlanders of Scotland, vol. i. p. 69.
[62] We are indebted for most of the following account to Connellan’s
Annals of the Four Masters, p. 367 (note).
[63] See Taylor’s Words and Places, ch. ix.
[64] Pike’s English and their Origin, ch. ii., which contains some
shrewd and valuable remarks on the subject of language.
[65] Burton, vol. i. p. 192.
[66]
Chalmers for Celtic, Pinkerton for Gothic,
Jamieson, “Teutonic
Etymons.”
Drust
Probably the British
name Trwst, which
signifies din.
Drust, a common Pikish
name, is also Persian, and
signifies sincerus.... The
Persians were the old
Sythæ or Goths, from
whom the rest sprung.
Su. Goth. troest, dristig.
Germ., dreist. Alem.
gidrost, daring.
Brudi or
Bridei
Brudw, which is
pronounced Bridw
or Bradw, is in the
British treacherous.
Brudi is the real Gothic
name; Bout is the
wounded (Bott ictus
Wachter).
Island., Briddi eminebat.
vercl: breida, to
extend; and Sueo-
Goth, e, law; 2. one
who extends the law,
who publishes it.
For other instances see Burton’s Scotland, i. p. 196.
[67] Garnett’s Phil. Essays, pp. 197, 198.
[68] Highlanders.
[69] Phil. Essays, p. 200.
[70] Words and Places, p. 246.
[71] Highlanders.
[72] Scotland, vol i. p. 207.
[73] Vol. i. p. 26.
[74] Vol. ii. p. 377.
[75] Essay on Scotland, vol. i. p. 70.](https://image.slidesharecdn.com/26841941-250513054829-3af4882c/75/Data-Structures-And-Algorithms-In-C-Michael-T-Goodrich-Roberto-Tamassia-78-2048.jpg)
![[76] We have already (p. 22) referred to the Gaelo-Cymric theory
broached by Dr. Maclauchlan in his Early Scottish Church, and recently
adopted by Dr. Skene. Speaking of the distribution of the topographical
nomenclature in the Highlands, Dr. Maclauchlan says it indicates one of
two things; “either that the one race overpowered the other in the
east, and superinduced a new nomenclature over the old throughout
the country,—that we have in fact two successive strata of Celtic
names, the Gaelic underlying the British, which is by no means
impossible; or, what is more likely, that the Pictish people were a
people lying midway between the Gael and the Cymri—more Gaelic
than the Cymri, and more Cymric than the Gael. This is precisely the
character of the old Pictish topography; it is a mixture of Gaelic and
Cymric; and if the language of the people was like their topography, it
too was a language neither Gaelic nor Cymric, but occupying a middle
space between them, indicating the identity of the races at some
distant period, although they afterwards became rivals for the
possession of the land.” This we think on the whole the most
satisfactory theory yet propounded.
[77] We would infer from the recently published Book of Deer, that
down at least to the time of David II., the inhabitants were still a
Gaelic speaking population; all the entries in that book as to land are
in that language.
[78] Burton, vol. i. p. 200.](https://image.slidesharecdn.com/26841941-250513054829-3af4882c/75/Data-Structures-And-Algorithms-In-C-Michael-T-Goodrich-Roberto-Tamassia-79-2048.jpg)
![Strathclyde, until ultimately they were incorporated with the Scots.
[79]
Although both the external and internal history of the Highlands
during this period is much better known than in the case of the
Roman period, still the materials are exceedingly scanty. Scottish
historians, from Fordun and Boece downwards, made it their
business to fill up from their own imaginations what is wanting, so
that, until the simple-minded but acute Innes put it in its true light,
the early history of Scotland was a mass of fable.
Undoubtedly the two most momentous events of this period are
the firm settlement in Argyle of a colony of Scots from Ireland and
some of the neighbouring isles in 503,[80]
and the conversion of the
Northern Picts to Christianity by Columba about 563.
At the time of the Roman abandonment of Britain the Picts were
under the sway of a king or chieftain named Drust, son of Erp,
concerning whom the only record remaining is, that he lived a
hundred years and fought a hundred battles. In fact, little is known
with certainty of the Pictish history for upwards of one hundred
years after the departure of the Romans, although some ancient
chronicles afford us lists of Pictish kings or princes, a chronological
table of whom, from Drust downwards, will be found at the end of
this chapter. The Pictish chronicle contains the names of thirty-six
others who are said to have reigned before Drust, but these are
generally regarded as almost entirely spurious.
Before proceeding farther with the Pictish history, it may be proper
to give a brief account of the settlement of the Irish Scots or
Dalriads, as they are frequently called, in the Pictish territory.
The time of the settlement of the Scots in present Scotland was
for long a subject of disputation, the early Scottish historians, from a
false and unscrupulous patriotism, having pushed it back for many
centuries before its actual occurrence. This dispute is now, however,
fairly set at rest, there being no foundation for believing that the
Scots found their way from Ireland to Scotland earlier than a century](https://image.slidesharecdn.com/26841941-250513054829-3af4882c/75/Data-Structures-And-Algorithms-In-C-Michael-T-Goodrich-Roberto-Tamassia-82-2048.jpg)
Data Structures And Algorithms In C Michael T Goodrich Roberto Tamassia
- 1. Data Structures AndAlgorithms In C Michael T Goodrich Roberto Tamassia download https://ebookbell.com/product/data-structures-and-algorithms-in- c-michael-t-goodrich-roberto-tamassia-53683882 Explore and download more ebooks at ebookbell.com
- 2. Here are somerecommended products that we believe you will be interested in. You can click the link to download. Data Structures And Algorithms In C 4th Edition Adam Drozdek https://ebookbell.com/product/data-structures-and-algorithms-in-c-4th- edition-adam-drozdek-48951104 Data Structures And Algorithms In C Pocket Primer Lee Wittenberg https://ebookbell.com/product/data-structures-and-algorithms-in-c- pocket-primer-lee-wittenberg-38416118 Data Structures And Algorithms In C 1st Edition Michael Mcmillan https://ebookbell.com/product/data-structures-and-algorithms-in-c-1st- edition-michael-mcmillan-979682 Data Structures And Algorithms In C Bm Harwani https://ebookbell.com/product/data-structures-and-algorithms-in-c-bm- harwani-231682544
- 3. Data Structures AndAlgorithms In C Pocket Primer Pocket Primer Series Lee Wittenberg https://ebookbell.com/product/data-structures-and-algorithms-in-c- pocket-primer-pocket-primer-series-lee-wittenberg-153703588 C Data Structures And Algorithms Learn How To Write Efficient Code To Build Scalable And Robust Applications In C Wisnu Anggoro https://ebookbell.com/product/c-data-structures-and-algorithms-learn- how-to-write-efficient-code-to-build-scalable-and-robust-applications- in-c-wisnu-anggoro-43450358 Data Structures Algorithms And Applications In C 2nd Sartaj Sahni https://ebookbell.com/product/data-structures-algorithms-and- applications-in-c-2nd-sartaj-sahni-5912596 Data Structure And Algorithms In C Second Edition Adam Drozdek https://ebookbell.com/product/data-structure-and-algorithms-in-c- second-edition-adam-drozdek-4908124 Data Structures And Algorithm Analysis In C 3rd Edition Clifford A Shaffer https://ebookbell.com/product/data-structures-and-algorithm-analysis- in-c-3rd-edition-clifford-a-shaffer-49161310
- 5.
- 6. This page intentionallyleft blank www.allitebooks.com
- 7. i i “main” — 2011/1/13— 9:10 — page i — #1 i i i i i i Data Structures and Algorithms in C++ Second Edition www.allitebooks.com
- 8. This page intentionallyleft blank www.allitebooks.com
- 9. i i “main” — 2011/1/13— 9:10 — page iii — #3 i i i i i i Data Structures and Algorithms in C++ Second Edition Michael T. Goodrich Department of Computer Science University of California, Irvine Roberto Tamassia Department of Computer Science Brown University David M. Mount Department of Computer Science University of Maryland John Wiley & Sons, Inc. www.allitebooks.com
- 10. i i “main” — 2011/1/13— 9:10 — page iv — #4 i i i i i i ACQUISITIONS EDITOR Beth Lang Golub MARKETING MANAGER Chris Ruel EDITORIAL ASSISTANT Elizabeth Mills MEDIA EDITOR Thomas Kulesa SENIOR DESIGNER Jim O’Shea CONTENT MANAGER Micheline Frederick PRODUCTION EDITOR Amy Weintraub PHOTO EDITOR Sheena Goldstein This book was set in L A TEX by the authors and printed and bound by Malloy Lithographers. The cover was printed by Malloy Lithographers. The cover image is from Wuta Wuta Tjan- gala, “Emu dreaming” c estate of the artist 2009 licensed by Aboriginal Artists Agency. Jennifer Steele/Art Resource, NY. This book is printed on acid free paper. ∞ Trademark Acknowledgments: Java is a trademark of Sun Microsystems, Inc. UNIX R is a registered trademark in the United States and other countries, licensed through X/Open Company, Ltd. PowerPoint R is a trademark of Microsoft Corporation. All other product names mentioned herein are the trademarks of their respective owners. Copyright c 2011, John Wiley & Sons, Inc. All rights reserved. No part of this publication may be reproduced, stored in a retrieval system or transmitted in any form or by any means, electronic, mechanical, photocopying, recording, scanning or otherwise, except as permitted under Sections 107 or 108 of the 1976 United States Copyright Act, without either the prior written permission of the Publisher, or authorization through payment of the appropriate per-copy fee to the Copyright Clearance Center, Inc. 222 Rosewood Drive, Danvers, MA 01923, (978)750-8400, fax (978)646-8600. Requests to the Publisher for permission should be addressed to the Permissions Depart- ment, John Wiley & Sons, Inc., 111 River Street, Hoboken, NJ 07030, (201)748-6011, fax (201)748-6008, E-Mail: PERMREQ@WILEY.COM. To order books or for customer service please call 1-800-CALL WILEY (225-5945). Founded in 1807, John Wiley & Sons, Inc. has been a valued source of knowledge and understanding for more than 200 years, helping people around the world meet their needs and fulfill their aspirations. Our company is built on a foundation of principles that include responsibility to the communities we serve and where we live and work. In 2008, we launched a Corporate Citizenship Initiative, a global effort to address the environmental, social, economic, and ethical challenges we face in our business. Among the issues we are addressing are carbon impact, paper specifications and procurement, ethical conduct within our business and among our vendors, and community and charitable support. For more information, please visit our website: www.wiley.com/go/citizenship. Library of Congress Cataloging in Publication Data ISBN-13 978-0-470-38327-8 Printed in the United States of America 10 9 8 7 6 5 4 3 2 1 www.allitebooks.com
- 11. i i “main” — 2011/1/13— 9:10 — page v — #5 i i i i i i To Karen, Paul, Anna, and Jack – Michael T. Goodrich To Isabel – Roberto Tamassia To Jeanine – David M. Mount www.allitebooks.com
- 12. This page intentionallyleft blank www.allitebooks.com
- 13. i i “main” — 2011/1/13— 9:10 — page vii — #7 i i i i i i Preface This second edition of Data Structures and Algorithms in C++ is designed to pro- vide an introduction to data structures and algorithms, including their design, analy- sis, and implementation. In terms of curricula based on the IEEE/ACM 2001 Com- puting Curriculum, this book is appropriate for use in the courses CS102 (I/O/B versions), CS103 (I/O/B versions), CS111 (A version), and CS112 (A/I/O/F/H ver- sions). We discuss its use for such courses in more detail later in this preface. The major changes in the second edition are the following: • We added more examples of data structure and algorithm analysis. • We enhanced consistency with the C++ Standard Template Library (STL). • We incorporated STL data structures into many of our data structures. • We added a chapter on arrays, linked lists, and iterators (Chapter 3). • We added a chapter on memory management and B-trees (Chapter 14). • We enhanced the discussion of algorithmic design techniques, like dynamic programming and the greedy method. • We simplified and reorganized the presentation of code fragments. • We have introduced STL-style iterators into our container classes, and have presented C++ implementations for these iterators, even for complex struc- tures such as hash tables and binary search trees. • We have modified our priority-queue interface to use STL-style comparator objects. • We expanded and revised exercises, continuing our approach of dividing them into reinforcement, creativity, and project exercises. This book is related to the following books: • M.T. Goodrich and R. Tamassia, Data Structures and Algorithms in Java, John Wiley & Sons, Inc. This book has a similar overall structure to the present book, but uses Java as the underlying language (with some modest, but necessary pedagogical differences required by this approach). • M.T. Goodrich and R. Tamassia, Algorithm Design: Foundations, Analysis, and Internet Examples, John Wiley & Sons, Inc. This is a textbook for a more advanced algorithms and data structures course, such as CS210 (T/W/C/S versions) in the IEEE/ACM 2001 curriculum. While this book retains the same pedagogical approach and general structure as Data Structures and Algorithms in Java, the code fragments have been com- pletely redesigned. We have been careful to make full use of C++’s capabilities and design code in a manner that is consistent with modern C++ usage. In particular, whenever appropriate, we make extensive use of C++ elements that are not part of Java, including the C++ Standard Template Library (STL), C++ memory allocation vii www.allitebooks.com
- 14. i i “main” — 2011/1/13— 9:10 — page viii — #8 i i i i i i viii Preface and deallocation (and the associated issues of destructors), virtual functions, stream input and output, operator overloading, and C++’s safe run-time casting. Use as a Textbook The design and analysis of efficient data structures has long been recognized as a vital subject in computing, because the study of data structures is part of the core of every collegiate computer science and computer engineering major program we are familiar with. Typically, the introductory courses are presented as a two- or three-course sequence. Elementary data structures are often briefly introduced in the first programming course or in an introduction to computer science course and this is followed by a more in-depth introduction to data structures in the courses that follow after this. Furthermore, this course sequence is typically followed at a later point in the curriculum by a more in-depth study of data structures and algorithms. We feel that the central role of data structure design and analysis in the curriculum is fully justified, given the importance of efficient data structures in most software systems, including the Web, operating systems, databases, compilers, and scientific simulation systems. With the emergence of the object-oriented paradigm as the framework of choice for building robust and reusable software, we have tried to take a consistent object- oriented viewpoint throughout this text. One of the main ideas behind the object- oriented approach is that data should be presented as being encapsulated with the methods that access and modify them. That is, rather than simply viewing data as a collection of bytes and addresses, we think of data objects as instances of an abstract data type (ADT), which includes a repertoire of methods for performing operations on data objects of this type. Likewise, object-oriented solutions are often organized utilizing common design patterns, which facilitate software reuse and robustness. Thus, we present each data structure using ADTs and their respective implementations and we introduce important design patterns as a way to organize those implementations into classes, methods, and objects. For most of the ADTs presented in this book, we provide a description of the public interface in C++. Also, concrete data structures realizing the ADTs are discussed and we often give concrete C++ classes implementing these interfaces. We also give C++ implementations of fundamental algorithms, such as sorting and graph searching. Moreover, in addition to providing techniques for using data struc- tures to implement ADTs, we also give sample applications of data structures, such as HTML tag matching and a simple system to maintain a play list for a digital audio system. Due to space limitations, however, we only show code fragments of some of the implementations in this book and make additional source code avail- able on the companion web site. www.allitebooks.com
- 15. i i “main” — 2011/1/13— 9:10 — page ix — #9 i i i i i i Preface ix Online Resources This book is accompanied by an extensive set of online resources, which can be found at the following web site: www.wiley.com/college/goodrich Included on this Web site is a collection of educational aids that augment the topics of this book, for both students and instructors. Students are encouraged to use this site along with the book, to help with exercises and increase understand- ing of the subject. Instructors are likewise welcome to use the site to help plan, organize, and present their course materials. Because of their added value, some of these online resources are password protected. For the Student For all readers, and especially for students, we include the following resources: • All the C++ source code presented in this book. • PDF handouts of Powerpoint slides (four-per-page) provided to instructors. • A database of hints to all exercises, indexed by problem number. • An online study guide, which includes solutions to selected exercises. The hints should be of considerable use to anyone needing a little help getting started on certain exercises, and the solutions should help anyone wishing to see completed exercises. Students who have purchased a new copy of this book will get password access to the hints and other password-protected online resources at no extra charge. Other readers can purchase password access for a nominal fee. For the Instructor For instructors using this book, we include the following additional teaching aids: • Solutions to over 200 of the book’s exercises. • A database of additional exercises, suitable for quizes and exams. • Additional C++ source code. • Slides in Powerpoint and PDF (one-per-page) format. • Self-contained, special-topic supplements, including discussions on convex hulls, range trees, and orthogonal segment intersection. The slides are fully editable, so as to allow an instructor using this book full free- dom in customizing his or her presentations. All the online resources are provided at no extra charge to any instructor adopting this book for his or her course.
- 16. i i “main” — 2011/1/13— 9:10 — page x — #10 i i i i i i x Preface A Resource for Teaching Data Structures and Algorithms This book contains many C++-code and pseudo-code fragments, and hundreds of exercises, which are divided into roughly 40% reinforcement exercises, 40% cre- ativity exercises, and 20% programming projects. This book can be used for the CS2 course, as described in the 1978 ACM Com- puter Science Curriculum, or in courses CS102 (I/O/B versions), CS103 (I/O/B ver- sions), CS111 (A version), and/or CS112 (A/I/O/F/H versions), as described in the IEEE/ACM 2001 Computing Curriculum, with instructional units as outlined in Table 0.1. Instructional Unit Relevant Material PL1. Overview of Programming Languages Chapters 1 and 2 PL2. Virtual Machines Sections 14.1.1 and 14.1.2 PL3. Introduction to Language Translation Section 1.7 PL4. Declarations and Types Sections 1.1.2, 1.1.3, and 2.2.5 PL5. Abstraction Mechanisms Sections 2.2.5, 5.1–5.3, 6.1.1, 6.2.1, 6.3, 7.1, 7.3.1, 8.1, 9.1, 9.5, 11.4, and 13.1.1 PL6. Object-Oriented Programming Chapters 1 and 2 and Sections 6.2.1, 7.3.7, 8.1.2, and 13.3.1 PF1. Fundamental Programming Constructs Chapters 1 and 2 PF2. Algorithms and Problem-Solving Sections 1.7 and 4.2 PF3. Fundamental Data Structures Sections 3.1, 3.2, 5.1–5.3, 6.1–6.3, 7.1, 7.3, 8.1, 8.3, 9.1–9.4, 10.1, and 13.1.1 PF4. Recursion Section 3.5 SE1. Software Design Chapter 2 and Sections 6.2.1, 7.3.7, 8.1.2, and 13.3.1 SE2. Using APIs Sections 2.2.5, 5.1–5.3, 6.1.1, 6.2.1, 6.3, 7.1, 7.3.1, 8.1, 9.1, 9.5, 11.4, and 13.1.1 AL1. Basic Algorithmic Analysis Chapter 4 AL2. Algorithmic Strategies Sections 11.1.1, 11.5.1, 12.2, 12.3.1, and 12.4.2 AL3. Fundamental Computing Algorithms Sections 8.1.5, 8.2.2, 8.3.5, 9.2, and 9.3.1, and Chapters 11, 12, and 13 DS1. Functions, Relations, and Sets Sections 4.1, 8.1, and 11.4 DS3. Proof Techniques Sections 4.3, 6.1.3, 7.3.3, 8.3, 10.2–10.5, 11.2.1, 11.3.1, 11.4.3, 13.1.1, 13.3.1, 13.4, and 13.5 DS4. Basics of Counting Sections 2.2.3 and 11.1.5 DS5. Graphs and Trees Chapters 7, 8, 10, and 13 DS6. Discrete Probability Appendix A and Sections 9.2, 9.4.2, 11.2.1, and 11.5 Table 0.1: Material for units in the IEEE/ACM 2001 Computing Curriculum.
- 17. i i “main” — 2011/1/13— 9:10 — page xi — #11 i i i i i i Preface xi Contents and Organization The chapters for this course are organized to provide a pedagogical path that starts with the basics of C++ programming and object-oriented design. We provide an early discussion of concrete structures, like arrays and linked lists, in order to pro- vide a concrete footing to build upon when constructing other data structures. We then add foundational techniques like recursion and algorithm analysis, and, in the main portion of the book, we present fundamental data structures and algorithms, concluding with a discussion of memory management (that is, the architectural underpinnings of data structures). Specifically, the chapters for this book are orga- nized as follows: 1. A C++ Primer 2. Object-Oriented Design 3. Arrays, Linked Lists, and Recursion 4. Analysis Tools 5. Stacks, Queues, and Deques 6. List and Iterator ADTs 7. Trees 8. Heaps and Priority Queues 9. Hash Tables, Maps, and Skip Lists 10. Search Trees 11. Sorting, Sets, and Selection 12. Strings and Dynamic Programming 13. Graph Algorithms 14. Memory Management and B-Trees A. Useful Mathematical Facts A more detailed listing of the contents of this book can be found in the table of contents.
- 18. i i “main” — 2011/1/13— 9:10 — page xii — #12 i i i i i i xii Preface Prerequisites We have written this book assuming that the reader comes to it with certain knowl- edge. We assume that the reader is at least vaguely familiar with a high-level pro- gramming language, such as C, C++, Python, or Java, and that he or she understands the main constructs from such a high-level language, including: • Variables and expressions. • Functions (also known as methods or procedures). • Decision structures (such as if-statements and switch-statements). • Iteration structures (for-loops and while-loops). For readers who are familiar with these concepts, but not with how they are ex- pressed in C++, we provide a primer on the C++ language in Chapter 1. Still, this book is primarily a data structures book, not a C++ book; hence, it does not provide a comprehensive treatment of C++. Nevertheless, we do not assume that the reader is necessarily familiar with object-oriented design or with linked structures, such as linked lists, since these topics are covered in the core chapters of this book. In terms of mathematical background, we assume the reader is somewhat famil- iar with topics from high-school mathematics. Even so, in Chapter 4, we discuss the seven most-important functions for algorithm analysis. In fact, sections that use something other than one of these seven functions are considered optional, and are indicated with a star (⋆). We give a summary of other useful mathematical facts, including elementary probability, in Appendix A. About the Authors Professors Goodrich, Tamassia, and Mount are well-recognized researchers in al- gorithms and data structures, having published many papers in this field, with ap- plications to Internet computing, information visualization, computer security, and geometric computing. They have served as principal investigators in several joint projects sponsored by the National Science Foundation, the Army Research Of- fice, the Office of Naval Research, and the Defense Advanced Research Projects Agency. They are also active in educational technology research. Michael Goodrich received his Ph.D. in Computer Science from Purdue Uni- versity in 1987. He is currently a Chancellor’s Professor in the Department of Com- puter Science at University of California, Irvine. Previously, he was a professor at Johns Hopkins University. He is an editor for a number of journals in computer science theory, computational geometry, and graph algorithms. He is an ACM Dis- tinguished Scientist, a Fellow of the American Association for the Advancement of Science (AAAS), a Fulbright Scholar, and a Fellow of the IEEE. He is a recipient of the IEEE Computer Society Technical Achievement Award, the ACM Recognition of Service Award, and the Pond Award for Excellence in Undergraduate Teaching.
- 19. i i “main” — 2011/1/13— 9:10 — page xiii — #13 i i i i i i Preface xiii Roberto Tamassia received his Ph.D. in Electrical and Computer Engineering from the University of Illinois at Urbana-Champaign in 1988. He is the Plastech Professor of Computer Science and the Chair of the Department of Computer Sci- ence at Brown University. He is also the Director of Brown’s Center for Geometric Computing. His research interests include information security, cryptography, anal- ysis, design, and implementation of algorithms, graph drawing, and computational geometry. He is an IEEE Fellow and a recipient of the Technical Achievement Award from the IEEE Computer Society for pioneering the field of graph drawing. He is an editor of several journals in geometric and graph algorithms. He previously served on the editorial board of IEEE Transactions on Computers. David Mount received his Ph.D. in Computer Science from Purdue University in 1983. He is currently a professor in the Department of Computer Science at the University of Maryland with a joint appointment in the University of Mary- land’s Institute for Advanced Computer Studies. He is an associate editor for ACM Transactions on Mathematical Software and the International Journal of Compu- tational Geometry and Applications. He is the recipient of two ACM Recognition of Service Awards. In addition to their research accomplishments, the authors also have extensive experience in the classroom. For example, Dr. Goodrich has taught data structures and algorithms courses, including Data Structures as a freshman-sophomore level course and Introduction to Algorithms as an upper-level course. He has earned sev- eral teaching awards in this capacity. His teaching style is to involve the students in lively interactive classroom sessions that bring out the intuition and insights behind data structuring and algorithmic techniques. Dr. Tamassia has taught Data Struc- tures and Algorithms as an introductory freshman-level course since 1988. One thing that has set his teaching style apart is his effective use of interactive hyper- media presentations integrated with the Web. Dr. Mount has taught both the Data Structures and the Algorithms courses at the University of Maryland since 1985. He has won a number of teaching awards from Purdue University, the University of Maryland, and the Hong Kong University of Science and Technology. His lecture notes and homework exercises for the courses that he has taught are widely used as supplementary learning material by students and instructors at other universities. Acknowledgments There are a number of individuals who have made contributions to this book. We are grateful to all our research collaborators and teaching assistants, who provided feedback on early drafts of chapters and have helped us in developing exercises, software, and algorithm animation systems. There have been a number of friends and colleagues whose comments have lead to improvements in the text. We are particularly thankful to Michael Goldwasser for his many valuable suggestions.
- 20. i i “main” — 2011/1/13— 9:10 — page xiv — #14 i i i i i i xiv Preface We are also grateful to Karen Goodrich, Art Moorshead, Scott Smith, and Ioannis Tollis for their insightful comments. We are also truly indebted to the outside reviewers and readers for their co- pious comments, emails, and constructive criticism, which were extremely use- ful in writing this edition. We specifically thank the following reviewers for their comments and suggestions: Divy Agarwal, University of California, Santa Bar- bara; Terry Andres, University of Manitoba; Bobby Blumofe, University of Texas, Austin; Michael Clancy, University of California, Berkeley; Larry Davis, Univer- sity of Maryland; Scott Drysdale, Dartmouth College; Arup Guha, University of Central Florida; Chris Ingram, University of Waterloo; Stan Kwasny, Washington University; Calvin Lin, University of Texas at Austin; John Mark Mercer, McGill University; Laurent Michel, University of Connecticut; Leonard Myers, California Polytechnic State University, San Luis Obispo; David Naumann, Stevens Institute of Technology; Robert Pastel, Michigan Technological University; Bina Rama- murthy, SUNY Buffalo; Ken Slonneger, University of Iowa; C.V. Ravishankar, University of Michigan; Val Tannen, University of Pennsylvania; Paul Van Ar- ragon, Messiah College; and Christopher Wilson, University of Oregon. We are grateful to our editor, Beth Golub, for her enthusiastic support of this project. The team at Wiley has been great. Many thanks go to Mike Berlin, Lil- ian Brady, Regina Brooks, Paul Crockett, Richard DeLorenzo, Jen Devine, Simon Durkin, Micheline Frederick, Lisa Gee, Katherine Hepburn, Rachael Leblond, An- dre Legaspi, Madelyn Lesure, Frank Lyman, Hope Miller, Bridget Morrisey, Chris Ruel, Ken Santor, Lauren Sapira, Dan Sayre, Diana Smith, Bruce Spatz, Dawn Stanley, Jeri Warner, and Bill Zobrist. The computing systems and excellent technical support staff in the departments of computer science at Brown University, University of California, Irvine, and Uni- versity of Maryland gave us reliable working environments. This manuscript was prepared primarily with the L ATEX typesetting package. Finally, we would like to warmly thank Isabel Cruz, Karen Goodrich, Jeanine Mount, Giuseppe Di Battista, Franco Preparata, Ioannis Tollis, and our parents for providing advice, encouragement, and support at various stages of the preparation of this book. We also thank them for reminding us that there are things in life beyond writing books. Michael T. Goodrich Roberto Tamassia David M. Mount
- 21. i i “main” — 2011/1/13— 9:10 — page xv — #15 i i i i i i Contents 1 A C++ Primer 1 1.1 Basic C++ Programming Elements . . . . . . . . . . . . . . . 2 1.1.1 A Simple C++ Program . . . . . . . . . . . . . . . . . . 2 1.1.2 Fundamental Types . . . . . . . . . . . . . . . . . . . . 4 1.1.3 Pointers, Arrays, and Structures . . . . . . . . . . . . . 7 1.1.4 Named Constants, Scope, and Namespaces . . . . . . . 13 1.2 Expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 1.2.1 Changing Types through Casting . . . . . . . . . . . . . 20 1.3 Control Flow . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 1.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 1.4.1 Argument Passing . . . . . . . . . . . . . . . . . . . . . 28 1.4.2 Overloading and Inlining . . . . . . . . . . . . . . . . . 30 1.5 Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 1.5.1 Class Structure . . . . . . . . . . . . . . . . . . . . . . 33 1.5.2 Constructors and Destructors . . . . . . . . . . . . . . . 37 1.5.3 Classes and Memory Allocation . . . . . . . . . . . . . . 40 1.5.4 Class Friends and Class Members . . . . . . . . . . . . . 43 1.5.5 The Standard Template Library . . . . . . . . . . . . . . 45 1.6 C++ Program and File Organization . . . . . . . . . . . . . . 47 1.6.1 An Example Program . . . . . . . . . . . . . . . . . . . 48 1.7 Writing a C++ Program . . . . . . . . . . . . . . . . . . . . . 53 1.7.1 Design . . . . . . . . . . . . . . . . . . . . . . . . . . . 54 1.7.2 Pseudo-Code . . . . . . . . . . . . . . . . . . . . . . . 54 1.7.3 Coding . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 1.7.4 Testing and Debugging . . . . . . . . . . . . . . . . . . 57 1.8 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60 2 Object-Oriented Design 65 2.1 Goals, Principles, and Patterns . . . . . . . . . . . . . . . . 66 2.1.1 Object-Oriented Design Goals . . . . . . . . . . . . . . 66 2.1.2 Object-Oriented Design Principles . . . . . . . . . . . . 67 2.1.3 Design Patterns . . . . . . . . . . . . . . . . . . . . . . 70 xv
- 22. i i “main” — 2011/1/13— 9:10 — page xvi — #16 i i i i i i xvi Contents 2.2 Inheritance and Polymorphism . . . . . . . . . . . . . . . . . 71 2.2.1 Inheritance in C++ . . . . . . . . . . . . . . . . . . . . . 71 2.2.2 Polymorphism . . . . . . . . . . . . . . . . . . . . . . . 78 2.2.3 Examples of Inheritance in C++ . . . . . . . . . . . . . . 79 2.2.4 Multiple Inheritance and Class Casting . . . . . . . . . . 84 2.2.5 Interfaces and Abstract Classes . . . . . . . . . . . . . . 87 2.3 Templates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90 2.3.1 Function Templates . . . . . . . . . . . . . . . . . . . . 90 2.3.2 Class Templates . . . . . . . . . . . . . . . . . . . . . . 91 2.4 Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93 2.4.1 Exception Objects . . . . . . . . . . . . . . . . . . . . . 93 2.4.2 Throwing and Catching Exceptions . . . . . . . . . . . . 94 2.4.3 Exception Specification . . . . . . . . . . . . . . . . . . 96 2.5 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98 3 Arrays, Linked Lists, and Recursion 103 3.1 Using Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . 104 3.1.1 Storing Game Entries in an Array . . . . . . . . . . . . . 104 3.1.2 Sorting an Array . . . . . . . . . . . . . . . . . . . . . . 109 3.1.3 Two-Dimensional Arrays and Positional Games . . . . . 111 3.2 Singly Linked Lists . . . . . . . . . . . . . . . . . . . . . . . . 117 3.2.1 Implementing a Singly Linked List . . . . . . . . . . . . 117 3.2.2 Insertion to the Front of a Singly Linked List . . . . . . 119 3.2.3 Removal from the Front of a Singly Linked List . . . . . 119 3.2.4 Implementing a Generic Singly Linked List . . . . . . . . 121 3.3 Doubly Linked Lists . . . . . . . . . . . . . . . . . . . . . . . 123 3.3.1 Insertion into a Doubly Linked List . . . . . . . . . . . . 123 3.3.2 Removal from a Doubly Linked List . . . . . . . . . . . 124 3.3.3 A C++ Implementation . . . . . . . . . . . . . . . . . . 125 3.4 Circularly Linked Lists and List Reversal . . . . . . . . . . . 129 3.4.1 Circularly Linked Lists . . . . . . . . . . . . . . . . . . . 129 3.4.2 Reversing a Linked List . . . . . . . . . . . . . . . . . . 133 3.5 Recursion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134 3.5.1 Linear Recursion . . . . . . . . . . . . . . . . . . . . . . 140 3.5.2 Binary Recursion . . . . . . . . . . . . . . . . . . . . . 144 3.5.3 Multiple Recursion . . . . . . . . . . . . . . . . . . . . 147 3.6 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149 4 Analysis Tools 153 4.1 The Seven Functions Used in This Book . . . . . . . . . . . 154 4.1.1 The Constant Function . . . . . . . . . . . . . . . . . . 154 4.1.2 The Logarithm Function . . . . . . . . . . . . . . . . . 154
- 23. i i “main” — 2011/1/13— 9:10 — page xvii — #17 i i i i i i Contents xvii 4.1.3 The Linear Function . . . . . . . . . . . . . . . . . . . . 156 4.1.4 The N-Log-N Function . . . . . . . . . . . . . . . . . . 156 4.1.5 The Quadratic Function . . . . . . . . . . . . . . . . . . 156 4.1.6 The Cubic Function and Other Polynomials . . . . . . . 158 4.1.7 The Exponential Function . . . . . . . . . . . . . . . . . 159 4.1.8 Comparing Growth Rates . . . . . . . . . . . . . . . . . 161 4.2 Analysis of Algorithms . . . . . . . . . . . . . . . . . . . . . 162 4.2.1 Experimental Studies . . . . . . . . . . . . . . . . . . . 163 4.2.2 Primitive Operations . . . . . . . . . . . . . . . . . . . 164 4.2.3 Asymptotic Notation . . . . . . . . . . . . . . . . . . . 166 4.2.4 Asymptotic Analysis . . . . . . . . . . . . . . . . . . . . 170 4.2.5 Using the Big-Oh Notation . . . . . . . . . . . . . . . . 172 4.2.6 A Recursive Algorithm for Computing Powers . . . . . . 176 4.2.7 Some More Examples of Algorithm Analysis . . . . . . . 177 4.3 Simple Justification Techniques . . . . . . . . . . . . . . . . 181 4.3.1 By Example . . . . . . . . . . . . . . . . . . . . . . . . 181 4.3.2 The “Contra” Attack . . . . . . . . . . . . . . . . . . . 181 4.3.3 Induction and Loop Invariants . . . . . . . . . . . . . . 182 4.4 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185 5 Stacks, Queues, and Deques 193 5.1 Stacks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194 5.1.1 The Stack Abstract Data Type . . . . . . . . . . . . . . 195 5.1.2 The STL Stack . . . . . . . . . . . . . . . . . . . . . . 196 5.1.3 A C++ Stack Interface . . . . . . . . . . . . . . . . . . 196 5.1.4 A Simple Array-Based Stack Implementation . . . . . . 198 5.1.5 Implementing a Stack with a Generic Linked List . . . . 202 5.1.6 Reversing a Vector Using a Stack . . . . . . . . . . . . . 203 5.1.7 Matching Parentheses and HTML Tags . . . . . . . . . 204 5.2 Queues . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208 5.2.1 The Queue Abstract Data Type . . . . . . . . . . . . . 208 5.2.2 The STL Queue . . . . . . . . . . . . . . . . . . . . . . 209 5.2.3 A C++ Queue Interface . . . . . . . . . . . . . . . . . . 210 5.2.4 A Simple Array-Based Implementation . . . . . . . . . . 211 5.2.5 Implementing a Queue with a Circularly Linked List . . . 213 5.3 Double-Ended Queues . . . . . . . . . . . . . . . . . . . . . . 217 5.3.1 The Deque Abstract Data Type . . . . . . . . . . . . . 217 5.3.2 The STL Deque . . . . . . . . . . . . . . . . . . . . . . 218 5.3.3 Implementing a Deque with a Doubly Linked List . . . . 218 5.3.4 Adapters and the Adapter Design Pattern . . . . . . . . 220 5.4 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223
- 24. i i “main” — 2011/1/13— 9:10 — page xviii — #18 i i i i i i xviii Contents 6 List and Iterator ADTs 227 6.1 Vectors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228 6.1.1 The Vector Abstract Data Type . . . . . . . . . . . . . 228 6.1.2 A Simple Array-Based Implementation . . . . . . . . . . 229 6.1.3 An Extendable Array Implementation . . . . . . . . . . . 231 6.1.4 STL Vectors . . . . . . . . . . . . . . . . . . . . . . . . 236 6.2 Lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 238 6.2.1 Node-Based Operations and Iterators . . . . . . . . . . . 238 6.2.2 The List Abstract Data Type . . . . . . . . . . . . . . . 240 6.2.3 Doubly Linked List Implementation . . . . . . . . . . . . 242 6.2.4 STL Lists . . . . . . . . . . . . . . . . . . . . . . . . . 247 6.2.5 STL Containers and Iterators . . . . . . . . . . . . . . . 248 6.3 Sequences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255 6.3.1 The Sequence Abstract Data Type . . . . . . . . . . . . 255 6.3.2 Implementing a Sequence with a Doubly Linked List . . 255 6.3.3 Implementing a Sequence with an Array . . . . . . . . . 257 6.4 Case Study: Bubble-Sort on a Sequence . . . . . . . . . . . 259 6.4.1 The Bubble-Sort Algorithm . . . . . . . . . . . . . . . . 259 6.4.2 A Sequence-Based Analysis of Bubble-Sort . . . . . . . . 260 6.5 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262 7 Trees 267 7.1 General Trees . . . . . . . . . . . . . . . . . . . . . . . . . . . 268 7.1.1 Tree Definitions and Properties . . . . . . . . . . . . . . 269 7.1.2 Tree Functions . . . . . . . . . . . . . . . . . . . . . . . 272 7.1.3 A C++ Tree Interface . . . . . . . . . . . . . . . . . . . 273 7.1.4 A Linked Structure for General Trees . . . . . . . . . . . 274 7.2 Tree Traversal Algorithms . . . . . . . . . . . . . . . . . . . 275 7.2.1 Depth and Height . . . . . . . . . . . . . . . . . . . . . 275 7.2.2 Preorder Traversal . . . . . . . . . . . . . . . . . . . . . 278 7.2.3 Postorder Traversal . . . . . . . . . . . . . . . . . . . . 281 7.3 Binary Trees . . . . . . . . . . . . . . . . . . . . . . . . . . . 284 7.3.1 The Binary Tree ADT . . . . . . . . . . . . . . . . . . . 285 7.3.2 A C++ Binary Tree Interface . . . . . . . . . . . . . . . 286 7.3.3 Properties of Binary Trees . . . . . . . . . . . . . . . . 287 7.3.4 A Linked Structure for Binary Trees . . . . . . . . . . . 289 7.3.5 A Vector-Based Structure for Binary Trees . . . . . . . . 295 7.3.6 Traversals of a Binary Tree . . . . . . . . . . . . . . . . 297 7.3.7 The Template Function Pattern . . . . . . . . . . . . . 303 7.3.8 Representing General Trees with Binary Trees . . . . . . 309 7.4 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 310 www.allitebooks.com
- 25. i i “main” — 2011/1/13— 9:10 — page xix — #19 i i i i i i Contents xix 8 Heaps and Priority Queues 321 8.1 The Priority Queue Abstract Data Type . . . . . . . . . . . 322 8.1.1 Keys, Priorities, and Total Order Relations . . . . . . . . 322 8.1.2 Comparators . . . . . . . . . . . . . . . . . . . . . . . . 324 8.1.3 The Priority Queue ADT . . . . . . . . . . . . . . . . . 327 8.1.4 A C++ Priority Queue Interface . . . . . . . . . . . . . . 328 8.1.5 Sorting with a Priority Queue . . . . . . . . . . . . . . . 329 8.1.6 The STL priority queue Class . . . . . . . . . . . . . . . 330 8.2 Implementing a Priority Queue with a List . . . . . . . . . . 331 8.2.1 A C++ Priority Queue Implementation using a List . . . 333 8.2.2 Selection-Sort and Insertion-Sort . . . . . . . . . . . . . 335 8.3 Heaps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337 8.3.1 The Heap Data Structure . . . . . . . . . . . . . . . . . 337 8.3.2 Complete Binary Trees and Their Representation . . . . 340 8.3.3 Implementing a Priority Queue with a Heap . . . . . . . 344 8.3.4 C++ Implementation . . . . . . . . . . . . . . . . . . . 349 8.3.5 Heap-Sort . . . . . . . . . . . . . . . . . . . . . . . . . 351 8.3.6 Bottom-Up Heap Construction ⋆ . . . . . . . . . . . . . 353 8.4 Adaptable Priority Queues . . . . . . . . . . . . . . . . . . . 357 8.4.1 A List-Based Implementation . . . . . . . . . . . . . . . 358 8.4.2 Location-Aware Entries . . . . . . . . . . . . . . . . . . 360 8.5 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361 9 Hash Tables, Maps, and Skip Lists 367 9.1 Maps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 368 9.1.1 The Map ADT . . . . . . . . . . . . . . . . . . . . . . 369 9.1.2 A C++ Map Interface . . . . . . . . . . . . . . . . . . . 371 9.1.3 The STL map Class . . . . . . . . . . . . . . . . . . . . 372 9.1.4 A Simple List-Based Map Implementation . . . . . . . . 374 9.2 Hash Tables . . . . . . . . . . . . . . . . . . . . . . . . . . . 375 9.2.1 Bucket Arrays . . . . . . . . . . . . . . . . . . . . . . . 375 9.2.2 Hash Functions . . . . . . . . . . . . . . . . . . . . . . 376 9.2.3 Hash Codes . . . . . . . . . . . . . . . . . . . . . . . . 376 9.2.4 Compression Functions . . . . . . . . . . . . . . . . . . 380 9.2.5 Collision-Handling Schemes . . . . . . . . . . . . . . . . 382 9.2.6 Load Factors and Rehashing . . . . . . . . . . . . . . . 386 9.2.7 A C++ Hash Table Implementation . . . . . . . . . . . . 387 9.3 Ordered Maps . . . . . . . . . . . . . . . . . . . . . . . . . . 394 9.3.1 Ordered Search Tables and Binary Search . . . . . . . . 395 9.3.2 Two Applications of Ordered Maps . . . . . . . . . . . . 399 9.4 Skip Lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 402
- 26. i i “main” — 2011/1/13— 9:10 — page xx — #20 i i i i i i xx Contents 9.4.1 Search and Update Operations in a Skip List . . . . . . 404 9.4.2 A Probabilistic Analysis of Skip Lists ⋆ . . . . . . . . . 408 9.5 Dictionaries . . . . . . . . . . . . . . . . . . . . . . . . . . . . 411 9.5.1 The Dictionary ADT . . . . . . . . . . . . . . . . . . . 411 9.5.2 A C++ Dictionary Implementation . . . . . . . . . . . . 413 9.5.3 Implementations with Location-Aware Entries . . . . . . 415 9.6 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417 10 Search Trees 423 10.1 Binary Search Trees . . . . . . . . . . . . . . . . . . . . . . . 424 10.1.1 Searching . . . . . . . . . . . . . . . . . . . . . . . . . 426 10.1.2 Update Operations . . . . . . . . . . . . . . . . . . . . 428 10.1.3 C++ Implementation of a Binary Search Tree . . . . . . 432 10.2 AVL Trees . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 438 10.2.1 Update Operations . . . . . . . . . . . . . . . . . . . . 440 10.2.2 C++ Implementation of an AVL Tree . . . . . . . . . . . 446 10.3 Splay Trees . . . . . . . . . . . . . . . . . . . . . . . . . . . . 450 10.3.1 Splaying . . . . . . . . . . . . . . . . . . . . . . . . . . 450 10.3.2 When to Splay . . . . . . . . . . . . . . . . . . . . . . . 454 10.3.3 Amortized Analysis of Splaying ⋆ . . . . . . . . . . . . 456 10.4 (2,4) Trees . . . . . . . . . . . . . . . . . . . . . . . . . . . . 461 10.4.1 Multi-Way Search Trees . . . . . . . . . . . . . . . . . . 461 10.4.2 Update Operations for (2,4) Trees . . . . . . . . . . . . 467 10.5 Red-Black Trees . . . . . . . . . . . . . . . . . . . . . . . . . 473 10.5.1 Update Operations . . . . . . . . . . . . . . . . . . . . 475 10.5.2 C++ Implementation of a Red-Black Tree . . . . . . . . 488 10.6 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 492 11 Sorting, Sets, and Selection 499 11.1 Merge-Sort . . . . . . . . . . . . . . . . . . . . . . . . . . . . 500 11.1.1 Divide-and-Conquer . . . . . . . . . . . . . . . . . . . . 500 11.1.2 Merging Arrays and Lists . . . . . . . . . . . . . . . . . 505 11.1.3 The Running Time of Merge-Sort . . . . . . . . . . . . 508 11.1.4 C++ Implementations of Merge-Sort . . . . . . . . . . . 509 11.1.5 Merge-Sort and Recurrence Equations ⋆ . . . . . . . . . 511 11.2 Quick-Sort . . . . . . . . . . . . . . . . . . . . . . . . . . . . 513 11.2.1 Randomized Quick-Sort . . . . . . . . . . . . . . . . . . 521 11.2.2 C++ Implementations and Optimizations . . . . . . . . . 523 11.3 Studying Sorting through an Algorithmic Lens . . . . . . . 526 11.3.1 A Lower Bound for Sorting . . . . . . . . . . . . . . . . 526 11.3.2 Linear-Time Sorting: Bucket-Sort and Radix-Sort . . . . 528 11.3.3 Comparing Sorting Algorithms . . . . . . . . . . . . . . 531
- 27. i i “main” — 2011/1/13— 9:10 — page xxi — #21 i i i i i i Contents xxi 11.4 Sets and Union/Find Structures . . . . . . . . . . . . . . . . 533 11.4.1 The Set ADT . . . . . . . . . . . . . . . . . . . . . . . 533 11.4.2 Mergable Sets and the Template Method Pattern . . . . 534 11.4.3 Partitions with Union-Find Operations . . . . . . . . . . 538 11.5 Selection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 542 11.5.1 Prune-and-Search . . . . . . . . . . . . . . . . . . . . . 542 11.5.2 Randomized Quick-Select . . . . . . . . . . . . . . . . . 543 11.5.3 Analyzing Randomized Quick-Select . . . . . . . . . . . 544 11.6 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 545 12 Strings and Dynamic Programming 553 12.1 String Operations . . . . . . . . . . . . . . . . . . . . . . . . 554 12.1.1 The STL String Class . . . . . . . . . . . . . . . . . . . 555 12.2 Dynamic Programming . . . . . . . . . . . . . . . . . . . . . 557 12.2.1 Matrix Chain-Product . . . . . . . . . . . . . . . . . . . 557 12.2.2 DNA and Text Sequence Alignment . . . . . . . . . . . 560 12.3 Pattern Matching Algorithms . . . . . . . . . . . . . . . . . 564 12.3.1 Brute Force . . . . . . . . . . . . . . . . . . . . . . . . 564 12.3.2 The Boyer-Moore Algorithm . . . . . . . . . . . . . . . 566 12.3.3 The Knuth-Morris-Pratt Algorithm . . . . . . . . . . . . 570 12.4 Text Compression and the Greedy Method . . . . . . . . . 575 12.4.1 The Huffman-Coding Algorithm . . . . . . . . . . . . . 576 12.4.2 The Greedy Method . . . . . . . . . . . . . . . . . . . . 577 12.5 Tries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 578 12.5.1 Standard Tries . . . . . . . . . . . . . . . . . . . . . . . 578 12.5.2 Compressed Tries . . . . . . . . . . . . . . . . . . . . . 582 12.5.3 Suffix Tries . . . . . . . . . . . . . . . . . . . . . . . . 584 12.5.4 Search Engines . . . . . . . . . . . . . . . . . . . . . . 586 12.6 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 587 13 Graph Algorithms 593 13.1 Graphs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 594 13.1.1 The Graph ADT . . . . . . . . . . . . . . . . . . . . . . 599 13.2 Data Structures for Graphs . . . . . . . . . . . . . . . . . . . 600 13.2.1 The Edge List Structure . . . . . . . . . . . . . . . . . . 600 13.2.2 The Adjacency List Structure . . . . . . . . . . . . . . . 603 13.2.3 The Adjacency Matrix Structure . . . . . . . . . . . . . 605 13.3 Graph Traversals . . . . . . . . . . . . . . . . . . . . . . . . . 607 13.3.1 Depth-First Search . . . . . . . . . . . . . . . . . . . . 607 13.3.2 Implementing Depth-First Search . . . . . . . . . . . . . 611 13.3.3 A Generic DFS Implementation in C++ . . . . . . . . . . 613 13.3.4 Polymorphic Objects and Decorator Values ⋆ . . . . . . 621
- 28. i i “main” — 2011/1/13— 9:10 — page xxii — #22 i i i i i i xxii Contents 13.3.5 Breadth-First Search . . . . . . . . . . . . . . . . . . . 623 13.4 Directed Graphs . . . . . . . . . . . . . . . . . . . . . . . . . 626 13.4.1 Traversing a Digraph . . . . . . . . . . . . . . . . . . . 628 13.4.2 Transitive Closure . . . . . . . . . . . . . . . . . . . . . 630 13.4.3 Directed Acyclic Graphs . . . . . . . . . . . . . . . . . . 633 13.5 Shortest Paths . . . . . . . . . . . . . . . . . . . . . . . . . . 637 13.5.1 Weighted Graphs . . . . . . . . . . . . . . . . . . . . . 637 13.5.2 Dijkstra’s Algorithm . . . . . . . . . . . . . . . . . . . . 639 13.6 Minimum Spanning Trees . . . . . . . . . . . . . . . . . . . . 645 13.6.1 Kruskal’s Algorithm . . . . . . . . . . . . . . . . . . . . 647 13.6.2 The Prim-Jarnı́k Algorithm . . . . . . . . . . . . . . . . 651 13.7 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 654 14 Memory Management and B-Trees 665 14.1 Memory Management . . . . . . . . . . . . . . . . . . . . . . 666 14.1.1 Memory Allocation in C++ . . . . . . . . . . . . . . . . 669 14.1.2 Garbage Collection . . . . . . . . . . . . . . . . . . . . 671 14.2 External Memory and Caching . . . . . . . . . . . . . . . . . 673 14.2.1 The Memory Hierarchy . . . . . . . . . . . . . . . . . . 673 14.2.2 Caching Strategies . . . . . . . . . . . . . . . . . . . . 674 14.3 External Searching and B-Trees . . . . . . . . . . . . . . . . 679 14.3.1 (a,b) Trees . . . . . . . . . . . . . . . . . . . . . . . . 680 14.3.2 B-Trees . . . . . . . . . . . . . . . . . . . . . . . . . . 682 14.4 External-Memory Sorting . . . . . . . . . . . . . . . . . . . . 683 14.4.1 Multi-Way Merging . . . . . . . . . . . . . . . . . . . . 684 14.5 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 685 A Useful Mathematical Facts 689 Bibliography 697 Index 702
- 29. i i “main” — 2011/1/13— 9:10 — page 1 — #23 i i i i i i Chapter 1 A C++ Primer Contents 1.1 Basic C++ Programming Elements . . . . . . . . . . . 2 1.1.1 A Simple C++ Program . . . . . . . . . . . . . . . . 2 1.1.2 Fundamental Types . . . . . . . . . . . . . . . . . . 4 1.1.3 Pointers, Arrays, and Structures . . . . . . . . . . . 7 1.1.4 Named Constants, Scope, and Namespaces . . . . . 13 1.2 Expressions . . . . . . . . . . . . . . . . . . . . . . . . 16 1.2.1 Changing Types through Casting . . . . . . . . . . . 20 1.3 Control Flow . . . . . . . . . . . . . . . . . . . . . . . 23 1.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . 26 1.4.1 Argument Passing . . . . . . . . . . . . . . . . . . . 28 1.4.2 Overloading and Inlining . . . . . . . . . . . . . . . 30 1.5 Classes . . . . . . . . . . . . . . . . . . . . . . . . . . 32 1.5.1 Class Structure . . . . . . . . . . . . . . . . . . . . 33 1.5.2 Constructors and Destructors . . . . . . . . . . . . . 37 1.5.3 Classes and Memory Allocation . . . . . . . . . . . . 40 1.5.4 Class Friends and Class Members . . . . . . . . . . . 43 1.5.5 The Standard Template Library . . . . . . . . . . . . 45 1.6 C++ Program and File Organization . . . . . . . . . . 47 1.6.1 An Example Program . . . . . . . . . . . . . . . . . 48 1.7 Writing a C++ Program . . . . . . . . . . . . . . . . . 53 1.7.1 Design . . . . . . . . . . . . . . . . . . . . . . . . . 54 1.7.2 Pseudo-Code . . . . . . . . . . . . . . . . . . . . . 54 1.7.3 Coding . . . . . . . . . . . . . . . . . . . . . . . . . 55 1.7.4 Testing and Debugging . . . . . . . . . . . . . . . . 57 1.8 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . 60
- 30. i i “main” — 2011/1/13— 9:10 — page 2 — #24 i i i i i i 2 Chapter 1. A C++ Primer 1.1 Basic C++ Programming Elements Building data structures and algorithms requires communicating instructions to a computer, and an excellent way to perform such communication is using a high- level computer language, such as C++. C++ evolved from the programming lan- guage C, and has, over time, undergone further evolution and development from its original definition. It has incorporated many features that were not part of C, such as symbolic constants, in-line function substitution, reference types, paramet- ric polymorphism through templates, and exceptions (which are discussed later). As a result, C++ has grown to be a complex programming language. Fortunately, we do not need to know every detail of this sophisticated language in order to use it effectively. In this chapter and the next, we present a quick tour of the C++ programming language and its features. It would be impossible to present a complete presentation of the language in this short space, however. Since we assume that the reader is already familiar with programming with some other language, such as C or Java, our descriptions are short. This chapter presents the language’s basic features, and in the following chapter, we concentrate on those features that are important for object-oriented programming. C++ is a powerful and flexible programming language, which was designed to build upon the constructs of the C programming language. Thus, with minor ex- ceptions, C++ is a superset of the C programming language. C++ shares C’s ability to deal efficiently with hardware at the level of bits, bytes, words, addresses, etc. In addition, C++ adds several enhancements over C (which motivates the name “C++”), with the principal enhancement being the object-oriented concept of a class. A class is a user-defined type that encapsulates many important mechanisms such as guaranteed initialization, implicit type conversion, control of memory man- agement, operator overloading, and polymorphism (which are all important topics that are discussed later in this book). A class also has the ability to hide its un- derlying data. This allows a class to conceal its implementation details and allows users to conceptualize the class in terms of a well-defined interface. Classes enable programmers to break an application up into small, manageable pieces, or objects. The resulting programs are easier to understand and easier to maintain. 1.1.1 A Simple C++ Program Like many programming languages, creating and running a C++ program requires several steps. First, we create a C++ source file into which we enter the lines of our program. After we save this file, we then run a program, called a compiler, which
- 31. i i “main” — 2011/1/13— 9:10 — page 3 — #25 i i i i i i 1.1. Basic C++ Programming Elements 3 creates a machine-code interpretation of this program. Another program, called a linker (which is typically invoked automatically by the compiler), includes any required library code functions needed and produces the final machine-executable file. In order to run our program, the user requests that the system execute this file. Let us consider a very simple program to illustrate some of the language’s basic elements. Don’t worry if some elements in this example are not fully explained. We discuss them in greater depth later in this chapter. This program inputs two integers, which are stored in the variables x and y. It then computes their sum and stores the result in a variable sum, and finally it outputs this sum. (The line numbers are not part of the program; they are just for our reference.) 1 #include <cstdlib> 2 #include <iostream> 3 /* This program inputs two numbers x and y and outputs their sum */ 4 int main( ) { 5 int x, y; 6 std::cout << "Please enter two numbers: "; 7 std::cin >> x >> y; // input x and y 8 int sum = x + y; // compute their sum 9 std::cout << "Their sum is " << sum << std::endl; 10 return EXIT SUCCESS; // terminate successfully 11 } A few things about this C++ program should be fairly obvious. First, comments are indicated with two slashes (//). Each such comment extends to the end of the line. Longer block comments are enclosed between /* and */. Block comments may extend over multiple lines. The quantities manipulated by this program are stored in three integer variables, x, y, and sum. The operators “>>” and “<<” are used for input and output, respectively. Program Elements Let us consider the elements of the above program in greater detail. Lines 1 and 2 input the two header files, “cstdlib” and “iostream.” Header files are used to provide special declarations and definitions, which are of use to the program. The first provides some standard system definitions, and the second provides definitions needed for input and output. The initial entry point for C++ programs is the function main. The statement “int main( )” on line 4 declares main to be a function that takes no arguments and returns an integer result. (In general, the main function may be called with the command-line arguments, but we don’t discuss this.) The function body is given within curly braces ({...}), which start on line 4 and end on line 11. The program terminates when the return statement on line 10 is executed.
- 32. i i “main” — 2011/1/13— 9:10 — page 4 — #26 i i i i i i 4 Chapter 1. A C++ Primer By convention, the function main returns the value zero to indicate success and returns a nonzero value to indicate failure. The include file cstdlib defines the constant EXIT SUCCESS to be 0. Thus, the return statement on line 10 returns 0, indicating a successful termination. The statement on line 6 prints a string using the output operator (“<<”). The statement on line 7 inputs the values of the variables x and y using the input operator (“>>”). These variable values could be supplied, for example, by the person running our program. The name std::cout indicates that output is to be sent to the standard output stream. There are two other important I/O streams in C++: standard input is where input is typically read, and standard error is where error output is written. These are denoted std::cin and std::cerr, respectively. The prefix “std::” indicates that these objects are from the system’s standard library. We should include this prefix when referring to objects from the standard library. Nonetheless, it is possible to inform the compiler that we wish to use objects from the standard library—and so omit this prefix—by utilizing the “using” statement as shown below. #include <iostream> using namespace std; // makes std:: available // . . . cout << "Please enter two numbers: "; // (std:: is not needed) cin >> x >> y; We discuss the using statement later in Section 1.1.4. In order to keep our examples short, we often omit the include and using statements when displaying C++ code. We also use “ //. . .” to indicate that some code has been omitted. Returning to our simple example C++ program, we note that the statement on line 9 outputs the value of the variable sum, which in this case stores the computed sum of x and y. By default, the output statement does not produce an end of line. The special object std::endl generates a special end-of-line character. Another way to generate an end of line is to output the newline character, ’n’. If run interactively, that is, with the user inputing values when requested to do so, this program’s output would appear as shown below. The user’s input is indicated below in blue. Please enter two numbers: 7 35 Their sum is 42 1.1.2 Fundamental Types We continue our exploration of C++ by discussing the language’s basic data types and how these types are represented as constants and variables. The fundamental
- 33. i i “main” — 2011/1/13— 9:10 — page 5 — #27 i i i i i i 1.1. Basic C++ Programming Elements 5 types are the basic building blocks from which more complex types are constructed. They include the following. bool Boolean value, either true or false char character short short integer int integer long long integer float single-precision floating-point number double double-precision floating-point number There is also an enumeration, or enum, type to represent a set of discrete val- ues. Together, enumerations and the types bool, char, and int are called integral types. Finally, there is a special type void, which explicitly indicates the absence of any type information. We now discuss each of these types in greater detail. Characters A char variable holds a single character. A char in C++ is typically 8-bits, but the exact number of bits used for a char variable is dependent on the particular imple- mentation. By allowing different implementations to define the meaning of basic types, such as char, C++ can tailor its generated code to each machine architecture and so achieve maximum efficiency. This flexibility can be a source of frustration for programmers who want to write machine-independent programs, however. A literal is a constant value appearing in a program. Character literals are enclosed in single quotes, as in ’a’, ’Q’, and ’+’. A backslash ( ) is used to specify a number of special character literals as shown below. ’n’ newline ’t’ tab ’b’ backspace ’0’ null ’’’ single quote ’"’ double quote ’’ backslash The null character, ’0’, is sometimes used to indicate the end of a string of characters. Every character is associated with an integer code. The function int(ch) returns the integer value associated with a character variable ch. Integers An int variable holds an integer. Integers come in three sizes: short int, (plain) int, and long int. The terms “short” and “long” are synonyms for “short int” and “long int,” respectively. Decimal numbers such as 0, 25, 98765, and -3 are of type int. The suffix “l” or “L” can be added to indicate a long integer, as in 123456789L. Octal (base 8) constants are specified by prefixing the number with the zero digit, and hexadecimal (base 16) constants can be specified by prefixing the number with
- 34. i i “main” — 2011/1/13— 9:10 — page 6 — #28 i i i i i i 6 Chapter 1. A C++ Primer “0x.” For example, the literals 256, 0400, and 0x100 all represent the integer value 256 (in decimal). When declaring a variable, we have the option of providing a definition, or initial value. If no definition is given, the initial value is unpredictable, so it is important that each variable be assigned a value before being used. Variable names may consist of any combination of letters, digits, or the underscore ( ) character, but the first character cannot be a digit. Here are some examples of declarations of integral variables. short n; // n’s value is undefined int octalNumber = 0400; // 400 (base 8) = 256 (base 10) char newline character = ’n’; long BIGnumber = 314159265L; short aSTRANGE 1234 variABlE NaMe; Although it is legal to start a variable name with an underscore, it is best to avoid this practice, since some C++ compilers use this convention for defining their own internal identifiers. C++ does not specify the exact number of bits in each type, but a short is at least 16 bits, and a long is at least 32 bits. In fact, there is no requirement that long be strictly longer than short (but it cannot be shorter!). Given a type T, the expression sizeof(T) returns the size of type T, expressed as some number of multiples of the size of char. For example, on typical systems, a char is 8 bits long, and an int is 32 bits long, and hence sizeof(int) is 4. Enumerations An enumeration is a user-defined type that can hold any of a set of discrete values. Once defined, enumerations behave much like an integer type. A common use of enumerations is to provide meaningful names to a set of related values. Each element of an enumeration is associated with an integer value. By default, these values count up from 0, but it is also possible to define explicit constant values as shown below. enum Day { SUN, MON, TUE, WED, THU, FRI, SAT }; enum Mood { HAPPY = 3, SAD = 1, ANXIOUS = 4, SLEEPY = 2 }; Day today = THU; // today may be any of MON . . . SAT Mood myMood = SLEEPY; // myMood may be HAPPY, . . ., SLEEPY Since we did not specify values, SUN would be associated with 0, MON with 1, and so on. As a hint to the reader, we write enumeration names and other constants with all capital letters. www.allitebooks.com
- 35. i i “main” — 2011/1/13— 9:10 — page 7 — #29 i i i i i i 1.1. Basic C++ Programming Elements 7 Floating Point A variable of type float holds a single-precision floating-point number, and a vari- able of type double holds a double-precision floating-point number. As it does with integers, C++ leaves undefined the exact number of bits in each of the floating point types. By default, floating point literals, such as 3.14159 and -1234.567 are of type double. Scientific or exponential notation may by specified using either “e” or “E” to separate the mantissa from the exponent, as in 3.14E5, which means 3.14× 105. To force a literal to be a float, add the suffix “f” or “F,” as in 2.0f or 1.234e-3F. 1.1.3 Pointers, Arrays, and Structures We next discuss how to combine fundamental types to form more complex ones. Pointers Each program variable is stored in the computer’s memory at some location, or address. A pointer is a variable that holds the value of such an address. Given a type T, the type T* denotes a pointer to a variable of type T. For example, int* denotes a pointer to an integer. Two essential operators are used to manipulate pointers. The first returns the address of an object in memory, and the second returns the contents of a given address. In C++ the first task is performed by the address-of operator, &. For example if x is an integer variable in your program &x is the address of x in memory. Accessing an object’s value from its address is called dereferencing. This is done using the * operator. For example, if we were to declare q to be a pointer to an integer (that is, int*) and then set q = &x, we could access x’s value with *q. Assigning an integer value to *q effectively changes the value of x. Consider, for example, the code fragment below. The variable p is declared to be a pointer to a char, and is initialized to point to the variable ch. Thus, *p is another way of referring to ch. Observe that when the value of ch is changed, the value of *p changes as well. char ch = ’Q’; char* p = &ch; // p holds the address of ch cout << *p; // outputs the character ’Q’ ch = ’Z’; // ch now holds ’Z’ cout << *p; // outputs the character ’Z’ *p = ’X’; // ch now holds ’X’ cout << ch; // outputs the character ’X’ We shall see that pointers are very useful when building data structures where ob- jects are linked to one another through the use of pointers. Pointers need not point
- 36. i i “main” — 2011/1/13— 9:10 — page 8 — #30 i i i i i i 8 Chapter 1. A C++ Primer only to fundamental types, such as char and int—they may also point to complex types and even to functions. Indeed, the popularity of C++ stems in part from its ability to handle low-level entities like pointers. It is useful to have a pointer value that points to nothing, that is, a null pointer. By convention, such a pointer is assigned the value zero. An attempt to dereference a null pointer results in a run-time error. All C++ implementations define a special symbol NULL, which is equal to zero. This definition is activated by inserting the statement “#include <cstdlib>” in the beginning of a program file. We mentioned earlier that the special type void is used to indicate no type information at all. Although we cannot declare a variable to be of type void, we can declare a pointer to be of type void*. Such a pointer can point to a variable of any type. Since the compiler is unable to check the correctness of such references, the use of void* pointers is strongly discouraged, except in unusual cases where direct access to the computer’s memory is needed. Beware when declaring two or more pointers on the same line. The * operator Caution binds with the variable name, not with the type name. Consider the following misleading declaration. int* x, y, z; // same as: int* x; int y; int z; This declares one pointer variable x, but the other two variables are plain integers. The simplest way to avoid this confusion is to declare one variable per statement. Arrays An array is a collection of elements of the same type. Given any type T and a constant N, a variable of type T[N] holds an array of N elements, each of type T. Each element of the array is referenced by its index, that is, a number from 0 to N − 1. The following statements declare two arrays; one holds three doubles and the other holds 10 double pointers. double f[5]; // array of 5 doubles: f[0], . . ., f[4] int m[10]; // array of 10 ints: m[0], . . ., m[9] f[4] = 2.5; m[2] = 4; cout << f[m[2]]; // outputs f[4], which is 2.5 Once declared, it is not possible to increase the number of elements in an array. Also, C++ provides no built-in run-time checking for array subscripting out of bounds. This decision is consistent with C++’s general philosophy of not intro- ducing any feature that would slow the execution of a program. Indexing an array outside of its declared bounds is a common programming error. Such an error of- ten occurs “silently,” and only much later are its effects noticed. In Section 1.5.5,
- 37. i i “main” — 2011/1/13— 9:10 — page 9 — #31 i i i i i i 1.1. Basic C++ Programming Elements 9 we see that the vector type of the C++ Standard Template Library (STL) provides many of the capabilities of a more complete array type, including run-time index checking and the ability to dynamically change the array’s size. A two-dimensional array is implemented as an “array of arrays.” For example “int A[15][30]” declares A to be an array of 30 objects, each of which is an array of 15 integers. An element in such an array is indexed as A[i][j], where i is in the range 0 to 14 and j is in the range 0 to 29. When declaring an array, we can initialize its values by enclosing the elements in curly braces ({...}). When doing so, we do not have to specify the size of the array, since the compiler can figure this out. int a[ ] = {10, 11, 12, 13}; // declares and initializes a[4] bool b[ ] = {false, true}; // declares and initializes b[2] char c[ ] = {’c’, ’a’, ’t’}; // declares and initializes c[3] Just as it is possible to declare an array of integers, it is possible to declare an array of pointers to integers. For example, int* r[17] declares an array r consist- ing of 17 pointers to objects of type int. Once initialized, we can dereference an element of this array using the * operator, for example, *r[16] is the value of the integer pointed to by the last element of this array. Pointers and Arrays There is an interesting connection between arrays and pointers, which C++ inher- ited from the C programming language—the name of an array is equivalent to a pointer to the array’s initial element and vice versa. In the example below, c is an array of characters, and p and q are pointers to the first element of c. They all behave essentially the same, however. char c[ ] = {’c’, ’a’, ’t’}; char* p = c; // p points to c[0] char* q = &c[0]; // q also points to c[0] cout << c[2] << p[2] << q[2]; // outputs “ttt” This equivalence between array names and pointers can be confusing, but it helps Caution to explain many of C++’s apparent mysteries. For example, given two arrays c and d, the comparison (c == d) does not test whether the contents of the two arrays are equal. Rather it compares the addresses of their initial elements, which is probably not what the programmer had in mind. If there is a need to perform operations on entire arrays (such as copying one array to another) it is a good idea to use the vector class, which is part of C++’s Standard Template Library. We discuss these concepts in Section 1.5.5.
- 38. i i “main” — 2011/1/13— 9:10 — page 10 — #32 i i i i i i 10 Chapter 1. A C++ Primer Strings A string literal, such as "Hello World", is represented as a fixed-length array of characters that ends with the null character. Character strings represented in this way are called C-style strings, since they were inherited from C. Unfortunately, this representation alone does not provide many string operations, such as concate- nation and comparison. It also possesses all the peculiarities of C++ arrays, as mentioned earlier. For this reason, C++ provides a string type as part of its Standard Template Library (STL). When we need to distinguish, we call these STL strings. In order to use STL strings it is necessary to include the header file <string>. Since STL strings are part of the standard namespace (see Section 1.1.4), their full name is std::string. By adding the statement “using std::string,” we inform the compiler that we want to access this definition directly, so we can omit the “std::” prefix. STL strings may be concatenated using the + operator, they may be compared with each other using lexicographic (or dictionary) order, and they may be input and output using the >> and << operators, respectively. For example: #include <string> using std::string; // . . . string s = "to be"; string t = "not " + s; // t = “not to be” string u = s + " or " + t; // u = “to be or not to be” if (s > t) // true: “to be” > “not to be” cout << u; // outputs “to be or not to be” There are other STL string operations, as well. For example, we can append one string to another using the += operator. Also, strings may be indexed like arrays and the number of characters in a string s is given by s.size(). Since some library functions require the old C-style strings, there is a conversion function s.c str(), which returns a pointer to a C-style string. Here are some examples: string s = "John"; // s = “John” int i = s.size(); // i = 4 char c = s[3]; // c = ’n’ s += " Smith"; // now s = “John Smith” The C++ STL provides many other string operators including operators for ex- tracting, searching for, and replacing substrings. We discuss some of these in Sec- tion 1.5.5. C-Style Structures A structure is useful for storing an aggregation of elements. Unlike an array, the elements of a structure may be of different types. Each member, or field, of a
- 39. i i “main” — 2011/1/13— 9:10 — page 11 — #33 i i i i i i 1.1. Basic C++ Programming Elements 11 structure is referred to by a given name. For example, consider the following struc- ture for storing information about an airline passenger. The structure includes the passenger’s name, meal preference, and information as to whether this passenger is in the frequent flyer program. We create an enumerated type to handle meal preferences. enum MealType { NO PREF, REGULAR, LOW FAT, VEGETARIAN }; struct Passenger { string name; // passenger name MealType mealPref; // meal preference bool isFreqFlyer; // in the frequent flyer program? string freqFlyerNo; // the passenger’s freq. flyer number }; This defines a new type called Passenger. Let us declare and initialize a variable named “pass” of this type. Passenger pass = { "John Smith", VEGETARIAN, true, "293145" }; The individual members of the structure are accessed using the member selection operator, which has the form struct name.member. For example, we could change some of the above fields as follows. pass.name = "Pocahontas"; // change name pass.mealPref = REGULAR; // change meal preference Structures of the same type may be assigned to one another. For example, if p1 and p2 are of type Passenger, then p2 = p1 copies the elements of p1 to p2. What we have discussed so far might be called a C-style structure. C++ pro- vides a much more powerful and flexible construct called a class, in which both data and functions can be combined. We discuss classes in Section 1.5. Pointers, Dynamic Memory, and the “new” Operator We often find it useful in data structures to create objects dynamically as the need arises. The C++ run-time system reserves a large block of memory called the free store, for this reason. (This memory is also sometimes called heap memory, but this should not be confused with the heap data structure, which is discussed in Chapter 8.) The operator new dynamically allocates the correct amount of storage for an object of a given type from the free store and returns a pointer to this object. That is, the value of this pointer is the address where this object resides in memory. Indeed, C++ allows for pointer variables to any data type, even to other pointers or to individual cells in an array.
- 40. i i “main” — 2011/1/13— 9:10 — page 12 — #34 i i i i i i 12 Chapter 1. A C++ Primer For example, suppose that in our airline system we encounter a new passenger. We would like to dynamically create a new instance using the new operator. Let p be a pointer to a Passenger structure. This implies that *p refers to the actual structure; hence, we could access one of its members, say the mealPref field, using the expression (*p).mealPref. Because complex objects like structures are often allocated dynamically, C++ provides a shorter way to access members using the “->” operator. pointer name->member is equivalent to (*pointer name).member For example, we could allocate a new passenger object and initialize its members as follows. Passenger *p; // . . . p = new Passenger; // p points to the new Passenger p−>name = "Pocahontas"; // set the structure members p−>mealPref = REGULAR; p−>isFreqFlyer = false; p−>freqFlyerNo = "NONE"; It would be natural to wonder whether we can initialize the members using the curly brace ({...}) notation used above. The answer is no, but we will see another more convenient way of initializing members when we discuss classes and constructors in Section 1.5.2. This new passenger object continues to exist in the free store until it is explicitly deleted—a process that is done using the delete operator, which destroys the object and returns its space to the free store. delete p; // destroy the object p points to The delete operator should only be applied to objects that have been allocated through new. Since the object at p’s address was allocated using the new operator, the C++ run-time system knows how much memory to deallocate for this delete statement. Unlike some programming languages such as Java, C++ does not pro- vide automatic garbage collection. This means that C++ programmers have the responsibility of explicitly deleting all dynamically allocated objects. Arrays can also be allocated with new. When this is done, the system allocator returns a pointer to the first element of the array. Thus, a dynamically allocated array with elements of type T would be declared being of type *T. Arrays allocated in this manner cannot be deallocated using the standard delete operator. Instead, the operator delete[ ] is used. Here is an example that allocates a character buffer of 500 elements, and then later deallocates it. char* buffer = new char[500]; // allocate a buffer of 500 chars buffer[3] = ’a’; // elements are still accessed using [ ] delete [ ] buffer; // delete the buffer
- 41. i i “main” — 2011/1/13— 9:10 — page 13 — #35 i i i i i i 1.1. Basic C++ Programming Elements 13 Memory Leaks Failure to delete dynamically allocated objects can cause problems. If we were to change the (address) value of p without first deleting the structure to which it points, there would be no way for us to access this object. It would continue to exist for the lifetime of the program, using up space that could otherwise be used for other allocated objects. Having such inaccessible objects in dynamic memory is called a memory leak. We should strongly avoid memory leaks, especially in programs that do a great deal of memory allocation and deallocation. A program with memory leaks can run out of usable memory even when there is a sufficient amount of memory present. An important rule for a disciplined C++ programmer is the following: Remember If an object is allocated with new, it should eventually be deallocated with delete. References Pointers provide one way to refer indirectly to an object. Another way is through references. A reference is simply an alternative name for an object. Given a type T, the notation T& indicates a reference to an object of type T. Unlike pointers, which can be NULL, a reference in C++ must refer to an actual variable. When a reference is declared, its value must be initialized. Afterwards, any access to the reference is treated exactly as if it is an access to the underlying object. string author = "Samuel Clemens"; string& penName = author; // penName is an alias for author penName = "Mark Twain"; // now author = “Mark Twain” cout << author; // outputs “Mark Twain” References are most often used for passing function arguments and are also often used for returning results from functions. These uses are discussed later. 1.1.4 Named Constants, Scope, and Namespaces We can easily name variables without concern for naming conflicts in small prob- lems. It is much harder for us to avoid conflicts in large software systems, which may consist of hundreds of files written by many different programmers. C++ has a number of mechanisms that aid in providing names and limiting their scope.
- 42. i i “main” — 2011/1/13— 9:10 — page 14 — #36 i i i i i i 14 Chapter 1. A C++ Primer Constants and Typedef Good programmers commonly like to associate names with constant quantities. By adding the keyword const to a declaration, we indicate that the value of the associated object cannot be changed. Constants may be used virtually anywhere that literals can be used, for example, in an array declaration. As a hint to the reader, we will use all capital letters when naming constants. const double PI = 3.14159265; const int CUT OFF[ ] = {90, 80, 70, 60}; const int N DAYS = 7; const int N HOURS = 24*N DAYS; // using a constant expression int counter[N HOURS]; // an array of 168 ints Note that enumerations (see Section 1.1.2) provide another convenient way to de- fine integer-valued constants, especially within structures and classes. In addition to associating names with constants, it is often useful to associate a name with a type. This association can be done with a typedef declaration. Rather than declaring a variable, a typedef defines a new type name. typedef char* BufferPtr; // type BufferPtr is a pointer to char typedef double Coordinate; // type Coordinate is a double BufferPtr p; // p is a pointer to char Coordinate x, y; // x and y are of type double By using typedef we can provide shorter or more meaningful synonyms for various types. The type name Coordinate provides more of a hint to the reader of the meaning of variables x and y than does double. Also, if later we decide to change our coordinate representation to int, we need only change the typedef statement. We will follow the convention of indicating user-defined types by capi- talizing the first character of their names. Local and Global Scopes When a group of C++ statements are enclosed in curly braces ({...}), they define a block. Variables and types that are declared within a block are only accessible from within the block. They are said to be local to the block. Blocks can be nested within other blocks. In C++, a variable may be declared outside of any block. Such a variable is global, in the sense that it is accessible from everywhere in the program. The portions of a program from which a given name is accessible are called its scope. Two variables of the same name may be defined within nested blocks. When this happens, the variable of the inner block becomes active until leaving the block.
- 43. i i “main” — 2011/1/13— 9:10 — page 15 — #37 i i i i i i 1.1. Basic C++ Programming Elements 15 Thus a local variable “hides” any global variables of the same name as shown in the following example. const int Cat = 1; // global Cat int main() { const int Cat = 2; // this Cat is local to main cout << Cat; // outputs 2 (local Cat) return EXIT SUCCESS; } int dog = Cat; // dog = 1 (from the global Cat) Namespaces Global variables present many problems in large software systems because they can be accessed and possibly modified anywhere in the program. They also can lead to programming errors, since an important global variable may be hidden by a local variable of the same name. As a result, it is best to avoid global variables. We may not be able to avoid globals entirely, however. For example, when we perform output, we actually use the system’s global standard output stream object, cout. If we were to define a variable with the same name, then the system’s cout stream would be inaccessible. A namespace is a mechanism that allows a group of related names to be defined in one place. This helps organize global objects into natural groups and minimizes the problems of globals. For example, the following declares a namespace myglob- als containing two variables, cat and dog. namespace myglobals { int cat; string dog = "bow wow"; } Namespaces may generally contain definitions of more complex objects, including types, classes, and functions. We can access an object x in namespace group, us- ing the notation group::x, which is called its fully qualified name. For example, myglobals::cat refers to the copy of variable cat in the myglobals namespace. We have already seen an example of a namespace. Many standard system ob- jects, such as the standard input and output streams cin and cout, are defined in a system namespace called std. Their fully qualified names are std::cin and std::cout, respectively.
- 44. i i “main” — 2011/1/13— 9:10 — page 16 — #38 i i i i i i 16 Chapter 1. A C++ Primer The Using Statement If we are repeatedly using variables from the same namespace, it is possible to avoid entering namespace specifiers by telling the system that we want to “use” a particular specifier. We communicate this desire by utilizing the using statement, which makes some or all of the names from the namespace accessible, without explicitly providing the specifier. This statement has two forms that allow us to list individual names or to make every name in the namespace accessible as shown below. using std::string; // makes just std::string accessible using std::cout; // makes just std::cout accessible using namespace myglobals; // makes all of myglobals accessible 1.2 Expressions An expression combines variables and literals with operators to create new values. In the following discussion, we group operators according to the types of objects they may be applied to. Throughout, we use var to denote a variable or anything to which a value may be assigned. (In official C++ jargon, this is called an lvalue.) We use exp to denote an expression and type to denote a type. Member Selection and Indexing Some operators access a member of a structure, class, or array. We let class name denote the name of a structure or class; pointer denotes a pointer to a structure or class and array denotes an array or a pointer to the first element of an array. class name . member class/structure member selection pointer −> member class/structure member selection array [ exp ] array subscripting Arithmetic Operators The following are the binary arithmetic operators: exp + exp addition exp − exp subtraction exp * exp multiplication exp / exp division exp % exp modulo (remainder) There are also unary minus (–x) and unary plus (+x) operations. Division be- tween two integer operands results in an integer result by truncation, even if the www.allitebooks.com
- 45. i i “main” — 2011/1/13— 9:10 — page 17 — #39 i i i i i i 1.2. Expressions 17 result is being assigned to a floating point variable. The modulo operator n%m yields the remainder that would result from the integer division n/m. Increment and Decrement Operators The post-increment operator returns a variable’s value and then increments it by 1. The post-decrement operator is analogous but decreases the value by 1. The pre-increment operator first increments the variables and then returns the value. var ++ post increment var −− post decrement ++ var pre increment −− var pre decrement The following code fragment illustrates the increment and decrement operators. int a[ ] = {0, 1, 2, 3}; int i = 2; int j = i++; // j = 2 and now i = 3 int k = −−i; // now i = 2 and k = 2 cout << a[k++]; // a[2] (= 2) is output; now k = 3 Relational and Logical Operators C++ provides the usual comparison operators. exp < exp less than exp > exp greater than exp <= exp less than or equal exp >= exp greater than or equal exp == exp equal to exp != exp not equal to These return a Boolean result—either true or false. Comparisons can be made between numbers, characters, and STL strings (but not C-style strings). Pointers can be compared as well, but it is usually only meaningful to test whether pointers are equal or not equal (since their values are memory addresses). The following logical operators are also provided. ! exp logical not exp && exp logical and exp | | exp logical or The operators && and | | evaluate sequentially from left to right. If the left operand of && is false, the entire result is false, and the right operand is not eval- uated. The | | operator is analogous, but evaluation stops if the left operand is true. This “short circuiting” is quite useful in evaluating a chain of conditional ex- pressions where the left condition guards against an error committed by the right
- 46. i i “main” — 2011/1/13— 9:10 — page 18 — #40 i i i i i i 18 Chapter 1. A C++ Primer condition. For example, the following code first tests that a Passenger pointer p is non-null before accessing it. It would result in an error if the execution were not stopped if the first condition is not satisfied. if ((p != NULL) && p−>isFreqFlyer) . . . Bitwise Operators The following operators act on the representations of numbers as binary bit strings. They can be applied to any integer type, and the result is an integer type. ˜ exp bitwise complement exp & exp bitwise and exp ^ exp bitwise exclusive-or exp | exp bitwise or exp1 << exp2 shift exp1 left by exp2 bits exp1 >> exp2 shift exp1 right by exp2 bits The left shift operator always fills with zeros. How the right shift fills depends on a variable’s type. In C++ integer variables are “signed” quantities by default, but they may be declared as being “unsigned,” as in “unsigned int x.” If the left operand of a right shift is unsigned, the shift fills with zeros and otherwise the right shift fills with the number’s sign bit (0 for positive numbers and 1 for negative numbers). Note that the input (>>) and output (<<) operators are not in this group. They are discussed later. Assignment Operators In addition to the familiar assignment operator (=), C++ includes a special form for each of the arithmetic binary operators (+, −, *, /, %) and each of the bit- wise binary operators (&, |, ^, <<, >>), that combines a binary operation with assignment. For example, the statement “n += 2” means “n = n + 2.” Some examples are shown below. int i = 10; int j = 5; string s = "yes"; i −= 4; // i = i - 4 = 6 j *= −2; // j = j * (-2) = -10 s += " or no"; // s = s + “ or no” = “yes or no” These assignment operators not only provide notational convenience, but they can be more efficient to execute as well. For example, in the string concatenation example above, the new text can just be appended to s without the need to generate a temporary string to hold the intermediate result.
- 47. i i “main” — 2011/1/13— 9:10 — page 19 — #41 i i i i i i 1.2. Expressions 19 Take care when performing assignments between aggregate objects (arrays, strings, and structures). Typically the programmer intends such an assignment to copy the contents of one object to the other. This works for STL strings and C- style structures (provided they have the same type). However, as discussed earlier, C-style strings and arrays cannot be copied merely through a single assignment statement. Other Operators Here are some other useful operators. class name :: member class scope resolution namespace name :: member namespace resolution bool exp ? true exp : false exp conditional expression We have seen the namespace resolution operator in Section 1.1.4. The condi- tional expression is a variant of “if-then-else” for expressions. If bool exp evaluates to true, the value of true exp is returned, and otherwise the value of false exp is re- turned. The following example shows how to use this to return the minimum of two numbers, x and y. smaller = (x < y ? x : y); // smaller = min(x,y) We also have the following operations on input/output streams. stream >> var stream input stream << exp stream output Although they look like the bitwise shift operators, the input (>>) and output (<<) stream operators are quite different. They are examples of C++’s powerful ca- pability, called operator overloading, which are discussed in Section 1.4.2. These operators are not an intrinsic part of C++, but are provided by including the file <iostream>. We refer the reader to the references given in the chapter notes for more information on input and output in C++. The above discussion provides a somewhat incomplete list of all the C++ oper- ators, but it nevertheless covers the most common ones. Later we introduce others, including casting operators. Operator Precedence Operators in C++ are assigned a precedence that determines the order in which operations are performed in the absence of parentheses. In Table 1.1, we show the precedence of some of the more common C++ operators, with the highest listed first. Unless parentheses are used, operators are evaluated in order from highest
- 48. i i “main” — 2011/1/13— 9:10 — page 20 — #42 i i i i i i 20 Chapter 1. A C++ Primer to lowest. For example, the expression 0 < 4 + x * 3 would be evaluated as if it were parenthesized as 0 < (4 + (x * 3)). If p is an array of pointers, then *p[2] is equivalent to *(p[2]). Except for && and | |, which guarantee left-to-right evalua- tion, the order of evaluation of subexpressions is dependent on the implementation. Since these rules are complex, it is a good idea to add parentheses to complex expressions to make your intent clear to someone reading your program. Operator Precedences Type Operators scope resolution namespace name :: member selection/subscripting class name.member pointer−>member array[exp] function call function(args) postfix operators var++ var−− prefix operators ++var −−var +exp −exp ˜exp !exp dereference/address *pointer &var multiplication/division * / % addition/subtraction + − shift << >> comparison < <= > >= equality == != bitwise and & bitwise exclusive-or ^ bitwise or | logical and && logical or | | conditional bool exp ? true exp : false exp assignment = += −= *= /= %= >>= <<= &= ^= |= Table 1.1: The C++ precedence rules. The notation “exp” denotes any expression. 1.2.1 Changing Types through Casting Casting is an operation that allows us to change the type of a variable. In essence, we can take a variable of one type and cast it into an equivalent variable of another type. Casting is useful in many situations. There are two fundamental types of casting that can be done in C++. We can either cast with respect to the fundamental types or we can cast with respect to class objects and pointers. We discuss casting with fundamental types here, and we consider casting with objects in Section 2.2.4. We begin by introducing the traditional way of casting in C++, and later we present C++’s newer casting operators.
- 49. i i “main” — 2011/1/13— 9:10 — page 21 — #43 i i i i i i 1.2. Expressions 21 Traditional C-Style Casting Let exp be some expression, and let T be a type. To cast the value of the expression to type T we can use the notation “(T)exp.” We call this a C-style cast. If the desired type is a type name (as opposed to a type expression), there is an alternate functional-style cast. This has the form “T(exp).” Some examples are shown below. In both cases, the integer value 14 is cast to a double value 14.0. int cat = 14; double dog = (double) cat; // traditional C-style cast double pig = double(cat); // C++ functional cast Both forms of casting are legal, but some authors prefer the functional-style cast. Casting to a type of higher precision or size is often needed in forming expres- sions. The results of certain binary operators depend on the variable types involved. For example, division between integers always produces an integer result by trun- cating the fractional part. If a floating-point result is desired, we must cast the operands before performing the operation as shown below. int i1 = 18; int i2 = 16; double dv1 = i1 / i2; // dv1 has value 1.0 double dv2 = double(i1) / double(i2); // dv2 has value 1.125 double dv3 = double( i1 / i2 ); // dv3 has value 1.0 When i1 and i2 are cast to doubles, double-precision division is performed. When i1 and i2 are not cast, truncated integer division is performed. In the case of dv3, the cast is performed after the integer division, so precision is still lost. Explicit Cast Operators Casting operations can vary from harmless to dangerous, depending on how similar the two types are and whether information is lost. For example, casting a short to an int is harmless, since no information is lost. Casting from a double to an int is more dangerous because the fractional part of the number is lost. Casting from a double* to char* is dangerous because the meaning of converting such a pointer will likely vary from machine to machine. One important element of good software design is that programs be portable, meaning that they behave the same on different machines. For this reason, C++ provides a number of casting operators that make the safety of the cast much more explicit. These are called the static cast, dynamic cast, const cast, and reinterpret cast. We discuss only the static cast here and con- sider the others as the need arises.
- 50. i i “main” — 2011/1/13— 9:10 — page 22 — #44 i i i i i i 22 Chapter 1. A C++ Primer Static Casting Static casting is used when a conversion is made between two related types, for example numbers to numbers or pointers to pointers. Its syntax is given below. static cast < desired type > ( expression ) The most common use is for conversions between numeric types. Some of these conversions may involve the loss of information, for example a conversion from a double to an int. This conversion is done by truncating the fractional part (not rounding). For example, consider the following: double d1 = 3.2; double d2 = 3.9999; int i1 = static cast<int>(d1); // i1 has value 3 int i2 = static cast<int>(d2); // i2 has value 3 This type of casting is more verbose than the C-style and functional-style casts shown earlier. But this form is appropriate, because it serves as a visible warning to the programmer that a potentially unsafe operation is taking place. In our examples in this book, we use the functional style for safe casts (such as integer to double) and these newer cast operators for all other casts. Some older C++ compilers may not support the newer cast operators, but then the traditional C-style and functional- style casts can be used instead. Implicit Casting There are many instances where the programmer has not requested an explicit cast, but a change of types is required. In many of these cases, C++ performs an implicit cast. That is, the compiler automatically inserts a cast into the machine-generated code. For example, when numbers of different types are involved in an operation, the compiler automatically casts to the stronger type. C++ allows an assignment that implicitly loses information, but the compiler usually issues a warning mes- sage. int i = 3; double d = 4.8; double d3 = i / d; // d3 = 0.625 = double(i)/d int i3 = d3; // i3 = 0 = int(d3) // Warning! Assignment may lose information A general rule with casting is to “play it safe.” If a compiler’s behavior regarding the implicit casting of a value is uncertain, then we are safest in using an explicit cast. Doing so makes our intentions clear.
- 51. i i “main” — 2011/1/13— 9:10 — page 23 — #45 i i i i i i 1.3. Control Flow 23 1.3 Control Flow Control flow in C++ is similar to that of other high-level languages. We review the basic structure and syntax of control flow in C++ in this section, including method returns, if statements, switch statements, loops, and restricted forms of “jumps” (the break and continue statements). If Statement Every programming language includes a way of making choices, and C++ is no exception. The most common method of making choices in a C++ program is through the use of an if statement. The syntax of an if statement in C++ is shown below, together with a small example. if ( condition ) true statement else if ( condition ) else if statement else else statement Each of the conditions should return a Boolean result. Each statement can either be a single statement or a block of statements enclosed in braces ({...}). The “else if” and “else” parts are optional, and any number of else-if parts may be given. The conditions are tested one by one, and the statement associated with the first true condition is executed. All the other statements are skipped. Here is a simple example. if ( snowLevel < 2 ) { goToClass(); // do this if snow level is less than 2 comeHome(); } else if ( snowLevel < 5 ) haveSnowballFight(); // if level is at least 2 but less than 5 else if ( snowLevel < 10 ) goSkiing(); // if level is at least 5 but less than 10 else stayAtHome(); // if snow level is 10 or more Switch Statement A switch statement provides an efficient way to distinguish between many different options according to the value of an integral type. In the following example, a
- 52. i i “main” — 2011/1/13— 9:10 — page 24 — #46 i i i i i i 24 Chapter 1. A C++ Primer single character is input, and based on the character’s value, an appropriate editing function is called. The comments explain the equivalent if-then-else structure, but the compiler is free to select the most efficient way to execute the statement. char command; cin >> command; // input command character switch (command) { // switch based on command value case ’I’ : // if (command == ’I’) editInsert(); break; case ’D’ : // else if (command == ’D’) editDelete(); break; case ’R’ : // else if (command == ’R’) editReplace(); break; default : // else cout << "Unrecognized commandn"; break; } The argument of the switch can be any integral type or enumeration. The “default” case is executed if none of the cases equals the switch argument. Each case in a switch statement should be terminated with a break statement, which, when executed, exits the switch statement. Otherwise, the flow of control “falls through” to the next case. While and Do-While Loops C++ has two kinds of conditional loops for iterating over a set of statements as long as some specified condition holds. These two loops are the standard while loop and the do-while loop. One loop tests a Boolean condition before performing an iteration of the loop body and the other tests a condition after. Let us consider the while loop first. while ( condition ) loop body statement At the beginning of each iteration, the loop tests the Boolean expression and then executes the loop body only if this expression evaluates to true. The loop body statement can also be a block of statements. Consider the following example. It computes the sum of the elements of an array, until encountering the first negative value. Note the use of the += operator to increment the value of sum and the ++ operator which increments i after accessing
- 53. i i “main” — 2011/1/13— 9:10 — page 25 — #47 i i i i i i 1.3. Control Flow 25 the current array element. int a[100]; // . . . int i = 0; int sum = 0; while (i < 100 && a[i] >= 0) { sum += a[i++]; } The do-while loop is similar to the while loop in that the condition is tested at the end of the loop execution rather than before. It has the following syntax. do loop body statement while ( condition ) For Loop Many loops involve three common elements: an initialization, a condition under which to continue execution, and an increment to be performed after each execution of the loop’s body. A for loop conveniently encapsulates these three elements. for ( initialization ; condition ; increment ) loop body statement The initialization indicates what is to be done before starting the loop. Typ- ically, this involves declaring and initializing a loop-control variable or counter. Next, the condition gives a Boolean expression to be tested in order for the loop to continue execution. It is evaluated before executing the loop body. When the con- dition evaluates to false, execution jumps to the next statement after the for loop. Finally, the increment specifies what changes are to be made at the end of each execution of the loop body. Typically, this involves incrementing or decrementing the value of the loop-control variable. Here is a simple example, which prints the positive elements of an array, one per line. Recall that ’n’ generates a newline character. const int NUM ELEMENTS = 100; double b[NUM ELEMENTS]; // . . . for (int i = 0; i < NUM ELEMENTS; i++) { if (b[i] > 0) cout << b[i] << ’n’; } In this example, the loop variable i was declared as int i = 0. Before each iteration, the loop tests the condition “i < NUM ELEMENTS” and executes the loop body
- 54. i i “main” — 2011/1/13— 9:10 — page 26 — #48 i i i i i i 26 Chapter 1. A C++ Primer only if this is true. Finally, at the end of each iteration the loop uses the statement i++ to increment the loop variable i before testing the condition again. Although the loop variable is declared outside the curly braces of the for loop, the compiler treats it as if it were a local variable within the loop. This implies that its value is not accessible outside the loop. Break and Continue Statements C++ provides statements to change control flow, including the break, continue, and return statements. We discuss the first two here, and leave the return state- ment for later. A break statement is used to “break” out of a loop or switch state- ment. When it is executed, it causes the flow of control to immediately exit the innermost switch statement or loop (for loop, while loop, or do-while loop). The break statement is useful when the condition for terminating the loop is determined inside the loop. For example, in an input loop, termination often depends on a specific value that has been input. The following example provides a different implementation of an earlier example, which sums the elements of an array until finding the first negative value. int a[100]; // . . . int sum = 0; for (int i = 0; i < 100; i++) { if (a[i] < 0) break; sum += a[i]; } The other statement that is often useful for altering loop behavior is the con- tinue statement. The continue statement can only be used inside loops (for, while, and do-while). The continue statement causes the execution to skip to the end of the loop, ready to start a new iteration. 1.4 Functions A function is a chunk of code that can be called to perform some well-defined task, such as calculating the area of a rectangle, computing the weekly withholding tax for a company employee, or sorting a list of names in ascending order. In order to define a function, we need to provide the following information to the compiler: Return type. This specifies the type of value or object that is returned by the func- tion. For example, a function that computes the area of a rectangle might re- turn a value of type double. A function is not required to return a value. For example, it may simply produce some output or modify some data structure. www.allitebooks.com
- 55. Random documents withunrelated content Scribd suggests to you:
- 56. to the southof the Forth and Clyde, while the Northern Picts occupied the whole district to the north of these estuaries. The best authorities, however, are of opinion that both divisions dwelt to the north of Antonine’s wall, and were divided from each other by the Grampians. What more immediately concerns our present purpose is a passage in Adamnan’s work in which he speaks of Columba preaching to the Picts through an interpreter. Now Columba was an Irish Scot, whose native tongue was Gaelic, and it is from this argued that the Picts to whom he preached must have spoken a different language, or at least dialect, and belonged to a different race or tribe from the saint himself. Mr. Skene,[44] who ably advocates the Gaelic origin of the Picts, perceiving this difficulty, endeavours to explain away the force of the passage by making it mean that Columba “interpreted or explained the word of God, that is, the Bible, which, being written in Latin, would doubtless require to be interpreted to them.” The passage as quoted by Skene is, “Verbo Dei per interpretorem recepto.” Garnett, however, one of the most competent and candid writers on this question in its philological aspect, and who maintains, with the greatest clearness and ability, the Cymric origin of the Picts, looks at the passage in a different light. The entire passage, he says,[45] as it stands in Colganus, is as follows:—“Alio in tempore quo sanctus Columba in Pictorum provincia per aliquot demorabatur dies, quidam cum tota plebeius familia, verbum vitæ per interpretorem, Sancto prædicante viro, audiens credidit, credensque baptizatus est.”[46] “Here it will be observed,” continues Garnett, “Adamnan does not say, ‘verbum Dei,’ which might have been construed to mean the Scripture, but ‘verbum vitæ, Sancto prædicante viro,’ which can hardly mean anything but ‘the word of life, as it was preached by the Saint.’” Certainly, we think, the unprejudiced reader must admit that, so far as this point is concerned, Mr. Garnett has the best of it. Although at that time the Gaelic and Cymric dialects may have had much more in common than they have at the present day, nevertheless it appears
- 57. to be beyonda doubt that the difference between the two was so great that a Gael would be unintelligible to a speaker of Cymric.[47] The next and most important authority of this class on this quæstio vexata is the Venerable Bede, who, considering the age in which he lived, exercised so much caution and discrimination, that he deserves to be listened to with respect. Bede was born about 673. He was educated in the Monastery of Wearmouth, whence he removed to Jarrow, where he was ordained deacon in his nineteenth year, and priest in his thirtieth, and where he spent the rest of his days, dying in 735. He wrote many works, but the most important is the Historia Ecclesiastica Gentis Anglorum, the materials for which he obtained chiefly from native chronicles and biographies, records and public documents, and oral and written communications from contemporaries. We shall transcribe most of the passage in which Bede speaks of the ancient inhabitants of Britain; so that our readers may be able to judge for themselves of the nature and value of the testimony borne by this venerable author. It must, however, be kept in mind that Bede does not pretend to give any but the ecclesiastical history of the English nation, everything else being subsidiary to this. “This island at present, following the number of the books in which the Divine law was written, contains five nations, the English, Britons, Scots, Picts, and Latins, each in its own peculiar dialect cultivating the sublime study of Divine truth. The Latin tongue is, by the study of the Scriptures, become common to all the rest. At first this island had no other inhabitants but the Britons, from whom it derived its name, and who coming over into Britain, as is reported, from Armorica, possessed themselves of the southern parts thereof. When they, beginning at the south, had made themselves master of the greatest part of the island, it happened, that the nation of the Picts coming into the ocean from Scythia, as is reported, in a few tall ships, were driven by the winds beyond the shores of Britain and arrived off Ireland, on the northern coasts, where, finding the nation of the Scots, they requested to be allowed to settle among them,
- 58. but could notsucceed in obtaining their request. The Scots answered, that the island could not contain them both; but ‘we can give you good advice,’ said they, ‘what to do; we know there is another island, not far from ours, to the eastward, which we often see at a distance, when the days are clear. If you will repair thither, you may be able to obtain settlements; or if they should oppose you, you may make use of us as auxiliaries.’ The Picts accordingly sailing over into Britain, began to inhabit the northern parts thereof, for the Britons were possessed of the southern. Now the Picts having no wives, and asking them of the Scots, they would not consent to grant them upon any other terms, than that when any difficulty should arise, they should rather choose themselves a king from the female royal race than from the male; which custom, as is well known, has been observed among the Picts to this day. In process of time, Britain, besides the Britons and the Picts, received a third nation, the Scots, who, departing out of Ireland under their leader Reuda, either by fair means, or by force of arms, secured to themselves those settlements among the Picts which they still possess. From the name of their commander, they are to this day called Dalreudins; for in their language Dal signifies a part.... It is properly the country of the Scots, who, migrating from thence, as has been said, added a third nation in Britain to the Britons and the Picts. There is a very large gulf of the sea, which formerly divided the nation of the Picts from the Britons; which gulf runs from the west very far into the land, where, to this day, stands the strong city of the Britons, called Alcluith. The Scots arriving on the north side of this bay, settled themselves there.”[48] Here then Bede informs us that in his time the common report was that the Picts came into Scotland from Scythia, which, like the Germania of Tacitus, may be taken to mean the northern countries of Europe generally. This is substantially the same statement as that of the author of the Historia Britonum, commonly called Nennius, who lived in the 9th century, and who informs us that the Picts coming to Scotland about 300 B.C., occupied the Orkney Islands, whence issuing, they laid waste many regions, and seized those on
- 59. the left-hand side,i.e. the north of Britain, where they still remained in the writer’s time, keeping possession of a third part of Britain.[49] Supposing that Bede’s report was quite in accordance with truth, still it gives us but small help in coming to a conclusion as to the place of these Picts among the families of men. It is certain that by far the greater part of Europe had at one time a Celtic population who preceded, but ultimately gave way to another wave of emigrants from the east. Now, if we knew the date at which this so- called migration of the Picts took place it might be of considerable assistance to us; but as we cannot now find out whether these emigrants proceeded from a Celtic or a Teutonic stock, the statement of Bede, even if reliable, helps us not at all towards a solution of the question as to the race of the Picts. Innes[50] remarks very justly on this point—“Now, supposing that there were any good ground for the opinion of these two writers, which they themselves give only as a conjecture or hearsay, and that we had any certainty of the Caledonians, or Picts, having had their origin from the more northern parts of the European continent, it were an useless, as well as an endless discussion, to examine in particular from which of all the northern nations of the continent the first colony came to Caledonia; because that these nations of the north were almost in perpetual motion, and changing habitations, as Strabo remarks; and he assigns for it two reasons: the one, because of the barrenness of the soil, they tilled not the ground, and built habitations only for a day; the other, because being often overpowered by their neighbours, they were forced to remove. Another reason why it is impossible to know from which of those nations the northern parts of Britain, (supposing they came from thence) were at first peopled, is because we have but very lame accounts of these northern nations from the Greek or Roman writers, (from whom alone we can look for any thing certain in those early times) especially of those of Scandia, to the north of the Baltic sea, as the same Strabo observes. Besides, it appears that Caledonia was peopled long before the inhabitants of these northern parts of the continent were mentioned, or even known by the most ancient writers we have; and perhaps
- 60. before the firstnations mentioned by them were settled in those parts.” There is, however, another statement made by Bede in the passage quoted, upon which, as it refers to his own time, much more reliance can be placed; it is, that in his time Britain contained five nations, each having its own peculiar dialect, viz., the English, Britons, Scots, Picts, and Latins. We know that the English spoke in the main Saxon; the Britons, i.e., the inhabitants of Wales, Cumbria, &c., Welsh; the Scots, Gaelic; the Latins, we suppose, being the Romanized Britons and ecclesiastics. What language then did the Picts speak? As we know that Bede never travelled, he must have got his information from an informant or by hearsay, which circumstance rather detracts from its value. But supposing we take the passage literally as it stands, we learn that in Bede’s time there were five distinct peoples or nations, whose names he gives, sharing among them the island. He does not say there were five distinct tongues, which would have been quite a different statement; he speaks of them not so much in respect of their language as in respect of their being the separate items which composed the inhabitants of Britain. In his time they were all quite distinct, in a measure independent of and at enmity with each other. He does not classify them in respect of the race to which they belonged, but with reference to the particular districts which they inhabited, and perhaps with regard to the time and means of their conversion to Christianity, each having been converted at a different time and by a different saint. The substance then of what he says appears to be, that there were in his time five distinct tribes or congregations of people in Britain, each converted to Christianity, and each having the gospel preached in its own tongue. Supposing that the Picts and Scots, or Picts and Britons, or Picts and English did speak exactly the same tongue, it is not at all likely that Bede, in the present case, would have classed them together as both being one nation. Moreover, suppose we allow that Bede did mean that each of these nations spoke a language quite distinct from all the others, then his statement cuts equally at the Gothic and Celtic theory. The
- 61. conclusion we areforced to is, that from this passage nothing can be gained to help us out of our difficulty. There is a statement at the end of the passage quoted to which we would draw the reader’s attention, as being Bede’s way, and no doubt the universal way in his time, of accounting for a peculiar law which appears to have regulated the succession to the Pictish throne, and which ultimately, according to some, was the means of placing on that throne a Scottish monarch; thus accounting to some extent for the sudden disappearance and apparent destruction of the Pictish people and language. We shall here refer to one other passage in the same historian, which has perhaps given rise to greater and more acrimonious contention than any other point in connection with this wordy discussion. The only word that has come down to us, which, with the exception of the names of the Pictish kings, we can be sure is a remnant of the Pictish language, is the name said by Bede to have been given to the eastern termination of the wall of Antonine. Bede, [51] in speaking of the turf wall built by the Britons of Valentia in the beginning of the 5th century, says, “it begins at about two miles distance from the monastery of Abercorn on the west, at a place called in the Pictish language Peanfahel, but in the English tongue Penneltum.” This statement of Bede’s is straightforward and clear enough, and has never been disputed by any writer on any one of the three sides of the question. Nevertheless it has been used by the advocates respectively of the Gothic, Gaelic, and Cymric origin of the Picts, as an undoubted proof of the correctness of each of these theories. Pinkerton, whose dishonesty and acrimoniousness are well known, and must detract considerably from the force of his arguments, claims it as being entirely Gothic or Teutonic. “The Pictish word,” he says,[52] “is broad Gothic; Paena ‘to extend,’ Ihre; and Vahel, a broad sound of veal, the Gothic for ‘wall,’ or of the Latin vallum, contracted val; hence it means ‘the extent or end of the wall.’” This statement of Pinkerton’s may be dismissed as too far- fetched and awkward to merit much consideration, and we may safely regard the word as capable of satisfactory explanation only in
- 62. Celtic. Innes, whoupholds the British, i.e. the Cymric, origin of the Picts, says,[53] “we nowhere find a clearer proof of the Pictish language being the same as the British [Welsh], than in Bede, where he tells us that Penuahel in Pictish signifies the head of the wall, which is just the signification that the same two words Pen and Uahel have in the British.” In this opinion Chalmers and other advocates of the Cymric theory coincide. Mr. Garnett, who essentially agrees with Innes and Chalmers as to the Cymric origin of the Picts, lays little stress upon this word as furnishing an argument in support of his theory. “Almost the only Pictish word given us by an ancient writer is the well-known Pen val (or as it appears in the oldest MSS. of Bede (Peann fahel)), the name given by the Picts to the Wall’s End, or eastern termination of the Vallum of Antoninus. It is scarcely necessary to say the first part of the word is decidedly Cymric; pen, head, being contrary to all Gaelic analogy. The latter half might be plausibly claimed as the Gaelic fal; gwall being the more common termination in Welsh for a wall or rampart. Fal, however, does occur in Welsh in the sense of inclosure, a signification not very remote.”[54] The two most recent and able supporters[55] of the Gaelic theory are of much the same mind as Garnett, and appear to regard this tantalizing word as affording no support to either side. Burton[56] cannot admit that anything has been made out of this leading to a historical conclusion. We may safely conclude, then, that this so called Pictish word, or, indeed, any information which we find in Bede, affords us no key to the perplexing question of the origin and race of the Picts. We learn, however, one fact from Bede[57] which is so far satisfactory, viz., that in his time there were two divisions of the Picts, known as the Northern and Southern Picts, which were separated from each other by steep and rugged mountains. On reading the passage in Bede, one very naturally supposes that the steep and rugged mountains must be the Grampians, to which the expression applies more aptly than to any other mountain-chain in
- 63. Scotland. Even this,however, has been made matter of dispute, it being contended by some that the locality of the Southern Picts was in the south-west and south of Scotland, where some writers set up a powerful Pictish kingdom. Mr. Grub,[58] however, has clearly shown that the locality of the Southern Picts was to the north of the Forth and Clyde, and to the south of the Grampians. “The mistake formerly so common in regard to the country of the Southern Picts converted by St. Ninian, was in part owing to the situation of Candida Casa. It was supposed that his see must have been in the country of those whom he converted.” He clearly proves that it was not so in reality, and that there was nothing so unusual in the situation as to justify the conclusion which was drawn from it. “It was, no doubt, the case that the teachers by whom the chief Celtic and Teutonic nations were converted generally fixed their seat among those whom they instructed in the faith. But there was no necessity for this, especially when the residence of the teacher was in the neighbourhood of his converts. St. Columba was primate of all the churches of the Northern Picts, but he did not permanently reside among that nation. St. Ninian had ready access to his Pictish converts, and could govern them as easily from his White Church on the Solway, as Columba could instruct and rule the Northern Picts from his monastery in Iona.”[59] Other authorities appealed to by the upholders of each of the Celtic theories are the Welsh traditions, the Irish Annals, the Chronicles of the Picts and Scots, and various legendary documents of more or less value and authenticity. As these are of no greater authority than the writers with whom we have been dealing, and as the partisans of each theory claim the various passages as either confirming, or, at any rate, not contradicting their views, we shall not further trouble the reader with specimens of the manner in which they are dealt with. There is one passage, however, in the Welsh Triads, which the advocates of the Gaelic hypothesis claim as strongly confirmatory of their theory. After referring to the coming in of the Cymry, the Britons, etc., the Triads[60] go on to say, “Three tribes came, under protection, into the Island of Britain, and by the
- 64. consent and permissionof the nation of the Cymry, without weapon, without assault. The first was the tribe of the Caledonians in the north. The second was the Gwyddelian Race, which are now in Alban (Scotland). The third were the men of Galedin, who came into the Isle of Wight. Three usurping tribes came into the Island of Britain and never departed out of it. The first were the Coranied, who came from the land of Pwyl. The second were the Gwyddelian Ffichti, who came into Alban over the sea of Llychlyn (Denmark). The third were the Saxons.” “The Triads,” says Skene[61] in connection with this, “appear distinctly to have been written previous to the Scottish conquest in the ninth century, and they mention among the three usurping tribes of Britain the ‘Gwyddyl Ffichti,’ and add immediately afterwards, ‘and these Gwyddyl Ffichti are in Alban, along the shore of the sea of Llychlyn.’ In another place, among the treacherous tribes of Britain, the same Triads mention the ‘Gwyddyl coch o’r Werddon a ddaethant in Alban,’ that is ‘the Red Gwyddyl from Ireland, who came into Alban,’ plainly alluding to the Dalriads, who were an Irish colony, and who have been acknowledged by all to have been a Gaelic race. It will be observed from these passages that the Welsh Triads, certainly the oldest and most unexceptionable authority on the subject, apply the same term of Gwyddyl to the Picts and to the Dalriads, and consequently they must have been of the same race, and the Picts a Gaelic people. Farther, the Welsh word ‘Gwyddyl,’ by which they distinguish that race, has been declared by all the best authorities to be exactly synonymous with the word Gael, the name by which the Highlanders have at all times been distinguished, and the Welsh words ‘Gwyddyl Ffichti’ cannot be interpreted to mean any thing else than ‘The Gaelic Picts,’ or ‘Pictish Gael.’” The following is the substance of the information given by the Irish writers as to the origin, race, and early history of the Picts. The greater part of it is, of course, mere tradition, accumulating as it grew older, and heightened by the imagination of the writers themselves.[62] The Picts were called by the Irish writers Cruithnidh, which O’Brien considers to be the same as Britneigh, or Britons; but
- 65. according to othersthe name was derived from Cruthen, who founded the kingdom of the Picts in North Britain, in the first century; others derive the name from Cruit, a harp, hence Cruitneach, the Irish for Pict, also signifies a harper, as they are said to have been celebrated harpers. The ancient Britons are mentioned by Cæsar, and other Roman writers, to have painted their bodies of a blue colour, with the juice of a plant called woad, hence the painted Britons were called by the Romans Picti. The Picts or Cruthneans, according to the Psalter of Cashel, and other ancient annals, came from Thrace, in the reign of the Milesian monarch Heremon, nearly a thousand years before the Christian era, and landed at Inver Slainge, now the Bay of Wexford, under two chief commanders named Gud and Cathluan, but not being permitted to settle in Ireland, they sailed to Albain, or that part of North Britain, now Scotland, their chiefs having been kindly supplied with wives of Irish birth. The Cruthneans became possessed of North Britain, and founded there the kingdom of the Picts. A colony of the Cruthneans, or Picts, from North Britain, settled in Ulster in early times, and are often mentioned from the first to the ninth century; they resided chiefly in Dalaradia and Tir Eogain, or parts of Down, Antrim, and Derry, and became mixed by intermarriages with the old Irish of the Irian race, and were ruled over by their own princes and chiefs; and some of those Picts, also settled in Connaught, in the county of Roscommon. According to the Irish writers, the Picts, in their first progress to Ireland from Thrace, settled a colony in Gaul, and the tribes called Pictones and Pictavi, in that country, were descended from them, and they gave name to Pictavia, or the city of Poictiers, and the province of Poitou; and from these Picts were descended the Vendeans of France. The Caledonians, or first inhabitants of Scotland, are considered to have been the same as the Picts, and mixed with Cimbrians or Britons, and some of the Milesian Scots from Ireland. The advocates of the various theories, apparently aware of how little can be made of the meagre and suspicious information afforded by these early histories and chronicles, have latterly made language
- 66. the principal battle-groundon which to fight out this endless and profitless strife. Most of them take for granted that if the language spoken by any people can be found out, a sure indication is afforded of the race to which that people belonged; and that the topography of a country must necessarily have been imposed by the earliest inhabitants of whom we have record; and that, if so, the limits of their territory must have been co-extensive with the limits of such topography. This, however, is going too far. All the length to which we are permitted in fairness to go, when we find in any district or country an abundance of names of natural objects, as rivers and mountains, which can with certainty be traced to any particular language, is, that at one time or other, a race of people speaking this language must have passed over and dwelt for some time in that particular district or country. We find Celtic names of rivers and mountains scattered all over Europe, in the midst of peoples who are admitted on all hands to have little or none of the Celtic element in them.[63] So that an unprejudiced judge must admit that the fact of Cymric and Gaelic words being found in certain districts of the north of Scotland argues only that at one time people speaking these dialects must have dwelt in these districts. It affords no proof by itself that the people whom we first meet with in these districts are the people who spoke these dialects, and who imposed these names; nor indeed, if we could be sure that the people whom we first meet with as inhabitants also spoke the dialect to which such names belong, does it prove that they were the imposers of these names, that the dialect was their native and original tongue, and that they had not acquired it either as conquerors or conquered. Nor can it be adduced as a proof of sameness of race, that the present inhabitants of any particular district speak the same language as those who inhabited that district 1800 years ago or less. “He who trusts to language, and especially to written language, alone, as an index to race, must be prepared to maintain that the Gallic nation emigrated from the seven hills of Rome, and that the Franks came with them; that the Romans extirpated the Celts and Iberians of Spain, and that the Goths and Moors spoke nearly the same
- 67. language as theRomans; that the Negroes of the United States and Jamaica were exported from England when in their infancy. So would Philology, if left to herself, interpret phenomena, of which we know, from other sources of information, that the causes are totally different.”[64] “The clearest proof that a mountain or river has a Celtic name, only shows that at some time or other Celts had been there; it does not tell us when they were there. Names, as the experience of the world amply shows, live after the people who bestowed them have long disappeared, and that through successive races of occupants.”[65] The materials which have been wrought up into a linguistic argument by the upholders of each of the three Pictish theories, Gothic, Gaelic, and Cymric, are chiefly a list of Pictish kings which, we believe, may be depended on as authentic, and the topography of the country to the east and south-east of the Grampians, together with the single so-called Pictish word Peanfahel, which we have already considered. The theorists differ as much in their interpretation of the significance of what remains of the Pictish language, as we have seen they do in their interpretation of any references to the subject in dispute in ancient chronicles. The names of the kings, and the names of places have been traced by the disputants to Gothic, Gaelic and Cymric roots. As an amusing specimen of the ingenuity displayed in this hunt after roots, we give below a small table from Burton, comparing the different etymologies of names of kings given by Pinkerton, Chalmers, and Jamieson.[66] It is, however, generally admitted at the present day, that so far as language is concerned, the Gothic theory has not the remotest chance; that names of places and of kings are most satisfactorily and straightforwardly explained by Cymric roots. As the Gothic or Teutonic theory cannot stand the test of modern criticism, we shall content ourselves with giving specimens of the manner in which the linguistic, or, more strictly, topographical argument is used by the advocates of the Cymric and Gaelic hypotheses respectively.
- 68. The Cymric argumentis clearly, ably, and succinctly stated by Mr. Garnett in his essay on “The Relation of the Pict and Gael;” he, however, it must be remembered, looked at the whole question mainly in its philological aspect. In stating the argument we shall use chiefly his own words.[67] “That the Picts were actually Celts, and not of Teutonic race, is proved to a demonstration by the names of their kings; of whom a list, undoubtedly genuine from the fifth century downwards, was published by Innes, from a manuscript in the Colbertine library. Some of those appellations are, as far as we know at present, confined to the Pictish sovereigns; but others are well- known Welsh and Gaelic names. They differ, however, slightly in their forms, from their Cymric equivalents; and more decidedly so from the Gaelic ones; and, as far as they go, lead to the supposition that those who bore them spoke a language bearing a remote analogy to the Irish with its cognates, but a pretty close one to the Welsh. “In the list furnished by Innes the names Maelcon, Elpin, Taran (i.e. thunder), Uven (Owen), Bargoit, are those of personages well known in British history or tradition. Wrgust, which appears as Fergus in the Irish annals, is the Welsh Gwrgust. Talorg, Talorgan, evidently contain the British word Tal, forehead, a common element in proper names; ex. gr. Talhaiarn, Iron Forehead; Taliesin, splendid forehead, &c. Taleurgain would signify in Welsh golden or splendid front. Three kings are represented as sons of Wid, in the Irish annals of Foit or Foith. In Welsh orthography it would be Gwydd, wild; a common name in Brittany at the present day, under the form of Gwez. The names Drust, Drostan, Wrad, Necton (in Bede Naitan), closely resemble the Welsh Trwst, Trwstan, Gwriad, Nwython. It will be sufficient to compare the entire list with the Irish or Highland genealogies, to be convinced that there must have been a material distinction between the two branches. Most of the Pictish names are totally unknown in Irish or Highland history, and the few that are equivalent, such as Angus and Fergus, generally differ in form. The Irish annalists have rather obscured the matter, by transforming those names according to their national system of orthography; but it is remarkable that a list in the ‘Book of Ballymote,’ partly given by
- 69. Lynch in his‘Cambrensis Eversus,’ agrees closely with Innes, even preserving the initial w or u where the Gaelic would require f. The philological inferences to be deduced from this document may be thus briefly summed up:—1. The names of the Pictish kings are not Gaelic, the majority of them being totally unknown both in the Irish and Highland dialects, while the few which have Gaelic equivalents decidedly differ from them in form. Cineod (Kenneth) and Domhnall or Donnel, appear to be the only exceptions. 2. Some of them cannot be identified as Welsh; but the greater number are either identical with or resemble known Cymric names; or approach more nearly to Welsh in structure and orthography than to any other known language. 3. There appears nevertheless to have been a distinction, amounting, at all events, to a difference in dialect. The Pictish names beginning with w would in Welsh have gw, as Gwrgust for Wrgust, and so of the rest. There may have been other differences sufficient to justify Bede’s statement that the Pictish language was distinct from the British, which it might very well be without any impeachment of its claim to be reckoned as closely cognate.” We have already referred to the use made of the Pictish word Peannfahel, preserved by Bede, and to the phrase in Adamnan concerning Columba’s preaching by means of an interpreter. It is contended by the upholders of the Cymric theory that the ancient topographical appellations of the Pictish territory can in general only be explained by the Cymric dialects, one strong point being the number of local names beginning with the Welsh prefix aber, which, according to Chalmers, was in several instances subsequently changed by the Gael into inver. Skene,[68] who felt the force of this argument, tried to get rid of it by contending that aber is essentially a Gaelic word, being compounded of ath, ford, and bior, water. Garnett thinks this explanation utterly gratuitous, and observes that the term may be much more satisfactorily accounted for by a different process. “There are,” he observes,[69] “three words in Welsh denoting a meeting of waters—aber, cynver, and ynver,— respectively compounded of the particles a, denoting juxtaposition,
- 70. cyn (Lat. con),and yn, with the root ber, flowing, preserved in the Breton verb beri, to flow, and all virtually equivalent to our word confluence. Inver is the only term known in any Gaelic dialect, either as an appellative or in proper names; and not a single local appellation with the prefix aber occurs either in Ireland or the Hebrides, or on the west coast of Scotland. Indeed, the fact that inver was substituted for it after the Gaelic occupation of the Pictish territories, is decisive evidence on the point; for, if aber was a term familiar to the Gael, why should they change it?” “In Scotland,” says Isaac Taylor,[70] who upholds the Cymric hypothesis, “the invers and abers are distributed in a curious and instructive manner. If we draw a line across the map from a point a little south of Inverary, to one a little north of Aberdeen, we shall find that (with very few exceptions) the invers lie to the north west of the line, and the abers to the south-east of it. This line nearly coincides with the present southern limit of the Gaelic tongue, and probably also with the ancient division between the Picts and Scots. Hence we may conclude that the Picts, a people belonging to the Cymric branch of the Celtic stock, and whose language has now ceased to be anywhere vernacular, occupied the central and eastern districts of Scotland, as far as the Grampians; while the Gadhelic Scots have retained their language, and have given their name to the whole country. The local names prove, moreover, that in Scotland the Cymry did not encroach on the Gael, but the Gael on the Cymry. The intrusive names are invers, which invaded the land of the abers. Thus on the shore of the Frith of Forth we find a few invers among the abers. The Welsh word uchel, high, may also be adduced to prove the Cymric affinities of the Picts. This word does not exist in either the Erse or the Gaelic languages, and yet it appears in the name of the Ochil Hills, in Perthshire. Again, the Erse bally, a town, occurs in 2,000 names in Ireland; and, on the other hand, is entirely absent in Wales and Brittany. In Scotland this most characteristic test-word is found frequently in the inver district, while it never appears among the abers. The evidence of these names
- 71. makes it impossibleto deny that the Celts of the Scottish Lowlands must have belonged to the Cymric branch of the Celtic stock.” We infer from what Mr. Taylor says, that he is of opinion that at one time the language of the whole of the north of Scotland was Cymric, but that the district in which the Scots obtained a settlement afterwards underwent a change of topography. But it is admitted on all hands that the Scottish Dalriada comprehended no more than the modern Argyllshire, extending no farther north than Loch Leven and Loch Linnhe; and that the Irish Scots had little influence on the people or their language to the north-west of the Grampians. Indeed, Skene[71] maintains that this district, in which he places the Northern Picts, was never subjected to the Scots, and that it was only the Southern Picts who latterly came under their sway. Yet we find that the abers here are few and far between, or, indeed, any indications of Cymric possession such as we find in the southern district. Is it possible that the Northern and Southern Picts were representatives of the two great divisions of the Celts,—the former claiming a Gaelic origin, and the latter a Cymric? Perhaps after all the Welsh Triads may in course of time be of some help in the solution of this dark problem, as, according to them, there was more than one Celtic settlement in Scotland before the migration of the Scots. The passages above quoted are, to all appearance, much more favourable to the Gaelic than to the Cymric hypothesis, and have been made much of by Skene and other supporters of that side of the question. The Cymric origin of the Picts, besides Garnett and Taylor, is supported by such names as Innes, Chalmers, Ritson, Whittaker, Grub, and others. Pinkerton, it is well known, is the great and unscrupulous upholder of the Gothic origin of the Picts; while the Gaelic theory has for its supporters such writers, of undoubted ability and acuteness, as Skene, E. W. Robertson, Forbes-Leslie, &c. Burton[72] is of opinion that the Highlanders of the present day are the true representatives of the Dalriadic Scots of the West.
- 72. We shall, aswe have done in the case of the other side, allow the upholders of the Gaelic hypothesis to state for themselves the Gaelic topographical argument. We shall use the words of Colonel Forbes- Leslie, who, in his invaluable work on the “Early Races of Scotland,”[73] says, “The Celtic words Inver and Aber have nearly the same meaning; and the relative position in which they occur in names of places has been employed as if it were a sufficient argument for defining the presence or preponderance of the British or Gaelic Celts in certain districts. In this way Aber, prefixed to names of places, has been urged as adequate proof that the Picts of Caledonia were Celts of the British branch. The value of these and some other words requires examination. Inver is to be found in names of places in Wales. It may possibly be a British word. It certainly is a Gaelic one. Aber, although undoubtedly British, is also Gaelic—compounded of the two words Ath and Bior—and signifying the same as Inver, viz., the confluence of two streams, or the entrance to a river. If the word Aber had been unknown to the Gaelic scholars of modern days, its former existence in that language might have been presumed from the ancient names of places in the districts of Caledonia, where it occurs most frequently, being generally Gaelic and not British. “Beyond the limits of Caledonia on the south of the Forth and Clyde, but within the boundary of modern Scotland, the word Inver, generally pronounced Inner, is of common occurrence, and bears witness to a Gaelic nomenclature. Thus, Inner or Inverkip, in the county of Renfrew; Innerwell, in the county of Wigton; Innerwick, in the county of Haddington; Innerleithen, in the county of Peebles; Inverleith and Inveresk, in the county of Edinburgh, derive their names from their situation in regard to the rivers Kip, Leithen, Esk, &c. &c. “From the Moray Frith to the Forth, in the eastern counties of Caledonia, the prefix Inver or Aber is used indiscriminately in contiguous places. At the confluence of lesser streams with the river Dee, in Aberdeenshire, we find Inverey, Abergeldie, Invercauld, Invercanny, Aberdeen. Yet in those counties—viz., Aberdeen,
- 73. Kincardine, Forfar, Perth,and Fife, in which were situated the capitals, and which were the richest provinces of the southern Picts —the number of names of places beginning with Inver is three times as numerous as those commencing with Aber; there being, in a list taken from land-registers, which do not go farther back than the middle of the sixteenth century, seventy-eight with Inver to twenty- four with Aber. It may, however, be admitted that, although Aber is Gaelic, its use is far more general by Celts of the British tribes; and that the predominance of Inver in the districts north of the Spey, and the intermixture of places the names of which commence with Inver or Aber, not unfrequently used in records of nearly the same date for the same place in the country lying between the Moray and the Solway Friths, is, to a certain extent, evidence of a British element of population extending into Caledonia. The Britons, in earlier times, may have been pressing on to the north by gradual intrusion, and were probably afterwards increased by bodies of exiles escaping from the severity of Roman bondage and the punishment of unsuccessful revolt. “That names of places containing the words Bal, from Bail, a place or residence, and Ard, a height or rising ground, are so common in Ireland, and comparatively rare, so it is alleged, in Caledonia, has also been used as an argument to prove that the language of the Picts and other Caledonians of the southern and eastern districts was British, not Gaelic. But the foundation of the argument has been assumed, and is easily disproved. It is true that of large towns and places that appear in gazeteers, names commencing with Bal and Ard are not numerous. But in fact such names are extremely common. In the lowlands of Aberdeenshire—that is, in the portion of one county, and in the part of Caledonia farthest removed from the settlements of the intrusive Gaels, viz., the Scots from Ireland— registers of land show upwards of fifty places the names of which commence with Bal, and forty which commence with Ard. In the Pictish territory, from the Moray Frith to the Forth, I soon collected upwards of four hundred names of places beginning with Bal, and
- 74. upwards of onehundred with Ard; and the number might easily be doubled.” Mr. E. W. Robertson, one of the latest and ablest upholders of this theory, thinks[74] there is scarcely sufficient evidence to justify any very decided conclusion as to the pre-existence of a Cymric population; and that, whilst it would be unquestionably erroneous to ascribe a Cymric origin to the Picts, the existence of a Celtic element akin to the Cymri, amongst the population of Alban before the arrival of the Gwyddel Ffichti, must remain to a certain extent an open question. Of all a priori theories that have hitherto been advanced as to how Scotland was likely to have been at first peopled, that of Father Innes, the first writer who investigated the subject thoroughly and critically, appears to us to be the most plausible and natural, although even it is beset with many difficulties. It appears to him more natural and probable that the Caledonian Britons, or Picts, were of the same origin as the Britons of the south; that as these came in originally from the nearest coast of Gaul, as they multiplied in the island, they advanced to the north and settled there, carrying with them the customs and language of the South Britons.[75] We have thus endeavoured to lay before the reader, as fully as space permits, and as clearly and unprejudicedly as possible, the materials at present existing by means of which to form an opinion on the Pictish question, and the arguments pro and con, mainly in their own words, urged by the partisans of the different theories. It appears to us that the data within reach are far too scanty to justify any one in coming to a settled conclusion, and that we must wait for more light before we can be justified in finally making up our minds on this perplexing subject.[76] At the present day we find that nearly the whole of the territory said to have been originally occupied by the Picts, is inhabited, and has been for centuries, by a population which in appearance is far more Teutonic than Celtic, and which undoubtedly speaks a broad Teutonic dialect.[77] And even in the district where the Gaelic
- 75. language has beentriumphant for ages, it is acknowledged even by the most devoted partisans of the Gaelic theory, that among the population there is a very considerable intermixture of the Teutonic element. Burton thinks, from a general view of the whole question, that the proportion of the Teutonic race that came into the use of the Gaelic, was much greater than the proportion of the Gaelic that came into the use of the Teutonic or Saxon, and that this may account for the contrasts of physical appearance to be seen in the Highlands. We certainly have not exhausted the statement of the question, have not stated fully and completely all the points in dispute; nor do we pretend to have given with fulness all the arguments pro and con on the various sides. We have, however, given as much as will enable any ordinary reader to form for himself a fair idea of the present state of the Pictish question, and indicated the sources whence more information may be derived, should any one wish to pursue the subject farther. In the words of the latest and greatest Scottish historian “this brief survey of the great Pictish controversy leaves nothing but a melancholy record of wasted labour and defeated ambition. It has been more fruitless than a polemical or a political dispute, for these leave behind them, either for good or evil, their marks upon the conduct and character of the populations among whom they have raged; while here a vast outlay of learning, ingenuity, enthusiasm, and, it must be added, temper, have left no visible monument but a pile of forbidding volumes, in which should any one who has not studied the matter fundamentally expect to find instructive information, he will assuredly be led into a tangled maze of unintelligible pedantry, from which he will come forth with no impression but a nightmare feeling of hopeless struggle with difficulties.”[78]
- 76. FOOTNOTES: [24] Garnett’s PhilologicalEssays, p. 196. [25] Agricola xi. [26] The wall of Antonine. [27] Dio L. 76, c. 12, as quoted in Ritson’s Annals, p. 11. [28] Critical Essay, ch. ii. [29] Highlanders. [30] Book iii. [31] “Scotti per diversa vagantes, multa populabantur.” Am. Mar. xxvii. 8. [32] “—— Nec falso nomine Pictos Edomuit.” [33] “Venit et extremis legio prætenta Britannis Quæ Scoto dat fræna truci, ferroque notatas Perlegit exangues Scoto moriente figuras.”— De bello Getico, v. 416. Thus rendered by Ritson:— The legion came, o’er distant Britains placed, Which bridles the fierce Scot, and bloodless figures With iron marked, views in the dying Pict. [34] The name given by the Irish Annalists to the Picts is Cruithne, said by some to mean “variegated.” [35] The only important exception is Ritson, whose arguments, like those of his opponent Pinkerton, consist mostly of virulent language and vehement assertion. [36] In Amm. Mar. [37] It is a curious fact that these latter are, among the peasantry of Scotland, the distinctive characteristics of the Picts or Pechts, who, however, it is not unlikely, may be popularly confounded with the Brownies, especially as, in Perthshire at any rate, they are said always to have done their work while others were asleep.
- 77. [38] Skene’s Highlanders,vol. i. p. 2. [39] L. O. Pike, The English and their Origin, ch. i. [40] Biographia Britannica Literaria, vol. i. [41] Gildas, 1. [42] Id., 19. [43] Gildas, 14. [44] Highlanders, vol. i. p. 72. [45] Garnett’s Philological Essays, p. 199. [46] Adam. ap. Colganum, 1. ii. c. 32. [47] On the subject in question the recently published Book of Deer cannot be said to afford us any information. It gives a short account of the landing of Columba and a companion at Aberdour in the north of Aberdeenshire, and the founding of a monastery at Deer. But although the entries are in Gaelic, they do not tell us what language Columba spoke, nor whether ‘Bede the Pict,’ the mormaer of Buchan, understood him without an interpreter. The name of the saint— Drostan—whom Columba left behind him to prosecute the work, is Pictish, at any rate not Irish, so that nothing can be inferred from this. Since much of the first part of this book was written, Mr. Skene has advanced the theory, founded partly on four new Pictish words he has managed to discover, that the language of the Picts was neither pure Gaelic nor Cymric, ‘but a sort of low Gaelic dialect partaking largely of Welsh forms.’ This theory is not new, but was distinctly put forth by Dr. Maclauchlan some years ago in his able and learned work, The Early Scottish Church, p. 29: if true, it would certainly satisfy a great many of the demands which any hypothesis on the subject must do. [48] Bede’s Eccles. Hist., Book 1. c. i. [49] Nennius 12, Vatican MS. [50] Critical Essay on Scotland, vol. i. p. 68. [51] Book i., c. 12. [52] Inquiry into the Hist. of Scot., vol. i. p. 357, ed. 1814. [53] Crit. Essay, vol. i. p. 75. [54] Garnett’s Phil. Essays, p. 198. [55] Robertson’s Scotland under her Early Kings, vol. ii. p. 380. Forbes- Leslie’s Early Races of Scotland, vol. i. p 35.
- 78. [56] Hist. ofScot., vol. i. p. 187. [57] Book iii. ch. 4. [58] Eccl. Hist. of Scot., vol. i. p. 15, &c. [59] Eccl. Hist. of Scot., vol. i. p. 17. [60] Davies’ Celtic Researches, p. 155. [61] Highlanders of Scotland, vol. i. p. 69. [62] We are indebted for most of the following account to Connellan’s Annals of the Four Masters, p. 367 (note). [63] See Taylor’s Words and Places, ch. ix. [64] Pike’s English and their Origin, ch. ii., which contains some shrewd and valuable remarks on the subject of language. [65] Burton, vol. i. p. 192. [66] Chalmers for Celtic, Pinkerton for Gothic, Jamieson, “Teutonic Etymons.” Drust Probably the British name Trwst, which signifies din. Drust, a common Pikish name, is also Persian, and signifies sincerus.... The Persians were the old Sythæ or Goths, from whom the rest sprung. Su. Goth. troest, dristig. Germ., dreist. Alem. gidrost, daring. Brudi or Bridei Brudw, which is pronounced Bridw or Bradw, is in the British treacherous. Brudi is the real Gothic name; Bout is the wounded (Bott ictus Wachter). Island., Briddi eminebat. vercl: breida, to extend; and Sueo- Goth, e, law; 2. one who extends the law, who publishes it. For other instances see Burton’s Scotland, i. p. 196. [67] Garnett’s Phil. Essays, pp. 197, 198. [68] Highlanders. [69] Phil. Essays, p. 200. [70] Words and Places, p. 246. [71] Highlanders. [72] Scotland, vol i. p. 207. [73] Vol. i. p. 26. [74] Vol. ii. p. 377. [75] Essay on Scotland, vol. i. p. 70.
- 79. [76] We havealready (p. 22) referred to the Gaelo-Cymric theory broached by Dr. Maclauchlan in his Early Scottish Church, and recently adopted by Dr. Skene. Speaking of the distribution of the topographical nomenclature in the Highlands, Dr. Maclauchlan says it indicates one of two things; “either that the one race overpowered the other in the east, and superinduced a new nomenclature over the old throughout the country,—that we have in fact two successive strata of Celtic names, the Gaelic underlying the British, which is by no means impossible; or, what is more likely, that the Pictish people were a people lying midway between the Gael and the Cymri—more Gaelic than the Cymri, and more Cymric than the Gael. This is precisely the character of the old Pictish topography; it is a mixture of Gaelic and Cymric; and if the language of the people was like their topography, it too was a language neither Gaelic nor Cymric, but occupying a middle space between them, indicating the identity of the races at some distant period, although they afterwards became rivals for the possession of the land.” This we think on the whole the most satisfactory theory yet propounded. [77] We would infer from the recently published Book of Deer, that down at least to the time of David II., the inhabitants were still a Gaelic speaking population; all the entries in that book as to land are in that language. [78] Burton, vol. i. p. 200.
- 81. CHAPTER III. A.D. 446–843. EarlyHistory—Scottish Settlement—Origin of Scots—Dalriada—Conversion of Picts—Druidism—St. Columba—Iona—Spread of Christianity—Brude and his Successors—Dun-Nechtan—Pictish Wars—Ungus—Contests—Norsemen—Union of Picts and Scots—Scoto-Irish or Dalriads—Lorn, Fergus, Angus and their Successors—Aidan—Contest at Degsastan—Donal Breac—Wars with Irish and Picts—Conal II. and Successors—Ferchar Fada—Selvach and Duncha Beg— Eocha III. unites Dalriada—Muredach—Contests with Picts—Aodh-fin—Eocha IV. or Achaius—Alpin—Kenneth—Union of Picts and Scots—Dalriadic Government—Tanist—Brehon—Laws—Fosterage—Lists of Kings. As we have already said, the materials for the internal history of the Highlands during the Roman occupation are of the scantiest, nearly all that can be recorded being the struggles of the northern tribes with the Roman invaders, and the incursions of the former and their allies into the territories of the Romanized Britons. Doubtless many events as worthy of record as these, an account of which has been preserved, were during this period being transacted in the northern part of Scotland, and we have seen that many additions, from various quarters, must have been made to the population. However, there are no records extant which enable us to form any distinct notion of the nature of these events, and history cannot be manufactured. After the departure of the Romans, the provincial Britons of the south of Scotland were completely at the mercy of the Picts as well as the Saxons, who had been invited over by the South Britons to assist them against the northern barbarians. These Saxons, we know, very soon entered into alliance with those whom they came to repel, and between them the Britons south of the friths were eventually driven into the West, where for centuries they appear to have maintained an independent kingdom under the name of
- 82. Strathclyde, until ultimatelythey were incorporated with the Scots. [79] Although both the external and internal history of the Highlands during this period is much better known than in the case of the Roman period, still the materials are exceedingly scanty. Scottish historians, from Fordun and Boece downwards, made it their business to fill up from their own imaginations what is wanting, so that, until the simple-minded but acute Innes put it in its true light, the early history of Scotland was a mass of fable. Undoubtedly the two most momentous events of this period are the firm settlement in Argyle of a colony of Scots from Ireland and some of the neighbouring isles in 503,[80] and the conversion of the Northern Picts to Christianity by Columba about 563. At the time of the Roman abandonment of Britain the Picts were under the sway of a king or chieftain named Drust, son of Erp, concerning whom the only record remaining is, that he lived a hundred years and fought a hundred battles. In fact, little is known with certainty of the Pictish history for upwards of one hundred years after the departure of the Romans, although some ancient chronicles afford us lists of Pictish kings or princes, a chronological table of whom, from Drust downwards, will be found at the end of this chapter. The Pictish chronicle contains the names of thirty-six others who are said to have reigned before Drust, but these are generally regarded as almost entirely spurious. Before proceeding farther with the Pictish history, it may be proper to give a brief account of the settlement of the Irish Scots or Dalriads, as they are frequently called, in the Pictish territory. The time of the settlement of the Scots in present Scotland was for long a subject of disputation, the early Scottish historians, from a false and unscrupulous patriotism, having pushed it back for many centuries before its actual occurrence. This dispute is now, however, fairly set at rest, there being no foundation for believing that the Scots found their way from Ireland to Scotland earlier than a century
- 83. Welcome to ourwebsite – the perfect destination for book lovers and knowledge seekers. We believe that every book holds a new world, offering opportunities for learning, discovery, and personal growth. That’s why we are dedicated to bringing you a diverse collection of books, ranging from classic literature and specialized publications to self-development guides and children's books. More than just a book-buying platform, we strive to be a bridge connecting you with timeless cultural and intellectual values. With an elegant, user-friendly interface and a smart search system, you can quickly find the books that best suit your interests. Additionally, our special promotions and home delivery services help you save time and fully enjoy the joy of reading. Join us on a journey of knowledge exploration, passion nurturing, and personal growth every day! ebookbell.com