C++ Programming: Program Design Including Data Structures, Third Edition

1. C++ Programming: Program Design Including Data Structures, Third Edition Chapter 8: User-Defined Simple Data Types, Namespaces, and the string Type

2. Objectives In this chapter you will: • Learn how to create and manipulate your own simple data type—called the enumeration type • Become aware of the typedef statement • Learn about the namespace mechanism • Explore the string data type, and learn how to use the various string functions to manipulate strings

3. Enumeration Type • Data type - a set of values together with a set of operations on those values • To define a new simple data type, called enumeration type, we need three things: • A name for the data type • A set of values for the data type • A set of operations on the values

4. Enumeration Type (continued) • A new simple data type can be defined by specifying its name and the values, but not the operations • The values must be identifiers

5. Enumeration Type (continued) • The syntax for enumeration type is: • value1, value2, … are identifiers called enumerators • value1 < value2 < value3 <...

6. Enumeration Type (continued) • Enumeration type is an ordered set of values • If a value has been used in one enumeration type • It cannot be used by another in the same block • The same rules apply to enumeration types declared outside of any blocks

10. Assignment • The statement: popularSport = FOOTBALL; stores the word FOOTBALL into popularSport • The statement: mySport = popularSport; copies the contents of the variable popularSport into mySport

11. Operations • No arithmetic operation is allowed on enumeration types • The following statements are illegal:

12. Operations (continued) • The increment and decrement operations are not allowed on enumeration types • The following statements are illegal:

13. Operations (continued)

14. Operations and Input/Output • Because an enumeration is an ordered set of values • We can use relational operators with them • The cast operator can be used to increment, decrement, and compare values • Values can be used in loops • Input and output are defined only for built-in data types such as int, char, double • The enumeration type can be neither input nor output (directly)

15. Functions and Enumeration Types • Enumeration type can be passed as parameters to functions either by value or by reference • A function can return a value of the enumeration type

16. Anonymous Data Types • Anonymous - a data type in which values are directly specified in the variable declaration with no type name, for example: • Creating an anonymous type has drawbacks • We cannot pass an anonymous type as a parameter to a function

17. Anonymous Data Types (continued) • A function cannot return a value of an anonymous type • Values used in one can be used in another, but they are treated differently

18. typedef Statement • You can create synonyms or aliases to a previously defined data type by using the typedef statement • The syntax of the typedef statement is: • typedef does not create any new data types • typedef creates an alias to an existing data type

19. ANSI/ISO Standard C++ • ANSI/ISO standard C++ was officially approved in July 1998 • Most of the recent compilers are also compatible with ANSI/ISO standard C++ • For the most part, standard C++ and ANSI/ISO standard C++ are the same, but • ANSI/ISO Standard C++ has some features not available in Standard C++

20. Namespaces • When a header file, such as iostream, is included in a program • Global identifiers in the header file also become global identifiers in the program • If a global identifier in a program has the same name as one of the global identifiers in the header file • The compiler will generate a syntax error (such as identifier redefined) • The same problem can occur if a program uses third party libraries

21. Namespaces (continued) • To overcome this problem, third party vendors begin their global identifiers with a special symbol • Because compiler vendors begin their global identifier with _ (underscore) • To avoid linking errors, do not begin identifiers in your program with _ • ANSI/ISO standard C++ attempts to solve this problem of overlapping global identifier names with the namespace mechanism

22. Syntax: namespace • The syntax of the statement namespace is: where a member is usually a variable declaration, a named constant, a function, or another namespace

24. Accessing a namespace Member • The scope of a namespace member is local to the namespace • Usually two ways a namespace member can be accessed outside the namespace • One way is to use the syntax: namespace_name::identifier • To access the member rate of the namespace globalType, the following statement is required: globalType::RATE

25. Accessing a namespace Member (continued) • To access the function printResult, the following statement is required: globalType::printResult(); • To simplify the accessing of all namespace members: using namespace namespace_name; • To simplify the accessing of a specific namespace member: using namespace_name::identifier;

26. The using Statement • After the using statement • Not necessary to precede the namespace_name and the scope resolution operator before the namespace member • If a namespace member and a global identifier or a block identifier have the same name • namespace_name and scope resolution operator must precede the namespace member

27. The string Type • To use the data type string, the program must include the header file <string> • The statement string name = "William Jacob"; declares name to be a string variable and also initializes name to "William Jacob" • The first character in name, 'W', is in position 0, the second character, 'i', is in position 1, and so on

