Strings: Strings are not built into the C++ core language, but they are provided as one of the Standard Template Libraries (STLs). So to use them you have put in your program: #include <string> There is a kind of string data type built into the C++ language. They are usually called C-strings or "native C strings." They're kind of a holdover from the the C language, on which C++ is built. Partly they are there for "upward compatibility." C strings are more primitive, in the sense that they do less for you and more errorprone. When you write a quoted sequence of characters, such as "Hello", you are writing a C-string. When you do an assignment, such as: string fred; fred = "Hello"; The compiler is automatically converting the C-string "Hello" to a string value. You can also do it explicitly like this: string fred; fred = string("Hello"); Strings are nicer: They can grow. They have better error checking. You can do things with them, such as compare them (<, >, etc.) and concatenate them (glue them end to end). String concatenation is denoted by the "+" operator, which has been overloaded to work on strings as well as other things, such as ints, doubles, and chars. "Overloading" means giving more than one meaning to an operator of function. You can overload operators and functions too. The only rule is that the compiler has to be able to tell from the types of the arguments which definition to use. To understand things it is helpful to think of them as vectors of characters (they are almost identical). Many of the same operations apply to both. What are some of the other things you can do with strings? Strings have a number of member functions, which are functions that you address to the string. (Just like for scribblers, you can address commands to them like forward() and getName(), for example robot.forward(0.75) or robot.getName().) If S is a string, S.size() returns the length of the string. S.find(c) returns the location of the first occurrence of the character c in S. If c doesn't occur in S, it returns a special value, string::npos (which stands for "no position"). We can address locations in a string with indices, just as we do for vectors. So S[0] is the first character in S, S[1] is the second, and so forth. You can assign to these too. Notice that the indices of an N-element string string run from 0 to N-1, so that the last character in a string is always S[S.size()-1]. If you forget this, you'll make an off-by-one error. If the index I is too big (>= S.size() ), then S[I] fetches the contents of the location in memory where S[I] would be if it existed. In other words I bytes from the beginning of S. It could be anything. If you fetch it, you are getting garbage. If you assign to it, you are assigning to a memory location that is not part of S, but is part of some other variable or even the code. This can lead to mysterious errors or cause your program to blow up. This is called out-of-bound subscripting or indexing, or over-subscripting a string or vector. This is potentially a serious problem, and even a computer security risk. "Buffer overruns" have been used to insert malicious code into computers. Unfortunately, C and C++ do not do vector and string bounds checking, because it takes a little computer time, and so these errors are easy to make. There a safe indexing operation in C++: the .at() member function. S.at(I) is equivalent to S[I], but with bounds checking. Bounds checking is like putting a fuse or a circuit breaker in a circuit. It costs a little, but helps prevent things from blowing up. .at() throws an out-of-bounds exception (which you can "catch") if the index is too big or too small. find is built in to strings, but it's a good exercise to define your own Find function. To do it, think about how you would do it by hand. This is a typical example of a sequential search. If the data are not ordered in any way, the best you can do is to search from beginning to end. If what you are looking for happens to be at the beginning of the string or vector, then it takes one pass through the loop. If it is at the end, then it takes N passes through the loop. On the average (assuming everything is equally likely), it takes about N/2 passes through the loop. So the time is proportional to N, the size of the string or vector. So it is called an O(n), order N, or linear algorithm. If you can organize the data (e.g., alphabetize or sort it), then you can do better, for example there are O(log N) steps, a logarithmic search. An algorithm that takes time proportional to N^2 is a quadratic algorithm, which is not so good. Practice: think about writing Find(string S, string T), which looks for T as a substring of S, and tells you the first place it occurs, if any. It will require two nested loops. Another example, palindrome tester. Palindromes: "Madam, I am Adam." — Adam "Able was I ere I saw Elba." — Napoleon Ignore everything but letters. Ignore uppercase/lowercase. Then see if the string is symmetrical. Don't forget to pay attention to whether it's odd or even length. It's a palindrome if S[0] == S[N-1] S[1] == S[N-2] S[2] == S[N-3] .... terminates with S[X] == S[N-X-1] Stops if N is even and X == N/2 (integer division). This also works if N is odd (do you see why?)