CISC 2200 Data Structure Fall, C++ Review:3/3. 1 From last lecture:

Transcription

1 CISC 2200 Data Structure Fall, 2016 C++ Review:3/3 1 From last lecture: pointer type and pointer variable (stores memory addresses of a variable (of any type, local or global, automatic/static/dynamic) ) operation on pointer variables: increment (++), decrement ( ), dereference (*), assignment, delete Why pointer type: allow a function to access local variables defined in the function that calls it (access a variable by address), access dynamically allocated variables (which do not have names), and organize data structure (such as linked list, trees,). Tracing a program: especially function calls with pass-by-value, pass-by-reference parameters Drawing memory map: an important tool going forward (to understand linked list, tree structures) array variable is a special pointer (we cannot modify it.) Using array with function: parameter passing, return arrays 2 Object-Oriented Programming When we design our own class, we are building a new data type that is hopefully useful for various applications, e.g., a DollarAmount class, a Rational class, (a) Encapsupation (via private members): restricting direct access to private members, and bundling data with the methods. Information hiding is achieved as user of a class (such as main.cpp) does not need to know the impelmentation details of the class. This leads to the concept of Abstract Data Type, which stresses the fact that the properties of the data type (such as domain and opeations) are specified independently from any particular implemenation. (b) Member functions (or methods): constructor and destructor, input, output, getters, setters, operator overloading (c) Modular Design: Class interface file (such as rational.h), class implementation file (such as rational.cpp), and driver/test/main file (such as main.cpp that makes use of the rational class). (d) C++ keyword static: Can you list all different usage of the keyword static? (e) C++ keyword const: Can you lsit all different usages of const? (f) friend function of a class: a non-member function of a class that is allowed to access the private member of the class. For example, IsEqual() that compares two rational objects class rational{ public: // Usually list all friend functions at the top of public section: friend bool IsEqualTo (const rational & n1, const rational &n2);

2 }; bool IsEqualTo (cosnt rational & n1, const rational & n2) { return (n1.numerator*n2.denominator == n2.numerator*n1.denominator); } (g) Operator overload: Can you list all operators that one can overload? For each of them, can you overload them as friend function (or member function)? How would you write the operator overload function s header? //What operators are called? rational a,b; cin >> a; //If we overload operator >> cout <<"a s value is" << a << endl; //if we overload operator << cin >> b; //If we overload operator >> cout <<"b s value is" << b << endl; //if we overload operator << if (a==b) cout << a << "==" << b << end; else cout << a << "!=" << b << endl; a=-b; // if we overload negation operator a = a+b+a; //if we overload + (h) Overload operator as member function: Here are some examples: class Money { public: // add invoking object with parameter, and return the result 2

3 }; Money operator+ (const Money & amount) const; Money Money::operator+ (const Money & amount) const { Money temp; temp.all_cents = all_cents + amount.all_cents; return temp; } // in main Money my_amount (100,25),your_ammount (75); Money total_amount = my_amount+your_amount; my_amount = my_amount+10; // this is fine, first operand is // used as invoking object my_amount = 10+my_amount; // this does not work any more (i) Overload input, output operators: i. Examine the usage of input and output operators more closely: int day, month,year; char c; cin >> month >> c >> day >> c >> year; // >> operator is associated from left-to-right, i.e., it s like: // ((((cin >> month) >> c) >> day) >> c) >> year; // i.e., first cin >> month is carried out, // the value of this subexpression is then used as first operand // for the second >> operation // // This means that // 1. the first operand of >> operator is cin, or something similar ( // like a file stream, or even string). // A common type (class type) of cin, ifstream and istringstream is // istream // Will revisit this when learning about inheritance // 2. the return type should be the type of cin ii. Examples: class Money { public: friend istream& operator >>(istream& ins, Money& amount); //Overloads the >> operator so it can be used to input values of type Money. //Notation for inputting negative amounts is as in -$ //Precondition: If ins is a file input stream, then ins has already been 3

4 //connected to a file. friend ostream& operator <<(ostream& outs, const Money& amount); //Overloads the << operator so it can be used to output values of type Money. //Precedes each output value of type Money with a dollar sign. //Precondition: If outs is a file output stream, //then outs has already been connected to a file. private: long all_cents; }; ostream& operator <<(ostream& outs, const Money& amount) { long positive_cents, dollars, cents; positive_cents = labs(amount.all_cents); dollars = positive_cents/100; cents = positive_cents%100; if (amount.all_cents < 0) outs << "-$" << dollars <<. ; else outs << "$" << dollars <<. ; if (cents < 10) outs << 0 ; outs << cents; } return outs; 3 How to read variable declaration statements? C++ variable declarations can be extremely complex. There is a specific process to follow in order to read them correctly. In general, you will follow an inside-out procedure. (a) Start at the variable name. (b) Read the first item to the right of the variable name (if there is one). If the item is a right parenthesis, go to the next step. (c) Read the first item to the left of the variable name (if there is one). If the item is a left parenthesis, go to the next step. (d) Read the next item to the right of the variable name (if there is one). If the item is a right parenthesis, go to the next step. (e) Read the next item to the left of the variable name (if there is one). If the item is a left parenthesis, go to the next step. (f) Repeat Steps (d) and (e) until you run out of items to read. Usually you will run out of items to the right of the variable name well before you run out of items to the left. The items you will most frequently encounter in a C++ variable declaration are summarized in the following table: 4

5 Item Appears Read as int, Date, to the left of the variable name exactly as it appears const to the left of the variable name constant * to the left of the variable name pointer to & to the left of the variable name reference to ( to the left of the variable name not read, skip to next step [] To the right of the variable name array of [6] To the right of the variable name array of 6 [][10] To the right of the variable name two-dimensional array of an unknown number of rows with 10 columns of [4][10] To the right of the variable name two-dimensional array of 4 rows with 10 columns of ) to the right of the variable name not read, skip to next step Please practice the above guidelines by reading out (writing out) the following variable declaration, and then illustrating the variable by drawing out its memory map: (1)int a[20]; (2) const int LABNUM=4; int * labs[labnum]; (3) char board[3][3]; (4) Date listofdates1[10]; (5) Date * listofdates2; (6) Date * listofdates3[10]; (7) Date DaysLater (const Data & date, int dayspassed); //What s the parameters type? (8) void PrintBoard (int board[][4], int row); //what s the first parameter s type? 5

6 (9) // if you are building a game program that allows the user to input the size of // the game board at running time int row, col; cout << "How large is the board? enter the number of rows, number of cols:"; cin >> row >> col; // How do you declare the variables, and allocate the memory? // Recall "lab monitor" lab? (10) int *p; int * & b = p; (11) int * * p[4]; 6