28. The string Type (continued) • The variable name is capable of storing any size string • Binary operator + (to allow the string concatenation operation), and the array subscript operator [], have been defined for the data type string • For example, if str1 = "Sunny", the statement stores the string "Sunny Day" into str2: str2 = str1 + " Day";

29. length Function • Length returns the number of characters currently in the string • The syntax to call the length function is: strVar.length() where strVar is variable of the type string • length has no arguments • length returns an unsigned integer • The value returned can be stored in an integer variable

31. size Function • The function size is the same as the function length • Both functions return the same value • The syntax to call the function size is: strVar.size() where strVar is variable of the type string • As in the case of the function length, the function size has no arguments

32. find Function • find searches a string for the first occurrence of a particular substring • Returns an unsigned integer value of type string::size_type giving the result of the search • The syntax to call the function find is: strVar.find(strExp) where strVar is a string variable and strExp is a string expression evaluating to a string • The string expression strExp can also be a character

33. find Function (continued) • If successful, find returns the position in strVar where the match begins • For the search to be successful, the match must be exact • If unsuccessful, find returns the special value string::npos (“not a position within the string”)

35. substr Function • substr returns a particular substring of a string • The syntax to call the function substr is: strVar.substr(expr1,expr2) where expr1 and expr2 are expressions evaluating to unsigned integers

36. substr Function (continued) • The expression expr1 specifies a position within the string (starting position of the substring) • The expression expr2 specifies the length of the substring to be returned

38. swap Function • swap interchanges the contents of two string variables • The syntax to use the function swap is strVar1.swap(strVar2); where strVar1 and strVar2 are string variables • Suppose you have the following statements: string str1 = "Warm"; string str2 = "Cold"; • After str1.swap(str2); executes, the value of str1 is "Cold" and the value of str2 is "War

39. Programming Example: Pig Latin Strings • Program prompts user to input a string • Then outputs the string in the pig Latin form • The rules for converting a string into pig Latin form are as follows: • If the string begins with a vowel, add the string "-way" at the end of the string • For example, the pig Latin form of the string "eye" is "eye-way"

40. Pig Latin Strings (continued) • If the string does not begin with a vowel, first add "-" at the end of the string • Then move the first character of the string to the end of the string until the first character of the string becomes a vowel • Next, add the string "ay" at the end • For example, the pig Latin form of the string "There" is "ere-Thay"

41. Pig Latin Strings (continued) • Strings such as "by" contain no vowels • In cases like this, the letter y can be considered a vowel • For this program, the vowels are a, e, i, o, u, y, A, E, I, O, U, and Y; the pig Latin form of "by" is "y-bay" • Strings such as "1234" contain no vowels • The pig Latin form of a string that has no vowels in it is the string followed by the string "-way" • For example, the pig Latin form of the string "1234" is "1234-way"

42. Problem Analysis • If str denotes a string • Check the first character, str[0], of str • If str[0] is a vowel, add "-way" at the end of str • If the first character of str, str[0], is not a vowel • First add "-" at the end of the string • Remove the first character of str from str and put it at end of str • Now the second character of str becomes the first character of str

43. Problem Analysis (continued) • This process is repeated until either • The first character of str is a vowel • All characters of str are processed, in which case str does not contain any vowels

44. Algorithm Design • The program contains the following functions: • isVowel - to determine whether a character is a vowel • rotate - to move first character of str to the end of str • pigLatinString - to find the pig Latin form of str • Steps in the Algorithm: • Get str • Use the function pigLatinString to find the pig Latin form of str • Output the pig Latin form of str

46. Function rotate • Takes a string as a parameter • Removes the first character of the string • Places it at end of the string by extracting the substring starting at position 1 until the end of the string, and then adding the first character of the string

47. Function rotate (continued)

48. Function pigLatinString • If pStr[0] is a vowel, add "-way" at end of pStr • If pStr[0] is not a vowel • Move the first character of pStr to the end of pStr • The second character of pStr becomes the first character of pStr • Now pStr may or may not contain a vowel • Use a bool variable, foundVowel, which is set to true if pStr contains a vowel, and false otherwise • Initialize foundVowel to false

49. Function pigLatinString (continued) • if pStr[0] is not a vowel, move str[0] to the end of pStr by calling the function rotate • Repeat third step until either the first character of pStr becomes a vowel or all characters of pStr have been checked • Convert pStr into the pig Latin form • Return pStr

50. Main Algorithm • Get the string • Call the function pigLatinString to find the pig Latin form of the string • Output the pig Latin form of the string