Introduction to C++ Massachusetts Institute of Technology January 26, 2011 6.096 Lecture 10 Notes: Advanced Topics II 1 Stuﬀ You May Want to Use in Your Project 1.1 File handling File handling in C++ works almost identically to terminal input/output. To use ﬁles, you write #include at the top of your source ﬁle. Then you can access two classes from the std namespace: • ifstream – allows reading input from ﬁles • ofstream – allows outputting to ﬁles Each open ﬁle is represented by a separate ifstream or an ofstream object. You can use ifstream objects in excatly the same way as cin and ofstream objects in the same way as cout, except that you need to declare new objects and specify what ﬁles to open. For example: 1 2 3 4 5 6 7 8 9 10 11 12 # include < fstream > using namespace std ; int main () { ifstream source ( " source - file . txt " ) ; ofstream destination ( " dest - file . txt " ) ; int x ; source >> x ; // Reads one int from source - file . txt source . close () ; // close file as soon as we ’ re done using it destination << x ; // Writes x to dest - file . txt return 0; } // close () called on destination by its destructor As an alternative to passing the ﬁlename to the constructor, you can use an existing ifstream or ofstream object to open a ﬁle by calling the open method on it: source.open("other-file.txt");. Close your ﬁles using the close() method when you’re done using them. This is automat ically done for you in the object’s destructor, but you often want to close the ﬁle ASAP, without waiting for the destructor. You can specify a second argument to the constructor or the open method to specify what “mode” you want to access the ﬁle in – read-only, overwrite, write by appending, etc. Check documentation online for details. 1.2 Reading Strings You’ll likely ﬁnd that you want to read some text input from the user. We’ve so far seen only how to do ints, chars, etc. It’s usually easiest to manage text using the C++ string class. You can read in a string from cin like other variables: 1 string mobileCarrier ; 2 cin >> mobileCarrier ; However, this method only reads up to the ﬁrst whitespace; it stops at any tab, space, newline, etc. If you want to read multiple words, you can use the getline function, which reads everything up until the user presses enter: 1 string sentence ; 2 getline ( cin , sentence ) ; 1.3 enum In many cases you’ll ﬁnd that you’ll want to have a variable that represents one of a discrete set of values. For instance, you might be writing a card game and want to store the suit of a card, which can only be one of clubs, diamonds, hearts, and spades. One way you might do this is declaring a bunch of const ints, each of which is an ID for a particular suit. If you wanted to print the suit name for a particular ID, you might write this: 1 const int CLUBS = 0 , DIAMONDS = 1 , HEARTS = 2 , SPADES = 3; 2 void print_suit ( const int suit ) { 3 const char * names [] = { " Clubs " , " Diamonds " , 4 " Hearts " , " Spades " }; 5 return names [ suit ]; 6 } The problem with this is that suit could be integer, not just one of the set of values we know it should be restricted to. We’d have to check in our function whether suit is too big. Also, there’s no indication in the code that these const ints are related. Instead, C++ allows us to use enums. An enum just provides a set of named integer values which are the only legal values for some new type. For instance: 2 1 enum suit_t { CLUBS , DIAMONDS , HEARTS , SPADES }; 2 void print_suit ( const suit_t suit ) { 3 const char * names [] = { " Clubs " , " Diamonds " , 4 " Hearts " , " Spades " }; 5 return names [ suit ]; 6 } Now, it is illegal to pass anything but CLUBS, DIAMODNS, HEARTS, or SPADES into print suit. However, internally the suit t values are still just integers, and we can use them as such (as in line 5). You can specify which integers you want them to be: 1 enum suit_t { CLUBS =18 , DIAMONDS =91 , HEARTS =241 , SPADES =13}; The following rules are used by default to determine the values of the enum constants: • The ﬁrst item defaults to 0. • Every other item defaults to the previous item plus 1. Just like any other type, an enum type such as suit t can be used for any arguments, variables, return types, etc. 1.4 Structuring Your Project Many object-oriented programs like those you’re writing for your projects share an overall structure you will likely want to use. They have some kind of managing class (e.g., Game, Directory, etc.) that maintains all the other objects that interact in the program. For instance, in a board game, you might have a Game class that is responsible for maintaining Player objects and the Board object. Often this class will have to maintain some collection of objects, such as a list of people or a deck of cards; it can do so by having a ﬁeld that is an STL container. main creates a single instance of this managing class, handles the interaction with the user (i.e. asking the user what to do next), and calls methods on the manager object to perform the appropriate actions based on user input. 2 Review Some of the new concepts we’ll cover require familiarity with concepts we’ve touched on previously. These concepts will also be useful in your projects. 3 2.1 References References are perfectly valid types, just like pointers. For instance, just like int * is the “pointer to an integer” type, int & is the “reference to an integer” type. References can be passed as arguments to functions, returned from functions, and otherwise manipulated just like any other type. References are just pointers internally; when you declare a reference variable, a pointer to the value being referenced is created, and it’s just dereferenced each time the reference variable is used. The syntax for setting a reference variable to become an alias for another variable is just like regular assignment: 1 int & x = y ; // x and y are now two names for the same variable Similarly, when we want to pass arguments to a function using references, we just call the function with the arguments as usual, and put the & in the function deﬁniton, where the argument variables are being set to the arguments actually passed: 1 void sq ( int & x ) { // & is part of the type of x 2 // - x is an int reference 3 x *= x ; 4 } 5 sq ( y ) ; Note that on the last line, where we specify what variable x will be a reference to, we just write the name of that variable; we don’t need to take an address with & here. References can also be returned from functions, as in this contrived example: 1 int g ; // Global variable 2 int & getG () { // Return type is int reference 3 return g ; // As before , the value we ’ re making a 4 // reference * to * doesn ’t get an & in front of it 5 } 6 7 // ... Somewhere in main 8 int & gRef = getG () ; // gRef is now an alias for g 9 gRef = 7; // Modifies g If you’re writing a class method that needs to return some internal object, it’s often best to return it by reference, since that avoids copying over the entire object. You could also then use your method to do something like: 1 vector < Card > & cardList 4 2 = deck . getList () ; // getList declared to return a reference 3 cardList . pop_back () ; The second line here modiﬁes the original list in deck, because cardList was declared as a reference and getList returns a reference. 2.2 2.2.1 const Converting between const and non-const You can always provide a non-const value where a const one was expected. For instance, you can pass non-const variables to a function that takes a const argument. The const-ness of the argument just means the function promises not to change it, whether or not you require that promise. The other direction can be a problem: you cannot provide a const reference or pointer where a non-const one was expected. Setting a non-const pointer/reference to a const one would violate the latter’s requirement that it not be changeable. The following, for instance, does not work: 1 int g ; // Global variable 2 const int & getG () { return g ; } 3 4 // ... Somewhere in main 5 int & gRef = getG () ; This fails because gRef is a non-const reference, yet we are trying to set it to a const reference (the reference returned by getG). In short, the compiler will not let you convert a const value into a non-const value unless you’re just making a copy (which leaves the original const value safe). 2.2.2 const functions For simple values like ints, the concept of const variables is simple: a const int can’t be modiﬁed. It gets a little more complicated when we start talking about const objects. Clearly, no ﬁelds on a const object should be modiﬁable, but what methods should be available? It turns out that the compiler can’t always tell for itself which methods are safe to call on const objects, so it assumes by default that none are. To signal that a method is safe to call on a const object, you must put the const keyword at the end of its signature, e.g. int getX() const;. const methods that return pointers/references to internal class data should always return const pointers/references. 5 3 Exceptions Sometimes functions encounter errors that make it impossible to continue normally. For instance, a getFirst function that was called on an empty Array object would have no reasonable course of action, since there is no ﬁrst element to return. A functions can signal such an error to its caller by throwing an exception. This causes the function to exit immediately with no return value. The calling function has the opportunity to catch the exception – to specify how it should be handled. If it does not do so, it exits immediately as well, the exception passes up to the next function, and so on up the call stack (the chain of function calls that got us to the exception). An example: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 const int DIV_BY_0 = 0; int divide ( const int x , const int y ) { if ( y == 0) throw DIV_BY_0 ; return x / y ; } void f ( int x , int ** arrPtr ) { try { * arrPtr = new int [ divide (5 , x ) ]; } catch ( int error ) { // cerr is like cout but for error messages cerr << " Caught error : " << error ; } // ... Some other code ... } The code in main is executing a function (divide) that might throw an exception. In anticipation, the potentially problematic code is wrapped in a try block. If an exception is thrown from divide, divide immediately exits, passing control back to main. Next, the exception’s type is checked against the type speciﬁed in the catch block (line 11). If it matches (as it does in this case), the code in the catch block is executed; otherwise, f will exit as well as though it had thrown the exception. The exception will then be passed up to f’s caller to see if it has a catch block deﬁned for the exception’s type. You can have an arbitrary number of catch blocks after a try block: 1 int divide ( const int x , const int y ) { 2 if ( y == 0) 3 throw std :: runtime_exception ( " Divide by 0! " ) ; 4 return x / y ; 6 5 } 6 7 void f ( int x , int ** arrPtr ) { 8 try { 9 * arrPtr = new int [ divide (5 , x ) ]; 10 } 11 catch ( bad_alloc & error ) { // new throws exceptions of this type 12 cerr << " new failed to allocate memory " ; 13 } 14 catch ( runtime_exception & error ) { 15 // cerr is like cout but for error messages 16 cerr << " Caught error : " << error . what () ; 17 } 18 // ... 19 } In such a case, the exception’s type is checked against each of the catch blocks’ argument types in the order speciﬁed. If line 2 causes an exception, the program will ﬁrst check whether the exception is a bad alloc object. Failing that, it checks whether it was a runtime exception object. If the exception is neither, the function exits and the exception continues propagating up the call stack. The destructors of all local variables in a function are called before the function exits due to an exception. Exception usage notes: • Though C++ allows us to throw values of any type, typically we throw exception objects. Most exception classes inherit from class std::exception in header ﬁle . • The standard exception classes all have a constructor taking a string that describes the problem. That description can be accessed by calling the what method on an exception object. • You should always use references when specifying the type a catch block should match (as in lines 11 and 14). This prevents excessive copying and allows virtual functions to be executed properly on the exception object. 4 friend Functions/Classes Occasionally you’ll want to allow a function that is not a member of a given class to access the private ﬁelds/methods of that class. (This is particularly common in operator overloading.) 7 We can specify that a given external function gets full access rights by placing the signature of the function inside the class, preceded by the word friend. For example, if we want to make the ﬁelds of the USCurrency type from the previous lecture private, we can still have our stream insertion operator (the output operator, <<) overloaded: 1 class USCurrency { 2 friend ostream & operator < <( ostream &o , const USCurrency & c ) ; 3 int dollars , cents ; 4 public : 5 USCurrency ( const int d , const int c ) : dollars ( d ) , cents ( c ) {} 6 }; 7 8 ostream & operator < <( ostream &o , const USCurrency & c ) { 9 o << ’$ ’ << c . dollars << ’. ’ << c . cents ; 10 return o ; 11 } Now the operator<< function has full access to all members of USCurrency objects. We can do the same with classes. To say that all member functions of class A should be fully available to class B, we’d write: 1 class A { 2 friend class B ; 3 // More code ... 4 }; 5 Preprocessor Macros We’ve seen how to deﬁne constants using the preprocessor command #define. We can also deﬁne macros, small snippets of code that depend on arguments. For instance, we can write: 1 # define sum (x , y ) ( x + y ) Now, every time sum(a, b) appears in the code, for any arguments a and b, it will be replaced with (a + b). Macros are like small functions that are not type-checked; they are implemented by simple textual substitution. Because they are not type-checked, they are considered less robust than functions. 8 6 Casting Casting is the process of converting a value between types. We’ve already seen C-style casts – e.g. 1/(double)4. Such casts are not recommended in C++; C++ provides a number of more robust means of casting that allow you to specify more precisely what you want. All C++-style casts are of the form cast type(value), where type is the type you’re casting to. The possible cast types to replace cast type with are: • static cast – This is by far the most commonly used cast. It creates a simple copy of the value of the speciﬁed type. Example: static cast(x), where x is an int, gives a float copy of x. • dynamic cast – Allows converting between pointer/reference types within an inher itance hierarchy. dynamic cast checks whether value is actually of type type. For instance, we could cast a Vehicle * called v to a Car * by writing dynamic cast(v). If v is in fact a pointer to a Car, not a Vehicle of some other type such as Truck, this returns a valid pointer of type Car *. If v does not point to a Car, it returns null. dynamic cast can also be used with references: if v is a Vehicle & variable, dynamic cast (v) will return a valid reference if v is actually a reference to a Car, and will throw a bad cast exception otherwise. • reinterpret cast – Does no conversion; just treats the memory containing value as though it were of type type • const cast – Used for changing const modiﬁers of a value. You can use this to tell the compiler that you really do know what you’re doing and should be allowed to modify a const variable. You could also use it to add a const modiﬁer to an object so you can force use of the const version of a member function. 7 That’s All! This is the end of the 6.096 syllabus, but there are lots of really neat things you can do with C++ that we haven’t even touched on. Just to give you a taste: • Unions – group multiple data types together; unlike classes/structs, though, the ﬁelds of a union are mutually exclusive – only one of them is well-deﬁned at any time • Namespaces – allow you to wrap up all your code, classes, etc. into a “directory” of names, like std • Advanced STL manipulation – allows you to do all sorts of wacky things with STL containers and iterators 9 • void pointers – pointers to data of an unknown type • virtual inheritance – the solution to the “dreaded diamond” problem described in Lecture 8 • String streams – allow you to input from and output to string objects as though they were streams like cin and cout • Run-time type information (RTTI) – allows you to get information on the type of a variable at runtime • vtables – how the magic of virtual functions actually works If you are interested in learning more about these subjects or anything we’ve discussed, we encourage you to look through online tutorials, perhaps even to buy a C++ book – and most importantly, to just play around with C++ on your own! 10

Lecture 10 Notes: Advanced Topics II

Related Documents

Recommended Documents

Description

Related Documents

Free up your schedule!

Take 5 seconds to unlock