CSS 342 Data Structures, Algorithms, and Discrete Mathematics I. Lecture 2. Yusuf Pisan

Transcription

1 CSS 342 Data Structures, Algorithms, and Discrete Mathematics I Lecture 2 Yusuf Pisan

2 Compiled helloworld yet? Overview C++ fundamentals Assignment-1 CSS Linux Cluster - submitting assignment Call by Value, Reference, const Reference Operator Overloading Quiz

3 void TestIO() { int number; std::string str; C++ Fundamentals: Input std::cout << "Enter a number: "; std::cin >> number; std::cout << "Enter a string: "; std::cin >> str; std::cout << "Number: " << number << ", string: " << str << std::endl; // full line std::cin.ignore(); // ignores \n that cin >> str has left (if user pressed enter key) std::cout << "Enter your full name: "; std::getline ( std::cin, str); std::cout << "Hello, " << str << std::endl;

4 #include <cassert> C++ Fundamentals: string void TestString() { std::string strhello = "Hello"; std::string strworld = "World"; std::string strfull = strhello + " " + strworld; std::cout << strfull << std::endl; assert(strfull == "Hello World"); assert(strfull[0] == 'H'); assert(strfull[strfull.length() - 1] == 'd'); // Does not compile, + tries to act on C-strings // invalid operands of types 'const char [6]' and 'const char [6]' to... // std::string s1 = "Hello" + "World";

5 C++ Fundamentals: array void TestArray() { int nums[10]; nums[0] = 23; for (int i{0; i < 10; ++i) { std::cout << nums[i] << ", "; std::cout << std::endl; std::string str[10]; str[0] = "Hello"; for (int i{0; i < 10; ++i) { std::cout << str[i] << ", "; std::cout << std::endl;

6 C++ Fundamentals: vector void testvector() { std::vector<int> vi; vi.push_back(10); vi.push_back(30); std::cout << "Using a loop: "; for (int i{0; i < vi.size(); ++i) std::cout << vi[i] << ", "; std::cout << std::endl; std::cout << "Using range-based for: "; for (int i : vi) std::cout << i << ", "; std::cout << std::endl;

7 Assignment-1 Preview

8 Call by Value, Reference, const Reference struct Rectangle { int length; int width; ; // int Area(Rectangle rect) - value rect is copied // int Area(Rectangle &rect) - reference, can change rect // int Area(const Rectangle &rect)-const reference, cannot change rect { int temp; temp = rect.length; rect.length = 35; return (temp * rect.width); void TestRectangle() { int result; Rectangle r = {3, 3; result = Area(r); std::cout << "length = " << r.length << std::endl; std::cout << "width = " << r.width << std::endl; std::cout << "Area = " << result << std::endl;

9 In-Class Exercise Write a function which takes two strings and swaps them How do you want to pass the variables? by value by reference by const reference

10 // by value void swap(std::string a, std::string b) { std::string tmp = a; a = b; b = tmp; // by reference void swap(std::string &a, std::string &b) { std::string tmp = a; a = b; b = tmp; // by const reference void swap(const std::string &a, const std::string &b) { std::string tmp = a; a = b; b = tmp;

11 findmax - which version is appropriate // assume vector has at least 1 integer int findmax(vector<int> a) int findmax(vector<int> &a) int findmax(const vector<int> &a) { int max = a[0]; int i; for (i = 1; i < a.size(); i++) if (a[i] > max) max = a[i]; return max;

12 1. const int MAX = 100; const MAX is a constant. You cannot change it. 2. Account::displayBalance(const Account &acc) acc is passed as a constant reference, so no copy is created displaybalance can access acc, but not modify it 3. int Account::getBalance() const getbalance is not allowed to make any changes to the object (cannot modify this or any members) 4. const string& getnamebyreference(); Rare - returning a string by reference so it is not copied, but make sure the caller cannot change it

13 1. Friends 2. Constructors 3. Setters/Getters 4. Actions (verbs) 5. Operator Overloads 6. Private Data Types Class Design

14 class Account { account.h public: friend std::ostream &operator<<(std::ostream &out, const Account &acc); // constructor Account(); // destructor ~Account(); // get the current balance int getbalance() const; // deposit money into account // return true if successful, false otherwise // deposit is always successful bool Deposit(int amount); // withdraw money from account // return true if successful, false if not enough money bool Withdraw(int amount); private: // current balance int balance; ; #endif //WEEK1_ACCOUNT_H

15 #include "account.h" account.cpp std::ostream &operator<<(std::ostream &out, const Account &acc) { out << "A<" << acc.balance << ">"; return out; Account::Account() : balance{0 { Account::~Account() { // nothing to do int Account::getBalance() const { return balance; bool Account::Deposit(int amount) { balance += amount; return true; bool Account::Withdraw(int amount) { // to be completed

16 friend friend std::ostream &operator<<(std::ostream &out, const Account &acc); Overloading the << operator friend - allows ostream to access the private variables/functions from Account Account cannot access private variables/functions of ostream Violates encapsulation - but necessary cout << someaccount; cout << someobject;

17 Constructor - 1.h // constructor Account();.cpp Account::Account() { balance = 0; Default constructor with no parameters is automatically created by compiler No return value, creates the instance of the object May take parameters, responsible for initializing all private variables

18 Constructor - 2 // using an initialization list is better as of C++11 Account::Account() : balance{0 { If we specified an initial balance // best way Account::Account(int balance) : balance{balance { // ok Account::Account(int value) : balance{value { // works Account::Account(int balance) { this->balance = balance;

19 Constructor - 3 If a constructor takes a single parameter, it should be declared as explicit in.h This prevents implicit conversion //.h explicit Account(int balance); //.cpp is as before, no explicit needed

20 Objects are allocated on stack or heap Destructor Objects on stack are temporary. When the function is complete, the object disappears. int i; Account acc; Objects on heap created using new Continue to live until delete is called Programmer is responsible for deleting these objects, else memory leak Account class does not use new, so nothing to do in destructor.

21 Rational Class Create a class to represent a rational number: numerator / denominator 2 / 3 This should allow for multiplication, division, addition, subtraction. Comparison (eg, ==,!=) Printing out to stream

22 Without Operator Overloading Rational add(const Rational &rat); Rational subtract(const Rational &rat); Rational multiply(const Rational &rat); Rational divide(const Rational &rat); void printrational(); void printrationalasfloat(); Better to use the same operators: +, -, *, /, +=, *=, -=, /=, >, <, >=,... Rational r3 = r1 + r2;

23 Operator Overloading Principles Allowing for operators to work on classes in intuitive ways. Key Examples: Arithmetic: +, -, *, / Comparison: ==,!=, <, >, <=, >= Input: <<, >> General rules for overloading Whenever the meaning of an operator is not obviously clear and undisputed, it should not be overloaded Always stick to the operator s well-known semantics Always provide all out of a set of related operations Operators retain their precedence order

24 Overloading +,-,*,/ as member functions class Rational { public: // Op Overloads Rational operator*(const Rational &rat) const; Rational operator/(const Rational &rat) const; Rational operator-(const Rational &rat) const; Rational operator+(const Rational &rat) const; operator* and others create a new object that is returned by value

25 Overloading +=,-=,*=,/= as member functions Rational& operator*=(const Rational &rat); Rational& operator/=(const Rational &rat); Rational& operator-=(const Rational &rat); Rational& operator+=(const Rational &rat); operator*= and others modify the existing object and rreturn a reference to that object

26 Overloading == and!= bool operator==(const Rational &rat) const; bool operator!=(const Rational &rat) const; Same approach for >, <, >=, and others

27 Overloading input/output <<, >> class Rational { public: friend ostream& operator<<(ostream &outstream, const Rational &rat); friend istream& operator>>(istream &instream, Rational &rat); Rational class and other sample code at

28 Carrano: Appendix A: Fundamentals Comments 2. Primitive data types: bool, char, int, double 3. Variables 4. Named Constants: const double PI = Enumerations: enum Season {WINTER, SPRING, ; equivalent to const int WINTER = 0; 6. Assignments & Expressions: +, -, *, /, ==, &&,, >, +=, ++, -- explicit type conversions double volume{14.9; std::cout << static_cast<int>(volume); 7. Input/Output using ostream 8. Functions: reference vs value parameters 9. Selection: if, switch, 10. Iteration: while, for, do-while, 11. Arrays - multi-dimensional arrays need fixed size

29 Carrano: Appendix A: Fundamentals Strings 13. Vectors 14. Classes - header vs implementation file 15. Inheritance - to be discussed next week 16. Namespaces using namespace std;

30 Submit Assignment-1 Before next class Readings -- see syllabus Interlude , Interlude 6 Get familiar with Unix -- see resources