//14.1. Basic Concepts
//Exercises Section 14.1
//Exercise 14.1: In what ways does an overloaded operator differ from a
//built - in operator ? In what ways are overloaded operators the same as the
//built - in operators ?
//We can call an overloaded operator function directly.
//An overloaded operator function must either be a member of a class or have at least one parameter of class type.
//A few operators guarantee the order in which operands are evaluated.These overloaded versions of these operators do not preserve order of evaluation and/or short - circuit evaluation, it is usually a bad idea to overload them.
//An overloaded operator has the same precedence and associativity as the corresponding built - in operator.
//Exercise 14.2 : Write declarations for the overloaded input, output, addition,
//and compound - assignment operators for Sales_data.
/*#include <iostream>
#include <string>
using namespace std;
class Sales_data {
friend istream &operator>>(istream &, Sales_data &);
friend ostream &operator<<(ostream &, const Sales_data &);
friend Sales_data operator+(const Sales_data &, const Sales_data &);
public:
Sales_data(const string &s, unsigned n, double p) :
bookNo(s), units_sold(n), revenue(p) { }
Sales_data() : Sales_data("", 0, 0.0) { }
Sales_data(const string &s) : Sales_data(s, 0, 0.0) { }
Sales_data(istream &is);
Sales_data &operator += (const Sales_data &);
string isbn() const { return bookNo; }
private:
inline double avg_price() const;
string bookNo;
unsigned units_sold = 0;
double revenue = 0.0;
};
istream &operator>>(istream &, Sales_data &);
ostream &operator<<(ostream &, const Sales_data &);
Sales_data operator+(const Sales_data &, const Sales_data &);
inline double Sales_data::avg_price() const
{
return units_sold ? revenue / units_sold : 0;
}
#include "ChenHC.h"
using namespace std;
Sales_data::Sales_data(istream &is) : Sales_data()
{
is >> *this;
}
Sales_data &Sales_data::operator+=(const Sales_data &rhs)
{
units_sold += rhs.units_sold;
revenue += rhs.revenue;
return *this;
}
istream &operator>>(istream &is, Sales_data &item)
{
double price = 0.0;
is >> item.bookNo >> item.units_sold >> price;
if (is)
item.revenue = price * item.units_sold;
else
item = Sales_data();
return is;
}
ostream &operator<<(ostream &os, const Sales_data &item)
{
os << item.isbn() << " " << item.units_sold << " " << item.revenue << " " << item.avg_price();
return os;
}
Sales_data operator+(const Sales_data &lhs, const Sales_data &rhs)
{
Sales_data sum = lhs;
sum += rhs;
return sum;
}*/
//Exercise 14.3 : Both string and vector define an overloaded == that can
//be used to compare objects of those types.Assuming svec1 and svec2 are
//vectors that hold strings, identify which version of == is applied in each
//of the following expressions :
(a) "cobble" == "stone"//neither, it matches (char *, char *) better than (const string, const string) version.
(b)svec1[0] == svec2[0]//string
(c) svec1 == svec2//vector
(d) svec1[0] == "stone" //string
//Exercise 14.4: Explain how to decide whether the following should be class
//members :
(a) % //symmetric, non-member
(b) %=//change the objects, member
(c) ++//change the objects, member
(d) ->//=()[]->must be member
(e) <<//non-member ?
(f) &&//symetric, non-member
(g) ==//sysmetric, non-member
(h)()//as (d)
//Exercise 14.5: In exercise 7.40 from § 7.5.1 (p. 291) you wrote a sketch of
//one of the following classes.Decide what, if any, overloaded operators your
//class should provide.
(a)Book
(b) Date
(c) Employee
(d) Vehicle
(e) Object
(f) Tree
#include <iostream>
#include <string>
using namespace std;
class Book {
friend istream& operator>>(istream &, Book &);
friend ostream& operator<<(ostream &, const Book &);
friend bool operator==(const Book &, const Book &);
friend bool operator!=(const Book &, const Book &);
public:
Book() = default;
Book(unsigned no, string name, string author, string pubdate) :
no_(no), name_(name), author_(author), pubdate_(pubdate) { }
Book(istream &in) { in >> *this; }
private:
unsigned no_;
string name_;
string author_;
string pubdate_;
};
istream &operator>>(istream &, Book &);
ostream &operator<<(ostream &, const Book &);
bool operator==(const Book &, const Book &);
bool operator!=(const Book &, const Book &);
#include <iostream>
#include <string>
#include "ChenHC.h"
using namespace std;
istream &operator>>(istream &in, Book &book)
{
in >> book.no_ >> book.name_ >> book.author_ >> book.pubdate_;
return in;
}
ostream &operator<<(ostream &out, const Book &book)
{
out << book.no_ << " " << book.name_ << " " << book.author_ << " " << book.pubdate_;
return out;
}
bool operator==(const Book &lhs, const Book &rhs)
{
return lhs.no_ == rhs.no_;
}
bool operator!=(const Book &lhs, const Book &rhs)
{
return !(lhs.no_ == rhs.no_);
}
int main() {
Book book1(123, "aaa", "bbb", "2016");
Book book2(123, "aaa", "bbb", "2016");
if (book1 == book2) cout << book1 << endl;
return 0;
}
14.1.Basic Concepts
最新推荐文章于 2024-10-08 00:02:21 发布