We're always interested in getting feedback. E-mail us if you like this guide, if you think that important material is omitted, if you encounter errors in the code examples or in the documentation, if you find any typos, or generally just if you feel like e-mailing. Mail to Frank Brokken or use an e-mail form. Please state the concerned document version, found in the title.
In this chapter the usage of C++ is further explored. The possibility to
declare functions in struct
s is further illustrated using examples. The
concept of a class
is introduced.
::
is described first. This operator can be
used in situations where a global variable exists with the same name as a
local variable:
#include <stdio.h> int counter = 50; // global variable int main() { for (register int counter = 1; // this refers to the counter < 10; // local variable counter++) { printf("%d\n", ::counter // global variable / // divided by counter); // local variable } return (0); }
In this code fragment the scope operator is used to address a global variable
instead of the local variable with the same name. The usage of the scope
operator is more extensive than just this, but the other purposes will be
described later.
cout
, analogous to stdout
,
cin
, analogous to stdin
,
cerr
, analogous to stderr
.
Syntactically these streams are not used with functions: instead, data are
read from the streams or written to them using the operators <<
, called
the insertion operator and >>
, called the extraction operator.
This is illustrated in the example below:
#include <iostream> void main() { int ival; char sval[30]; cout << "Enter a number:" << endl; cin >> ival; cout << "And now a string:" << endl; cin >> sval; cout << "The number is: " << ival << endl << "And the string is: " << sval << endl; }
This program reads a number and a string from the cin
stream (usually the
keyboard) and prints these data to cout
. Concerning the streams and their
usage we remark the following:
iostream
.
cout
, cin
and cerr
are in fact `objects'
of a given class (more on classes later), processing the input and
output of a program. Note that the term `object', as used here, means the
set of data and functions which defines the item in question.
cin
reads data and copies the information to
variables (e.g., ival
in the above example) using the extraction
operator >>
. We will describe later how operators in C++
can perform quite different actions than what they are defined to do by the
language grammar, such as is the case here. We've seen function
overloading. In C++ operators can also have multiple
definitions, which is called operator overloading.
cin
, cout
and cerr
(i.e., >>
and <<
) also manipulate variables of
different types. In the above example cout << ival
results in the
printing of an integer value, whereas cout << "Enter a number"
results in the printing of a string. The actions of the operators
therefore depend on the type of supplied variables.
cout
is realized by inserting the
endl
symbol, rather than using the string "\n"
.
The streams cin
, cout
and cerr
are in fact not part of the C++
grammar, as defined in the compiler which parses source files. The streams are
part of the definitions in the header file iostream
. This is comparable
to the fact that functions as printf()
are not part of the C grammar,
but were originally written by people who considered such functions handy and
collected them in a run-time library.
Whether a program uses the old-style functions like printf()
and
scanf()
or whether it employs the new-style streams is a matter of taste.
Both styles can even be mixed. A number of advantages and disadvantages is
given below:
C
functions printf()
and
scanf()
, the usage of the insertion and extraction operators
is more type-safe
.
The format strings which are used with printf()
and
scanf()
can define wrong format specifiers for their arguments,
for which the compiler sometimes can't warn. In contrast, argument
checking with cin
, cout
and cerr
is performed
by the compiler. Consequently it isn't possible to err by providing an
int
argument in places where, according to the format string, a string
argument should appear.
printf()
and scanf()
, and other
functions which use format strings, in fact implement a mini-language
which is interpreted at run-time. In contrast, the C++
compiler
knows exactly which
in- or output action to perform given which
argument.
C++
.
Again, it requires a little getting used to, coming from C,
but after that these overloaded operators feel rather comfortably.
The iostream library has a lot more to offer than just cin, cout
and
cerr
. In chapter 11 iostreams will be covered in greater
detail.
const
very often occurs in C++ programs, even though it
is also part of the C grammar, where it's much less used.
This keyword is a modifier which states that the value of a variable or of an
argument may not be modified. In the below example an attempt is made to
change the value of a variable ival
, which is not legal:
int main() { int const // a constant int.. ival = 3; // initialized to 3 ival = 4; // assignment leads // to an error message return (0); }
This example shows how ival
may be initialized to a given value in its
definition; attempts to change the value later (in an assignment) are not
permitted.
Variables which are declared const
can, in contrast to C, be used as
the specification of the size of an array, as in the following example:
int const size = 20; char buf[size]; // 20 chars big
A further usage of the keyword const
is seen in the declaration of
pointers, e.g., in pointer-arguments. In the declaration
char const *buf;
buf
is a pointer variable, which points to char
s. Whatever is
pointed to by buf
may not be changed: the char
s are declared as
const
. The pointer buf
itself however may be changed. A statement as
*buf = 'a';
is therefore not allowed, while buf++
is.
In the declaration
char *const buf;
buf
itself is a const
pointer which may not be changed. Whatever
char
s are pointed to by buf
may be changed at will.
Finally, the declaration
char const *const buf;
is also possible; here, neither the pointer nor what it points to may be
changed.
The rule of thumb for the placement of the keyword const
is the
following: whatever occurs just prior to the keyword may not be changed.
The definition or declaration in which const
is used should be read
from the variable or function identifier back to the type indentifier:
``Buf is a const pointer to const characters''This rule of thumb is especially handy in cases where confusion may occur. In examples of C++ code, one often encounters the reverse:
const
preceding what should not be altered. That this may result in sloppy
code is indicated by our second example above:
char const *buf;
What must remain constant here? According to the sloppy interpretation, the
pointer cannot be altered (since const
precedes the pointer-*). In fact,
the charvalues are the constant entities here, as will be clear when it is
tried to compile the following program:
int main() { char const *buf = "hello"; buf++; // accepted by the compiler *buf = 'u'; // rejected by the compiler return (0); }
Compilation fails on the statement *buf = 'u';
, not on the statement
buf++
.
int int_value; int &ref = int_value;
In the above example a variable int_value
is defined. Subsequently a
reference ref
is defined, which due to its initialization addresses the
same memory location which int_value
occupies. In the definition of
ref
, the reference operator &
indicates that ref
is not
itself an integer but a reference to one. The two statements
int_value++; // alternative 1 ref++; // alternative 2
have the same effect, as expected. At some memory location an int
value
is increased by one --- whether that location is called int_value
or
ref
does not matter.
References serve an important function in C++ as a means to pass arguments
which can be modified (`variable arguments' in Pascal-terms). E.g., in
standard C, a function which increases the value of its argument by five
but which returns nothing (void
), needs a pointer argument:
void increase(int *valp) // expects a pointer { // to an int *valp += 5; } int main() { int x; increase(&x) // the address of x is return (0); // passed as argument }
This construction can also be used in C++ but the same effect
can be achieved using a reference:
void increase(int &valr) // expects a reference { // to an int valr += 5; } int main() { int x; increase(x); // a reference to x is return (0); // passed as argument }
The way in which C++ compilers implement references is actually by
using pointers: in other words, references in C++ are just ordinary
pointers, as far as the compiler is concerned. However, the programmer does
not need to know or to bother about levels of indirection. (Compare
this to the Pascal way: an argument which is declared as var
is in fact
also a pointer, but the programmer needn't know.)
It can be argued whether code such as the above is clear: the statement
increase
(x)
in the main()
function suggests that not x
itself but a copy is passed. Yet the value of x
changes because of
the way increase()
is defined.
Our suggestions for the usage of references as arguments to functions are
therefore the following:
void some_func(int val) { printf("%d\n", val); } int main() { int x; some_func(x); // a copy is passed, so return (0); // x won't be changed }
void by_pointer(int *valp) { *valp += 5; } void by_reference(int &valr) { valr += 5; } int main () { int x; by_pointer(&x); // a pointer is passed by_reference(x); // x is altered by reference return (0); // x might be changed }
struct
, is passed as argument, or is returned from the function.
In these cases the copying operations tend to become
significant factors when the entire structure must be copied, and it is
preferred to use references. If the argument isn't changed by the
function, or if the caller shouldn't change the returned information,
the use of the const
keyword is appropriate and should be used.
Consider the following example:
struct Person // some large structure { char name [80], address [90]; double salary; }; Person person[50]; // database of persons void printperson (Person const &p) // printperson expects a { // reference to a structure printf ("Name: %s\n" // but won't change it "Address: %s\n", p.name, p.address); } Person const &getperson(int index) // get a person by indexvalue { ... return (person[index]); // a reference is returned, } // not a copy of person[index] int main () { Person boss; printperson (boss); // no pointer is passed, // so variable won't be // altered by function printperson(getperson(5)); // references, not copies // are passed here return (0); }
References also can lead to extremely `ugly' code. A function can also return
a reference to a variable, as in the following example:
int &func() { static int value; return (value); }
This allows the following constructions:
func() = 20; func() += func ();
It is probably superfluous to note that such constructions should not normally
be used. Nonetheless, there are situations where it is useful to return a
reference. Even though this is discussed later, we have seen an example
of this phenomenon at our previous discussion of the iostreams. In a
statement like cout << "Hello" << endl;
, the insertion operator returns
a reference to cout
. So, in this statement first the "Hello"
is
inserted into cout
, producing a reference to cout
. Via this reference
the endl
is then inserted in the cout
object, again producing a
reference to cout
. This latter reference is not further used.
A number of differences between pointers and references is pointed out in the
list below:
int &ref;
is not allowed; what would ref
refer to?
external
.
These references were initialized elsewhere.
&
is used with a reference,
the expression yields the address of the variable to which the reference
applies. In contrast, ordinary pointers are variables themselves, so the
address of a pointer variable has nothing to do with the address of the
variable pointed to.
struct
s (see
section 2.5.16). Such functions are called member
functions or methods.
This section discusses the actual definition of such functions.
The code fragment below illustrates a struct
in which data fields for a
name and address are present. A function print()
is included in the
struct
definition:
struct person { char name [80], address [80]; void print (void); };
The member function print()
is defined using the structure name
(person
) and the scope resolution operator (::
):
void person::print() { printf("Name: %s\n" "Address: %s\n", name, address); }
In the definition of this member function, the function name is preceded by
the struct
name followed by ::
. The code of the function shows how
the fields of the struct
can be addressed without using the type name: in
this example the function print()
prints a variable name
. Since
print()
is a part of the struct
person
, the variable name
implicitly refers to the same type.
The usage of this struct
could be, e.g.:
person p; strcpy(p.name, "Karel"); strcpy(p.address, "Rietveldlaan 37"); p.print();
The advantage of member functions lies in the fact that the called function
can automatically address the data fields of the structure for which it was
invoked. As such, in the statement p.print()
the structure p
is the
`substrate': the variables name
and address
which are used in the
code of print()
refer to the same struct p
.
void, char, short,
int, long, float
and double
. C++ extends these five basic types with
several extra types: the types bool, wchar_t
and long double
. The type
long double
is merely a double-long double
datatype. Apart from these
basic types a standard type string
is available. The datatypes bool
,
wchar_t
and string
are covered in the following sections.
void, char, int,
float
and double
. C++ extends these five basic types with several
extra types. In this section the type bool
is introduced.
The type bool
represents boolean (logical) values, for which the
(now reserved) values true
and false
may be used. Apart from these
reserved values, integral values may also be assigned to variables of type
bool
, which are implicitly converted to true
and false
according
to the following conversion rules (assume intValue
is an int
-variable,
and boolValue
is a bool
-variable):
// from int to bool: boolValue = intValue ? true : false; // from bool to int: intValue = boolValue ? 1 : 0;Furthermore, when
bool
values are inserted into, e.g., cout
, then
1
is written for true
values, and 0
is written for false
values. Consider the following example:
cout << "A true value: " << true << endl << "A false value: " << false << endl;
The bool
data type is found in other programming languages as
well. Pascal has its type Boolean
, and Java has a boolean
type. Different from these languages, C++'s type bool
acts like a kind
of int
type: it's primarily a documentation-improving type, having just two
values true
and false
. Actually, these values can be interpreted as
enum
values for 1
and 0
. Doing so would neglect the philosophy
behind the bool
data type, but nevertheless: assigning true
to an
int
variable neither produces warnings nor errors.
Using the bool
-type is generally more intuitively clear than using
int
. Consider the following prototypes:
bool exists(char const *fileName); // (1) int exists(char const *fileName); // (2)For the first prototype
(1)
, most people will expect the function to
return true
if the given filename is the name of an existing
file. However, using the second prototype some ambiguity arises: intuitively
the returnvalue 1 is appealing, as it leads to constructions like
if (exists("myfile")) cout << "myfile exists";On the other hand, many functions (like
access(), stat(),
etc.) return
0
to indicate a successful operation, reserving other values to indicate
various types of errors.
As a rule of thumb we suggest the following: If a function should inform its
caller about the success or failure of its task, let the function return a
bool
value. If the function should return success or various types of
errors, let the function return enum values, documenting the situation
when the function returns. Only when the function returns a meaningful
integral value (like the sum of two int
values), let the function return
an int
value.
wchar_t
type is an extension of the char
basic type, to accomodate
wide character values, such as the Unicode character set.
Sizeof(wchar_t)
is 2, allowing for 65,536 different character values.
Note that a programming language like Java has a data type char
that
is comparable to C++'s wchar_t
type, while Java's byte
data
type is comparable to C++'s char
type. Very convenient....
Among the facilities C++ programmers have developed over and over again
(as reflected in the Annotations) are those for manipulating chunks of text,
commonly called strings. The C programming language offers rudimentary
string support: the ascii-z terminated series of characters is the
foundation on which a large amount of code has been built.
Standard C++ now offers a string
type of its own. In order to use
string
-type objects, the header file string
must be included in
sources.
Actually, string
objects are class type variables, and the class
is introduced for the first time in chapter 4. However, in order to
use a string, it is not necessary to know what a class is. In this section the
operators that are available for strings and some other operations are
discussed. The operations that can be performed on strings take the form
stringVariable.operation(argumentList)
For example, if string1
and string2
are variables of type string
,
then
string1.compare(string2)
can be used to compare both strings. A function like compare()
, which is
part of the string
-class is called a memberfunction. The string
class
offers a large number of these memberfunctions, as well as extensions of some
well-known operators, like the assignment (=
) and the comparison operator
(==
). These operators and functions are discussed in the following
sections.
3.3.3.1: Operations on strings
Some of the operations that can be performed on strings return indices within
the strings. Whenever such an operation fails to find an appropriate index,
the value string::npos
is returned. Other operations return size_type
returnvalues, which is (for all practical purposes) an int
. In all
operations where string
objects can be used as arguments, char const *
strings can be used as well.
Some string
-memberfunctions use iterators. Iterators will be covered
in section 10.1. The memberfunctions that use iterators are listed
in the next section (3.3.3.2), they are not further illustrated
below.
The following operations can be performed on strings:
ascii-z
string, another string
object, or an implicit initialization
can be used. In the example, note that the implicit initialization does not
have an argument, and does not use the function argumentlist notation.
#include <string> int main() { string stringOne("Hello World"), // using plain ascii-Z stringTwo(stringOne), // using another string object stringThree; // implicit initialization to "" // do not use: stringThree(); return (0); }
=
operator can be used, which takes both a string
object and a C-style characterstring as its right-hand argument:
#include <string> int main() { string stringOne("Hello World"), stringTwo; stringTwo = stringOne; // assign stringOne to stringTwo stringTwo = "Hello world"; // assign a C-string to StringTwo return (0); }
string
-object. The reverse conversion (converting a
string
object to a standard C-string is not performed
automatically. In order to obtain the C
-string that is stored within the
string
object itself, the memberfunction c_str()
, which returns a
char const *
, can be used:
#include <iostream> #include <string> int main() { string stringOne("Hello World"); char const *Cstring = stringOne.c_str(); cout << Cstring << endl; return (0); }
[]
) is available,
but not the pointer dereferencing operator (*
). The subscript operator
does not perform range-checking. If range-checking is required, the at()
memberfunction can be used instead of the subscript-operator:
#include <string> int main() { string stringOne("Hello World"); stringOne[6] = 'w'; // now "Hello world" if (stringOne[0] == 'H') stringOne[0] = 'h'; // now "hello world" // THIS WON'T COMPILE: // *stringOne = 'H'; // Now using the at() memberfunction: stringOne.at(6) = stringOne.at(0); // now "Hello Horld" if (stringOne.at(0) == 'H') stringOne.at(0) = 'W'; // now "Wello Horld" return (0); }
==, !=, <, <=, >
and >=
operators or the compare()
memberfunction
can be used. The compare()
memberfunction comes in different flavors, the
plain one (having another string
object as argument) offers a bit more
information than the operators do. The returnvalue of the compare()
memberfunction may be used for lexicographical ordering: a negative value is
returned if the string stored in the string object using the compare()
memberfunction (in the example: stringOne
) is located earlier in the
alphabet (based on the standard ascii-characterset) than the string stored in
the string object passed as argument to the compare()
memberfunction.
#include <iostream> #include <string> int main() { string stringOne("Hello World"), stringTwo; if (stringOne != stringTwo) stringTwo = stringOne; if (stringOne == stringTwo) stringTwo = "Something else"; if (stringOne.compare(stringTwo) > 0) cout << "stringOne after stringTwo in the alphabet\n"; else if (stringOne.compare(stringTwo) < 0) cout << "stringOne before stringTwo in the alphabet\n"; else cout << "Both strings are the same"; // Alternatively: if (stringOne > stringTwo) cout << "stringOne after stringTwo in the alphabet\n"; else if (stringOne < stringTwo) cout << "stringOne before stringTwo in the alphabet\n"; else cout << "Both strings are the same"; return (0); }There is no readily available case insensitive comparison function. Alternative forms of the
compare()
memberfunction have one or
two extra arguments. The first extra argument is an index position in the
string
-object calling the compare()
memberfunction. It indicates the
index position where the comparison should start. The second argument refers
to the string that is passed as argument to the compare memberfunction. It
indicates the number of characters of that string that should be used in the
comparison.
Note, however, that the compare()
memberfunction is not an alternative to
the standard C strncmp()
function: the string stored in the
string
-object calling the compare()
memberfunction is compared from a
possible offset position to the end of that string with another string,
possibly using only an initial substring of the other string. The
strncmp()
function, on the other hand, compares only the first n
characters of the two strings. See the following example for further details
about the compare()
function.
#include <iostream> #include <string> int main() { string stringOne("Hello World"); // comparing from a certain offset in stringOne if (!stringOne.compare("ello World", 1)) cout << "comparing 'Hello world' from index 1" " to 'ello World': ok\n"; // comparing from a certain offset in stringOne over a certain // number of characters in "World and more" if (!stringOne.compare("World and more", 6, 5)) cout << "comparing 'Hello World' from index 6 over 5 positions" " to 'World and more': ok\n"; // The same, but this fails, as all of the chars in stringOne // starting at index 6 are compared, not just 3 chars. // number of characters in "World and more" if (!stringOne.compare("World and more", 6, 3)) cout << "comparing 'Hello World' from index 6 over 3 positions" " to 'World and more': ok\n"; else cout << "Unequal (sub)strings\n"; return (0); }
string
can be appended to another string. For this the +=
operator can be used, as well as the append()
memberfunction. Within an
expression the +
operator can be used as well to append two strings:
#include <iostream> #include <string> int main() { string stringOne("Hello"), stringTwo("World"); stringOne += " " + stringTwo; stringOne = "hello"; stringOne.append(" world"); // append only 5 characters: stringOne.append(" ok. >This is not used<", 5); cout << stringOne << endl; string stringThree("Hello"); // append " World": stringThree.append(stringOne, 5, 6); cout << stringThree << endl; return (0); }The
+
operator can be used in cases where the left-hand term of the +
operator is a string object and the right-hand term is a string
object, a
char const *
value or a char
. Like the compare()
function, the
append()
memberfunction may have two extra arguments. The first argument
is the string to be appended, the second argument specifies the index position
of the first character that will be appended. The third argument specifies the
number of characters that will be appended.
If the first argument is of type char const *
, only a second argument may
be specified. The second argument then specifies the number of characters
of the first argument that are appended to the string
object.
append()
memberfunction is used to append characters at
the end of a string
. However, it is also possible to insert characters
somewhere within a string
. For this the memberfunction insert()
is
available.
The insert()
memberfunction has at least two, and up to four arguments.
The first argument is the offset in the calling string
object where a
string should be inserted. The second argument is the string to be inserted
itself, the third argument specifies the index position of the first character
in the provided string
-argument that will be inserted. The fourth
argument specifies the number of characters that will be inserted.
If the first argument is of type char const *
, the fourth argument is not
available. In this case, the third argument indicates the number of characters
of the provided char const *
value that will be inserted.
#include <iostream> #include <string> int main() { string stringOne("Hell ok."); stringOne.insert(4, "o "); // Insert "o " at position 4 string world("The World of C++"); // insert "World" into stringOne stringOne.insert(6, world, 4, 5); cout << "Guess what ? It is: " << stringOne << endl; return (0); }Several other variants of
insert()
are available. See section
3.3.3.2 for details.
replace()
can be used. The memberfunction has at
least three and possibly five arguments. Usually (see section
3.3.3.2 for overloaded versions of replace()
) the first
argument indicates the position of the first character that must be replaced
and the second argument gives the number of characters that must be
replaced. Then, the third argument defines the replacement text (a string
or char const *
). The fourth and fifth arguments are optional. When
specified, the fourth argument specifies the index position of the first
character in the provided string
-argument that will be inserted. In that
case the fifth argument can be used to specify the number of characters that
will be inserted.
If the third argument is of type char const *
, the fifth argument is not
available. In this case, the fourth argument indicates the number of
characters of the provided char const *
value that will be inserted. The
example shows a very simple filechanger: it reads lines from cin
, and
replaces occurrences of a `searchstring' by a `replacestring'. Simple tests
for the correct number of arguments and the contents of the provided strings
(they should be unequal) are implemented using the assert()
macro.
#include <iostream> #include <string> #include <cassert> int main(int argc, char **argv) { assert(argc == 3 && "Usage: <searchstring> <replacestring> to process stdin"); string line, search(argv[1]), replace(argv[2]); assert(search != replace); while (getline(cin, line)) { while (true) { string::size_type idx; idx = line.find(search); if (idx == string::npos) break; line.replace(idx, search.size(), replace); } cout << line << endl; } return (0); }
swap()
swaps the contents of two string
-objects. For example:
#include <iostream> #include <string> int main() { string stringOne("Hello"), stringTwo("World"); cout << "Before: stringOne: " << stringOne << ", stringTwo: " << stringTwo << endl; stringOne.swap(stringTwo); cout << "After: stringOne: " << stringOne << ", stringTwo: " << stringTwo << endl; return (0); }
erase()
is available. The standard
form has two optional arguments. The first argument may be used to specify the
offset of the first character that must be erased. If specified, an optional
second argument may be used to specify the number of characters that are to be
erased. If no arguments are specified, the stored string is erased completely.
The first See section 3.3.3.2 for overloaded functions. An example
of the use of erase()
is given below:
#include <string> int main() { string stringOne("Hello Cruel World"); stringOne.erase(5, 6); cout << stringOne << endl; stringOne.erase(); cout << "'" << stringOne << "'\n"; return (0); }
string
the memberfunction find()
can
be used. This function looks for the string that is provided as its first
argument in the string
object calling find()
and returns the index of
the first character of the substring if found. The memberfunction rfind()
looks for the substring from the end of the string
object back to its
beginning. An example using find()
was given earlier.
string
object, the memberfunction
substr()
is available. The returned string
object contains a copy of
the substring in the string
-object calling substr()
The memberfunction
has two optional arguments: the first argument may be used to specify the
offset of the first character to be returned. If the first argument is
specified, the second argument may be used to specify the number of characters
that are to be returned. For example:
#include <string> int main() { string stringOne("Hello World"); cout << stringOne.substr(0, 5) << endl << stringOne.substr(6) << endl << stringOne.substr() << endl; return (0); }
find()
is used to locate a substring, the functions
find_first_of(), find_first_not_of(), find_last_of()
and
find_last_not_of()
can be used to find sets of characters. The following
program reads a line of text from the standard input stream, and displays the
substrings starting at the first vowel, starting at the last vowel, and not
starting at the first digit:
#include <string> int main() { string line; getline(cin, line); string::size_type pos; cout << "Line: " << line << endl << "Starting at the first vowel:\n" << "'" << ( (pos = line.find_first_of("aeiouAEIOU")) != string::npos ? line.substr(pos) : "*** not found ***" ) << "'\n" << "Starting at the last vowel:\n" << "'" << ( (pos = line.find_last_of("aeiouAEIOU")) != string::npos ? line.substr(pos) : "*** not found ***" ) << "'\n" << "Not starting at the first digit:\n" << "'" << ( (pos = line.find_first_not_of("1234567890")) != string::npos ? line.substr(pos) : "*** not found ***" ) << "'\n"; return (0); }
size()
memberfunction, which, like the standard C function
strlen()
does not include the terminating ascii-Z character. For example:
#include <iostream> #include <string> int main() { string stringOne("Hello World"); cout << "The length of the stringOne string is " << stringOne.size() << " characters\n"; return (0); }
resize()
can be used to make it longer or shorter.
size()
memberfunction can be used to determine whether a
string holds no characters as well. Alternatively, the empty()
memberfunction can be used:
#include <iostream> #include <string> int main() { string stringOne; cout << "The length of the stringOne string is " << stringOne.size() << " characters\n" "It is " << (stringOne.empty() ? "" : " not ") << "empty\n"; stringOne = ""; cout << "After assigning a \"\"-string to a string-object\n" "it is " << (stringOne.empty() ? "also" : " not") << " empty\n"; return (0); }
istream &getline(istream instream, string target, char
delimiter)
memberfunction may be used to read a line of text (up to
the first delimiter or the end of the stream) from instream
. The delimiter
has a default value '\n'
. It is removed from instream
, but it is not
stored in target
. The function getline()
was used in several earlier
examples (e.g., with the replace() memberfunction).
3.3.3.2: Overview of operations on strings
In this section the available operations on strings are summarized. There are
four subparts here: the string
-initializers, the string
-iterators, the
string
-operators and the string
-memberfunctions. The memberfunctions
are ordered alphabetically by the name of the operation. Below, the target
object is a string
-object. The source
object is either a string
or
a char const *
, unless overloaded versions tailored to string
and
char const *
parameters are explicitly mentioned.
With memberfunctions the types of the parameters are given in a
function-prototypical way. With several memberfunctions iterators are
used. At this point in the Annotations it's a bit premature to discuss
iterators, but for referential purposes they have to be mentioned
nevertheless. So, a forward reference is used here: see section 10.1
for a more detailed discussion of iterators.
Finally, all string
-memberfunctions returning indices in the target
string return the predefined constant string::pos
if no suitable index
could be found.
string
-initializers:
string target
: Initializes target
to an empty string.
string target(size_type n, char c)
: Initializes target
with
n
characters c
.
string target(string source)
: Initializes target
with
source
.
string target(string source, size_type idx, size_type n =
pos)
: Initializes target
with source
, using n
characters of
source
, starting at index idx
.
string target(InputIterator begin, InputIterator end)
:
Initializes target
with the range of characters implied by the provided
InputIterators
.
string
-iterators:
See section 10.1 for details about iterators).
begin()
end()
rbegin()
rend()
string
-operators:
target = source
. Assignment of a source
to target
. May
also be used for initializing string
objects.
target = c
. Assignment of char c
to target
. May
not be used for initializing string
objects.
target += source
. Appends source
to target
. Source
may also be a char
value.
target + source
. Within expressions, strings
may be
added. The right-hand term may be a string
object, a char const *
value or a char
value.
target[size_type pos]
. The subscript-operator may be used to
assign individual characters of target
or to retrieve these
characters. There is no range-checking.
target == source
. The equality operator may be used to compare a
string
object to another string
or char const *
value. The
operator !=
is available as well.
target < source
. The less-than operator may be used to compare
the ordering within the Ascii-character set of target
and source
. The
operators <=, >, >=
are available as well.
ostream destination << target
. The insertion-operator may be used
with string
objects.
istream destination >> target
. The extraction-operator may be used
with string
objects.
string
memberfunctions:
char &target.at(size_type pos)
: The character (reference) at the
indicated position is returned (it may be reassigned). The memberfunction
performs range-checking.
string &target.append(InputIterator begin, InputIterator end)
: Using
this memberfunction the range of characters implied by the begin
and end
InputIterators
are appended to append
.
string &target.append(string source, size_type pos = 0; size_type n =
npos)
:
source
is given, it is appended to target
.
pos
is specified as well, source
is appended from
index position pos
until the end of source
.
n
characters of
source
, starting at index position pos
are appended to target
.
source
is of type char const *
, no parameter pos
is available.
So, with char const *
arguments, either all characters or an initial
subset of the characters of the provided char const *
argument are
appended to target
.
string &target.append(size_type n, char c)
: Using this memberfunction,
n
characters c
can be appended to target
.
string &target.assign(string source, size_type pos = 0; size_type n =
npos)
:
source
is given, it is assigned to target
.
pos
is specified as well, target
is assigned from
index position pos
until the end of source
.
n
characters of
source
, starting at index position pos
are assigned to target
.
source
is of type char const *
, no parameter pos
is available.
So, with char const *
arguments, either all characters or an initial
subset of the characters of the provided char const *
argument are
assigned to target
.
string &target.assign(size_type n, char c)
: Using this memberfunction,
n
characters c
can be assigned to target
.
size_type target.capacity()
: returns the number of characters that can
currently be stored inside target
.
int target.compare(string source, size_type pos, size_type n)
: This
memberfunction may be used to compare (according to the ascii-character set)
the strings stored in target
and source
. The parameter n
may be
used to specify the number of characters in source
that are used in the
comparison, the parameter pos
may be used to specify the initial character
in target
that is used in the comparison.
char const *target.c_str
: the memberfunction returns the contents of
target
as a C-string (used to assign the string stored in target
to a char const *
).
char const *target.data()
: returns the raw text stored in target
.
bool target.empty()
: returns true
if target
contains no data.
string &target.erase(size_type pos; size_type n)
. This
memberfunction can be used to erase (a sub)string of target
. The basic form
erases target
completely. The working of other forms of
erase()
depend on the specification of extra arguments:
pos
is specified, the contents of target
are erased
from index position pos
until the end of source
.
pos
and n
are provided, n
characters of
target
, starting at index position pos
are erased.
iterator target.erase(iterator p)
: The contents of target
are
erased until (iterator) position p
. The iterator p
is
returned.
iterator target.erase(iterator f, iterator l)
: The range of
characters of target
, implied by the iterators f
and l
are erased.
The iterator f
is returned.
size_type target.find(string source, size_type pos)
: This memberfunction
returns the index in target
where source
is found. If the argument
pos
is omitted, the search starts at the beginning of target
. If
provided, it refers to the index in target
where the search for source
should start.
size_type target.find(char const *source, size_type pos, size_type
n)
: This memberfunction returns the index in target
where source
is
found. The parameter n
indicates the number of characters of source
that should be used in the search: it defines a partial string starting at the
beginning of source
. If omitted, all characters in source
are used.
The parameter pos
refers to the index in
target
where the search for source
should start. If the parameter
pos
is omitted as well, all of target
is scanned.
size_type target.find(char c, size_type pos)
: This memberfunction
returns the index in target
where c
is found. If the argument
pos
is omitted, the search starts at the beginning of target
. If
provided, it refers to the index in target
where the search for source
should start.
size_type target.find_first_of(string source, size_type pos)
: This
memberfunction returns the index in target
where any character in source
is found. If the argument pos
is omitted, the search starts at the
beginning of target
. If provided, it refers to the index in target
where the search for source
should start.
size_type target.find_first_of(char const* s, size_type pos, size_type
n)
: This memberfunction returns the index in target
where any character of
source
is found. The parameter n
indicates the number of characters
of source
that should be used in the search: it defines a partial string
starting at the beginning of source
. If omitted, all characters in
source
are used. The parameter pos
refers to the index in target
where the search for source
should start. If the parameter pos
is
omitted as well, all of target
is scanned.
size_type target.find_first_of(char c, size_type pos)
: This
memberfunction returns the index in target
where character c
is found. If the argument pos
is omitted, the search starts at the
beginning of target
. If provided, it refers to the index in target
where the search for source
should start.
size_type target.find_first_not_of(string source, size_type pos)
:
This memberfunction returns the index in target
where any character not
appearing in source
is found. If the argument pos
is omitted, the
search starts at the beginning of target
. If provided, it refers to the
index in target
where the search for source
should start.
size_type target.find_first_not_of(char const* s, size_type pos,
size_type n)
: This memberfunction returns the index in target
where any
character not appearing in source
is found. The parameter n
indicates
the number of characters of source
that should be used in the search: it
defines a partial string starting at the beginning of source
. If omitted,
all characters in source
are used. The parameter pos
refers to the
index in target
where the search for source
should start. If the
parameter pos
is omitted as well, all of target
is scanned.
size_type target.find_first_not_of(char c, size_type pos)
: This
memberfunction returns the index in target
where another character than c
is found. If the argument pos
is omitted, the search starts at the
beginning of target
. If provided, it refers to the index in target
where the search for source
should start.
size_type target.find_last_of(string source, size_type pos)
: This
memberfunction returns the last index in target
where any character in
source
is found. If the argument pos
is omitted, the search starts at
the beginning of target
. If provided, it refers to the index in target
where the search for source
should start.
size_type target.find_last_of(char const* s, size_type pos, size_type
n)
: This memberfunction returns the last index in target
where any character of
source
is found. The parameter n
indicates the number of characters
of source
that should be used in the search: it defines a partial string
starting at the beginning of source
. If omitted, all characters in
source
are used. The parameter pos
refers to the index in target
where the search for source
should start. If the parameter pos
is
omitted as well, all of target
is scanned.
size_type target.find_last_of(char c, size_type pos)
: This
memberfunction returns the last index in target
where character c
is found. If the argument pos
is omitted, the search starts at the
beginning of target
. If provided, it refers to the index in target
where the search for source
should start.
size_type target.find_last_not_of(string source, size_type pos)
: This
memberfunction returns the last index in target
where any character not
appearing in source
is found. If the argument pos
is omitted, the
search starts at the beginning of target
. If provided, it refers to the
index in target
where the search for source
should start.
size_type target.find_last_not_of(char const* s, size_type pos,
size_type n)
: This memberfunction returns the last index in target
where
any character not appearing in source
is found. The parameter n
indicates the number of characters of source
that should be used in the
search: it defines a partial string starting at the beginning of
source
. If omitted, all characters in source
are used. The parameter
pos
refers to the index in target
where the search for source
should start. If the parameter pos
is omitted as well, all of target
is scanned.
size_type target.find_last_not_of(char c, size_type pos)
: This
memberfunction returns the last index in target
where another character than
c
is found. If the argument pos
is omitted, the search starts at the
beginning of target
. If provided, it refers to the index in target
where the search for source
should start.
istream &getline(istream instream, string target, char delimiter)
.
This memberfunction can be used to read a line of text (up to the first
delimiter or the end of the stream) from instream
. The delimiter has a
default value '\n'
. It is removed from instream
, but it is not stored
in target
.
string &target.insert(size_type t_pos, string source, size_type pos;
size_type n)
. This memberfunction can be used to insert (a sub)string of
source
into target
, at target
's index position t_pos
. The
basic form inserts source
completely at index t_pos
. The working of
other forms of insert()
depend on the specification of extra arguments:
pos
is specified, source
is inserted from
index position pos
until the end of source
.
pos
and n
are provided, n
characters of
source
, starting at index position pos
are inserted into target
.
source
is of type char const *
, no parameter pos
is available.
So, with char const *
arguments, either all characters or an initial
subset of the characters of the provided char const *
argument are
inserted into target
.
string &target.insert(size_type t_pos, size_type n, char c)
:
Using this memberfunction, n
characters c
can be inserted to
target
.
iterator target.insert(iterator p, char c)
: The character c
is
inserted at the (iterator) position p
in target
. The iterator p
is
returned.
iterator target.insert(iterator p, size_type n, char c)
: There are
n
characters c
inserted at the (iterator) position p
in
target
. The iterator p
is returned.
iterator target.insert(iterator p, InputIterator first, InputIterator
last)
: The range of characters implied by the InputIterators first
and
last
are inserted at the (iterator) position p
in
target
. The iterator p
is returned.
size_type target.length()
: returns the number of characters
stored in target
.
size_type target.max_size()
: returns the maximum number of characters
that can be stored in target
.
string& target.replace(size_type pos1, size_type n1, const string
source, size_type pos2, size_type n2)
: The substring of n1
characters of
target
, starting at position pos1
is replaced by source
. If n1
is set to 0, the memberfunction inserts source
into target
.source
completely. The working of other forms of
replace()
depend on the specification of extra arguments:
pos2
is specified, source
is inserted from
index position pos2
until the end of source
.
pos2
and n2
are provided, n2
characters of
source
, starting at index position pos2
are inserted into target
.
source
is of type char const *
, no parameter pos2
is available.
So, with char const *
arguments, either all characters or an initial
subset of the characters of the provided char const *
argument are
replaced in target
.
string &target.replace(size_type pos, size_type n1, size_type n2,
char c)
: This memberfunction can be used to replace n1
characters of
target
, starting at index position pos
, by n2 c
-characters. The
argument n2
may be omitted, in which case the string to be replaced is
replaced by just one character c
.
string& target.replace (iterator i1, iterator i2, string source)
:
Here, the string implied by the iterators i1
and i2
are replaced by
the string str
. If source
is a char const *
, an extra argument
n
may be used, specifying the number of characters of source
that are
used in the replacement.
iterator target.replace(iterator f, iterator l, string source)
: The
range of characters of target
, implied by the iterators f
and l
are replaced by source
. If source
is a char const *
, an extra
argument n
may be used, specifying the number of characters of source
that are used in the replacement. The string target
is returned.
iterator target.replace(iterator f, iterator l, size_type n, char c)
:
The range of characters of target
, implied by the iterators f
and
l
are replaced by n c
-characters. The string target
is
returned.
string replace(iterator i1, iterator i2, InputIterator j1,
InputIterator j2)
: here the range of characters implied by the iterators
i1
and i2
is replaced by the range of characters implied by the
InputIterators j1
and j2
.
void target.resize(size_type n, char c)
: The string stored in
target
is resized to n
characters. The second argument is optional. If
provided and the string is enlarged, the extra characters are initialized to
c
.
size_type target.rfind(string source, size_type pos)
: This memberfunction
returns the index in target
where source
is found. Searching proceeds
from the end of target
back to the beginning. If the argument
pos
is omitted, the search starts at the beginning of target
. If
provided, it refers to the index in target
where the search for source
should start.
size_type target.rfind(char const *source, size_type pos, size_type
n)
: This memberfunction returns the index in target
where source
is
found. Searching proceeds from the end of target
back to the beginning.
The parameter n
indicates the number of characters of source
that should be used in the search: it defines a partial string starting at the
beginning of source
. If omitted, all characters in source
are used.
The parameter pos
refers to the index in
target
where the search for source
should start. If the parameter
pos
is omitted as well, all of target
is scanned.
size_type target.rfind(char c, size_type pos)
: This memberfunction
returns the index in target
where c
is found. Searching proceeds
from the end of target
back to the beginning. If the argument
pos
is omitted, the search starts at the beginning of target
. If
provided, it refers to the index in target
where the search for source
should start.
size_type size()
: returns the number of characters stored in
target
.
string target.substr(size_type pos, size_type n)
: This memberfunction
returns a substring of target
. The parameter n
may be used to specify
the number of characters of target
that are returned. The parameter
pos
may be used to specify the index of the first character of target
that is returned. Either n
or both arguments may be omitted.
size_type target.swap(string source)
: swaps the contents of the
source
and target
. In this case, source
cannot be a
char const *
.
C++ has two special keywords which are concerned with data hiding:
private
and public
. These keywords can be inserted in the definition
of a struct
. The keyword public
defines all subsequent fields of a
structure as accessible by all code; the keyword private
defines all
subsequent fields as only accessible by the code which is part of the
struct
(i.e., only accessible for the member functions) (Besides
public
and private
, C++ defines the keyword protected
.
This keyword is not often used and it is left for the reader to
explore.). In a struct
all fields are public
, unless
explicitly stated otherwise.
With this knowledge we can expand the struct
person
:
struct person { public: void setname (char const *n), setaddress (char const *a), print (void); char const *getname (void), *getaddress (void); private: char name [80], address [80]; };
The data fields name
and address
are only accessible for the member
functions which are defined in the struct
: these are the functions
setname()
, setaddress()
etc.. This property of the data type is
given by the fact that the fields name
and address
are preceded by
the keyword private
. As an illustration consider the following code
fragment:
person x; x.setname ("Frank"); // ok, setname() is public strcpy (x.name, "Knarf"); // error, name is private
The concept of data hiding is realized here in the following manner. The
actual data of a struct
person
are named only in the structure
definition. The data are accessed by the outside world by special functions,
which are also part of the definition. These member functions control all
traffic between the data fields and other parts of the program and are
therefore also called `interface' functions.
The data hiding which is thus realized is illustrated further in
figure 2.
Also note that the functions setname()
and setaddress()
are declared
as having a char const *
argument. This means that the
functions will not alter the strings which are supplied as their arguments.
In the same vein, the functions getname()
and getaddress()
return a
char const *
: the caller may not modify the strings which are
pointed to by the return values.
Two examples of member functions of the struct
person
are shown
below:
void person::setname(char const *n) { strncpy(name, n, 79); name[79] = '\0'; } char const *person::getname() { return (name); }
In general, the power of the member functions and of the concept of data
hiding lies in the fact that the interface functions can perform special
tasks, e.g., checks for the validity of data. In the above example
setname()
copies only up to 79 characters from its argument to the data
member name
, thereby avoiding array boundary overflow.
Another example of the concept of data hiding is the following. As an
alternative to member functions which keep their data in memory (as do the
above code examples), a runtime library could be developed with interface
functions which store their data on file. The conversion of a program which
stores person
structures in memory to one that stores the data on disk
would mean the relinking of the program with a different library.
Though data hiding can be realized with structs
, more often (almost
always) classes are used instead. A class
is in principle equivalent to a
struct
except that unless specified otherwise, all members (data or
functions) are private
. As far as private
and public
are
concerned, a class
is therefore the opposite of a struct
. The
definition of a class
person
would therefore look exactly as shown
above, except for the fact that instead of the keyword struct
, class
would be used. Our typographic suggestion for class names is a capital as
first character, followed by the remainder of the name in lower case (e.g.,
Person
).
struct
s are concerned. In C it is
common to define several functions to process a struct
, which then
require a pointer to the struct
as one of their arguments. A fragment
of an imaginary C header file is given below:
// definition of a struct PERSON_ typedef struct { char name[80], address[80]; } PERSON_; // some functions to manipulate PERSON_ structs // initialize fields with a name and address extern void initialize(PERSON_ *p, char const *nm, char const *adr); // print information extern void print(PERSON_ const *p); // etc..
In C++, the declarations of the involved functions are placed inside the
definition of the struct
or class
. The argument which denotes which
struct
is involved is no longer needed.
class Person { public: void initialize(char const *nm, char const *adr); void print(void); // etc.. private: char name[80], address[80]; };
The struct
argument is implicit in C++. A function call in C
like
PERSON_ x; initialize(&x, "some name", "some address");
becomes in C++:
Person x; x.initialize("some name", "some address");
cos(), sin(), tan()
etc. are to be used
accepting arguments in degrees rather than arguments in
radials. Unfortunately, the functionname cos()
is already in use, and that
function accepts radials as its arguments, rather than degrees.
Problems like these are normally solved by looking for another name, e.g., the
functionname cosDegrees()
is defined. C++ offers an alternative
solution by allowing namespaces to be defined: areas or regions in the
code in which identifiers are defined which cannot conflict with existing
names defined elsewhere.
namespace identifier { // declared or defined entities // (declarative region) }The identifier used in the definition of a namespace is a standard C++ identifier.
Within the declarative region, introduced in the above code example,
functions, variables, structs, classes and even (nested) namespaces can be
defined or declared. Namespaces cannot be defined within a block. So it is not
possible to define a namespace within, e.g., a function. However, it is
possible to define a namespace using multiple namespace
declarations. Namespaces are said to be open. This means that a namespace
CppAnnotations
could be defined in a file file1.cc
and also in a file
file2.cc
. The entities defined in the CppAnnotations
namespace of
files file1.cc
and file2.cc
are then united in one CppAnnotations
namespace region. For example:
// in file1.cc namespace CppAnnotations { double cos(double argInDegrees) { ... } } // in file2.cc namespace CppAnnotations { double sin(double argInDegrees) { ... } }Both
sin()
and cos()
are now defined in the same
CppAnnotations
namespace.
Namespace entities can also be defined outside of their namespaces. This
topic is discussed in section 3.6.4.1.
3.6.1.1: Declaring entities in namespaces
Instead of defiing entities in a namespace, entities may also be declared in a namespace. This allows us to put all the declarations of a namespace in a header file which can thereupon be included in sources in which the entities of a namespace are used. Such a header file could contain, e.g.,
namespace CppAnnotations { double cos(double degrees); double sin(double degrees); }
Namespaces can be defined without using a name. Such a namespace is anonymous and it restricts the usability of the defined entities to the source file in which the anonymous namespace is defined.
The entities that are defined in the anonymous namespace are accessible the
same way as static
functions and variables in C. The static
keyword can still be used in C++, but its use is more dominant in
class
definitions (see chapter 4). In situations where static
variables or functions are necessary, the use of the anonymous namespace is
preferred.
cos()
defined in the
CppAnnotations
namespace the following code could be used:
// assume the CppAnnotations namespace is declared in the next header // file: #include <CppAnnotations> int main() { cout << "The cosine of 60 degrees is: " << CppAnnotations::cos(60) << endl; return (0); }This is a rather cumbersome way to refer to the
cos()
function in the
CppAnnotations
namespace, especially so if the function is frequently
used.
Therefore, an abbreviated form (just cos()
can be used by
declaring that cos()
will refer to CppAnnotations::cos()
. For this,
the using
-declaration can be used. Following
using CppAnnotations::cos; // note: no function prototype, just the // name of the entity is required.the function
cos()
will refer to the cos()
function in the
CppAnnotations
namespace. This implies that the standard cos()
function, accepting radials, cannot be used automatically anymore. The plain
scope resolution operator can be used to reach the generic cos()
function:
int main() { using CppAnnotations::cos; ... cout << cos(60) // this uses CppAnnotations::cos() << ::cos(1.5) // this uses the standard cos() function << endl; return (0); }Note that a
using
-declaration can be used inside a block. The
using
declaration prevents the definition of entities having the same
name as the one used in the using
declaration: it is not possible to
use a using declaration for a variable value
in the CppAnnotations
namespace, and to define (or declare) an identically named object in the
block in which the using
declaration was placed:
int main() { using CppAnnotations::value; ... cout << value << endl; // this uses CppAnnotations::value int value; // error: value already defined. return (0); }
A generalized alternative to the using
-declaration is the
using
-directive:
using namespace CppAnnotations;Following this directive, all entities defined in the
CppAnnotations
namespace are uses as if they where declared by using
declarations.
While the using
-directive is a quick way to import all the names of
the CppAnnotations
namespace (assuming the entities are declared or
defined separately from the directive), it is at the same time a somewhat
dirty way to do so, as it is less clear which entity will be used in a
particular block of code.
If, e.g., cos()
is defined in the CppAnnotations
namespace, the
function CppAnnotations::cos()
will be used when cos()
is called in
the code. However, if cos()
is not defined in the CppAnnotations
namespace, the standard cos()
function will be used. The using
directive does not document as clearly which entity will be used as the
using
declaration does. For this reason, the unsing
directive is
somewhat deprecated.
cout, cin, cerr
and the templates defined in the
Standard Template Library, see chapter 10) are now defined in the
std
namespace.
Regarding the discussion in the previous section, one should use a using
declaration for these entities. For example, in order to use the cout
stream, the code should start with something like
#include <iostream> using std::cout;Often, however, the identifiers that are defined in the
std
namespace
can all be accepted without much thought. Because of that, one often
encounters a using
directive, rather than a using
declaration with the
std
namespace. So, instead of the mentioned using declaration
a
construction like
#include <iostream> using namespace std;is often encountered. Whether this should be encouraged is subject of some dispute. Long
using
declarations are of course inconvenient too. So as a
rule of thumb one might decide to stick to using
declarations, up to the
point where the list becomes impractically long, at which point a using
directive could be considered.
namespace CppAnnotations { namespace Virtual { void *pointer; } }Now the variable
pointer
defined in the Virtual
namespace, nested
under the CppAnnotations
namespace. In order to refer to this variable,
the following options are available:
int main() { CppAnnotations::Virtual::pointer = 0; return (0); }
using
declaration for CppAnnotations::Virtual
can be
used. Now Virtual
can be used without any prefix, but
pointer
must be used with the Virtual::
prefix:
... using CppAnnotations::Virtual; int main() { Virtual::pointer = 0; return (0); }
using
declaration for CppAnnotations::Virtual::pointer
can be used. Now pointer
can be used without any prefix:
... using CppAnnotations::Virtual::pointer; int main() { pointer = 0; return (0); }
using
directive or directives can be used:
... using namespace CppAnnotations::Virtual; int main() { pointer = 0; return (0); }Alternatively, two separate
using
directives could have been used:
... using namespace CppAnnotations; using namespace Virtual; int main() { pointer = 0; return (0); }
using
declarations) and using
directives can be used. E.g., a using
directive can be used for
the CppAnnotations
namespace, and a using
declaration can be used for
the Virtual::pointer
variable:
... using namespace CppAnnotations; using Virtual::pointer; int main() { pointer = 0; return (0); }
using
directive all entities of that namespace can be used
without any further prefix. If a namespace is nested, then that namespace can
also be used without any further prefix. However, the entities defined in the
nested namespace still need the nested namespace's name. Only by using a
using
declaration or directive the qualified name of the
nested namespace can be omitted.
When fully qualified names are somehow preferred, while the long form (like
CppAnnotations::Virtual::pointer
) is at the same time considered too long,
a namespace alias can be used:
namespace CV = CppAnnotations::Virtual;This defines
CV
as an alias for the full name. So, to refer to the
pointer
variable the construction
CV::pointer = 0;Of course, a namespace alias itself can also be used in a
using
declaration or directive.
3.6.4.1: Defining entities outside of their namesapces
It is not strictly necessary to define members of namespaces within a
namespace
region. By prefixing the member by its namespace or namespaces a
member can be defined outside of a namespace region. This may be done at the
global level, or at intermediate levels in the case of nested namespaces. So it
is not possible to define a member of namespace A
within the region of
namespace C
, but it is possible to define a member of namespace A::B
within the region of namespace A
.
Note, however, that when a member of a namespace is defined outside of a
namespace region, it must still be declared within the region.
Assume the type int INT8[8]
is defined in the
CppAnnotations::Virtual
namespace.
Now suppose we want to define (at the global level) a member function
funny
of namespace CppAnnotations::Virtual
, returning a pointer to
CppAnnotations::Virtual::INT8
. The definition of such a function could be
as follows (first defining everything inside the CppAnnotations::Virtual
namespace):
namespace CppAnnotations { namespace Virtual { void *pointer; typedef int INT8[8]; INT8 *funny() { INT8 *ip = new INT8[1]; for (int idx = 0; idx < sizeof(INT8) / sizeof(int); ++idx) (*ip)[idx] = (1 + idx) * (1 + idx); return (ip); } } }The function
funny()
defines an array of one INT8
vector, and
returns its address after initializing the vector by the squares of the first
eight natural numbers.
Now the function funny()
can be defined outside of the
CppAnnotations::Virtual
as follows:
namespace CppAnnotations { namespace Virtual { void *pointer; typedef int INT8[8]; INT8 *funny(); } } CppAnnotations::Virtual::INT8 *CppAnnotations::Virtual::funny() { INT8 *ip = new INT8[1]; for (int idx = 0; idx < sizeof(INT8) / sizeof(int); ++idx) { cout << idx << endl; (*ip)[idx] = idx * idx; } return (ip); }At the final code fragment note the following:
funny()
is declared inside of the CppAnnotations::Virtual
namespace.
The definition outside of the namespace region requires us to use
the fully qualified name of the function and of its returntype.
Inside the block of the function funny
we are within the
CppAnnotations::Virtual
namespace, so inside the function fully
qualified names (e.g., for INT8
are not required any more.
Finally, note that the function could also have been defined in the
CppAnnotations
region. It that case the Virtual
namespace would have
been required for the function name and its returntype, while the internals of
the function would remain the same:
namespace CppAnnotations { namespace Virtual { void *pointer; typedef int INT8[8]; INT8 *funny(); } Virtual::INT8 *Virtual::funny() { INT8 *ip = new INT8[1]; for (int idx = 0; idx < sizeof(INT8) / sizeof(int); ++idx) { cout << idx << endl; (*ip)[idx] = idx * idx; } return (ip); } }