Use the dot operator to access a member of a specific object.

Transcription

1 Lab 16

2 Class A class is a data type that can contain several parts, which are called members. There are two types of members, data member and functions. An object is an instance of a class, and each object can have its own data values. A constructor is a function that gets called when you create an object, which you can use to initialize data members.

3 #include <iostream> using namespace std; class Square{ public: int length; // data member Square() {length= 1; // no-argument constructor Square(int n) {length = n; // 1-argument constructor double perimeter() {return 4*length;//member function double area() {return length*length; // member function ; A constructor is declared with the same name as the class, and with no return type. When you call the no-argument constructor, there is no parenthesis following the variable name(unlike JAVA). int main() { Square s; // calls the no-argument constructor Square t(5); // calls the 1-argument constructor cout << s.length << endl; // prints 1 cout << t.length << endl; // 5 cout << s.perimeter() << endl; // 4 cout << t.area() << endl; // 25 return 0; Use the dot operator to access a member of a specific object. In a member function, a variable name by itself refers to the data member of the object on which the function was called.

4 #include <iostream> using namespace std; class Square{ private: double length; public: Square() {length= 1; // no-argument constructor Square(int n) {length = n; // 1-argument constructor double get_length(){return length; void set_length(double len) {length = len; ; Members can be public or private. Private members can only be accessed from within the same class or from friends. If you do not want other users to directly access to the length, you can make it private and use get and set functions. int main() { Square s; // calls the no-argument constructor //s.length = 12; //not allowed since length is private s.set_length(12);//set the value of length to 12 cout << s.length << endl; // prints 1 return 0;

5 #include <iostream> using namespace std; class Rat { public: int n, d; Rat() {n = 0; d = 1; Rat(int i) {n = i; d = 1; ; // The return type is Rat. If you add 2 Rats, the sum should be the same type. Rat operator+(rat other) { Rat t; // First, create a new Rat. t.n= n*other.d + d*other.n; // Modify the new Rat. t.d = d*other.d; return t; // Return the new Rat t. int main() { Rat y(2), z(3); Rat x = y + z; // equivalent to Rat x = y.operator+(z); cout << x.n << "/" << x.d; // prints 5/1 return 0; 1. An operator is a type of function. The following two expressions are equivalent: x+y; x.operator+(y); 2. Operator + is not defined for Rat class. Hence, you need to define it for yourself. 3. Use the same operator for different purpose is called operator overloading. (use + operator to add int, string, or other classes defined by you) 4. In the operator + function, n and d are y s data(y is on the left side of + operator, so it is the object on which the function was called.) other.n and other.z are z s data(z is on the right side of + operator, so it is the object passed as parameter).

6 #include <iostream> using namespace std; class Rat { int n, d; public: Rat(int i, int j) {n = i; d = j; friend ostream& operator<<(ostream& os, Rat r); // declare operator<< as a friend of Rat ; ostream& operator<<(ostream& os, Rat r){ os << r.n << "/" << r.d << endl; // this function has access to private members n and d return os; int main() { Rat x(2, 3), y(4, 5); cout << x << y; // prints 2/3 // 4/5 return 0; A friend function is a function which is declared outside a class, but has access to the class s private members. Operator<< cannot be defined inside the Rat class because the left operand is an object of the ostream class and we do not have access to updating or altering ostream code. So we need to make it global and friend function. Note operator << returns an ostream so that we can print x and y in the same statement. ostream is passed and returned by reference, because we cannot make a copy of a stream.

7 Copy constructor: The constructor is called in a number of common situations whether you are aware of it or not. If you do not write one, the compiler automatically supplies one for you, but just a simple member-by-member copy, which is sufficient for Rat class. The copy constructor is automatically called when: When the return value of a function has class type. When an argument has class type. When you use one object to initialize another. Eg, Rat x = 3; Rat y = x;

8 Destructor: Destructors are called when an object is deleted. For example, if you declare an object in a function, it is deleted when the function returns. If you do not define one, the compiler will create one for you. For the homework of SafeArray class, you should define a destructor that deletes the array being pointed to.

9 Sample outputs: r1: 2 1/2 r2: 1 1/2 r1 + r2: 4 r1 - r2: 1 r1 * r2: 3 3/4 r1 / r2: 1 2/ r1: 1 1/2 r2: 2 1/4 r1 + r2: 3 3/4 r1 - r2: -3/4 r1 * r2: 3 3/8 r1 / r2: 2/ r1: 4 1/2 r2: 4 1/2 r1 + r2: 9 r1 - r2: 0 r1 * r2: 20 1/4 r1 / r2: 1