Simple (atomic) data structures: have no parts. For example, int, double, bool, char,...

Transcription

1 Data Structures: Simple (atomic) data structures: have no parts. For example, int, double, bool, char,... These are the basic building blocks. We can use them to assemble more complex compound data structures. Compound data structures are either: homogeneous = all their parts are the same type, or heterogeneous = their parts could be of different types. Examples of homogeneous data structures include vectors and strings. Homogeneous data structures are more restricted in that all the components have to be the same type. We have them because they are also more flexible. In particular, you can calculate the location of the component you want. For example in V[k+1] we are using the computed value k+1 to determine which component of the vector or string that we want. The compiler can do this because all the elements of a vector are the same type and therefore the same size. So you just have to multiply the index by the size of an element, and add it to the base address of the vector to get the address of the element. A simple, efficient operation. If the elements are of different types, then you can't calculate their address at runtime (at least not efficiently). So for heterogeneous structures, the components you can select are fixed in your program (you can't calculate them at runtime). In C++ there are two primary heterogeneous data structures: the struct and the

2 class. They are very closely related. Both allow to group together data, functions, variables, and other named things that belong together as part of some object. Example: employee record. Structures should represent meaningful "things" (e.g., employees, dates). Both structs and classes are ways of grouping together related named things (e.g., variables, functions, and other structs and classes). These named things are called member variables, member functions, etc. The only difference is that by default, all the members of a struct are public (visible everywhere the struct/class is visible), and if you want any of them to be private, you have to declare them private. Classes are just the opposite: all the members are private unless they are explicitly declared public. C++ really doesn't need both structs and classes, and it's mostly for upward compatibility that it has both. If we declare a struct (or class) "employee" we think of that as a class or kind of object, in this case representing an employee. When we declare: employee me; employee boss; that creates instances of that class or structure. Often (not always) we have many instances of any given class/struct. We can even create instances on the fly while the programming is running.

3 Reference Parameters: When you declare a parameter in the usual way, it tells the compiler to pass the parameter by value. For example, double abs (double x) { if (x<0) { return -x; else { return x; When I write an invocation of abs, such as: double a; cin >> a; cout << abs (a) << endl; the compiler takes the value of a, and copies it into a local variable x in the abs() function. It passes the value of the argument to the function. This is just what you want for many purposes. But there are two problems: (1) If the argument is very large (e.g., a big vector), then (a) it takes up a lot of extra space in the function, and (b) it takes time to copy it. [efficiency problem] (2) You can't change the argument from within the function.

4 [logic problem] When you put an ampersand in the parameter declaration, it means to pass that parameter by reference. Approximate synonyms in programming languages: reference = pointer = address. They are all "names" (i.e., addresses) of locations in the computer's memory. So if I declare: void increment (int& x) { x++; Then when I invoke: increment(n) the address of N gets passed to increment, rather than the value of N. Or we say, "a reference to N gets passed to increment." So if we want a function to be able to change a variable, we need to pass that variable by reference. Note: this only makes sense if the argument is a variable of some sort (something that has an address in memory). increment(12); // makes no sense (and it's illegal) Efficiency: If I pass a big argument by reference, it only passes the address of the argument, which may be a lot smaller. Takes less time. Also, the function only has to set aside space for address of the argument, not for a whole fresh copy of it. The only problem: writing it this way suggests that the function may alter the

5 argument, even if it doesn't. So it can be misleading to the reader. (There is a way around this called "constant reference parameters.")