《C++ Primer》习题

类的设计

#include <algorithm>
#include <cctype>
#include <cmath>
#include <fstream>
#include <iostream>
#include <iterator>
#include <string>
#include <vector>
using namespace std;

//----------------------------------------
class Person {
friend istream &read(istream &is, Person &p);
friend ostream &print(ostream &os, const Person &p);

private:
string name;
string addr;

public:
Person(const string &n, const string &a) : name(n), addr(a) {}
Person() = default;
Person(istream &is) { read(is, *this); }

string getName() const { return name; }
string getAddr() const { return addr; }
};

istream &read(istream &is, Person &p) {
is >> p.name >> p.addr;
return is;
}
ostream &print(ostream &os, const Person &p) {
os << p.name << " " << p.addr;
return os;
}

//-----------------------------------------
class Screen;

class Window_mgr {
private:
vector<Screen> screens;

public:
using ScreenIndex = vector<Screen>::size_type;
ScreenIndex addScreen(const Screen &);
void clear(ScreenIndex);
};

Window_mgr::ScreenIndex Window_mgr::addScreen(const Screen &s) {
screens.push_back(s);
return screens.size() - 1;
}

//-----------------------------------------
class Screen {
friend void Window_mgr::clear(ScreenIndex);

public:
typedef string::size_type pos;
Screen() = default;
Screen(pos ht, pos wd) : height(ht), width(wd), contents(ht * wd, ' ') {}
Screen(pos ht, pos wd, char c)
: height(ht), width(wd), contents(ht * wd, c) {}

char get() const { return contents[cursor]; }
char get(pos r, pos c) const;
Screen &move(pos r, pos c);
void some_member() const;
pos Size() const;

Screen &set(char c) {
contents[cursor] = c;
return *this;
}
Screen &set(pos r, pos col, char ch) {
contents[r * width + col] = ch;
return *this;
}

void do_display(ostream &os) const { os << contents << endl; }
Screen &dispaly(ostream &os) {
do_display(os);
return *this;
}
const Screen &display(ostream &os) const {
do_display(os);
return *this;
}

private:
pos cursor = 0;
pos height = 0, width = 0;
string contents;
mutable size_t accese_ctr;
};

char Screen::get(pos r, pos c) const {
pos row = r * width;
return contents[row + c];
}

Screen &Screen::move(pos r, pos c) {
pos row = r * width;
cursor = row + c;
return *this;
}

void Screen::some_member() const { ++accese_ctr; }

Screen::pos Screen::Size() const { return width * height; }

void Window_mgr::clear(ScreenIndex i) {
Screen &s = screens[i];
s.contents = string(s.height * s.width, '-');
}

//----------------------------------------
class Sales_data {
friend istream &read(istream &is, Sales_data &item);
friend ostream &print(ostream &os, Sales_data &item);

public:
// Sales_data() = default;
Sales_data(const string &s, unsigned n, double p)
: bookNo(s), units_sold(n), revenue(n * p) {
cout << "constructing" << endl;
}
Sales_data() : Sales_data("a", 0, 0.0f) {
cout << "delegating constructor" << endl;
}
Sales_data(string s) : Sales_data(s, 0, 0.0f) {}
Sales_data(istream &is) : Sales_data() { read(is, *this); }
string isbn() const { return bookNo; }

private:
float avg_price() const { return units_sold > 0 ? revenue / units_sold : 0; }

private:
string bookNo;
unsigned units_sold;
double revenue;
};

istream &read(istream &is, Sales_data &item) {
double price = 0;
is >> item.bookNo >> item.units_sold >> price;
item.revenue = item.units_sold * price;
return is;
}

ostream &print(ostream &os, Sales_data &item) {
os << item.isbn() << " " << item.units_sold << "" << item.revenue << " "
<< item.avg_price() << endl;
return os;
}

//---------------------------------------
class Account {
public:
void caculate() { amount += amount * interestRate; }
static double rate() { return interestRate; }
static void rate(double);

private:
string owner;
double amount;
static double interestRate;
static constexpr double todayRate = 40.2;
static double initRate() { return todayRate; };
};

void Account::rate(double newRate) { interestRate = newRate; }
double Account::interestRate = initRate();

//--------------------------------------
class wy_Date {
public:
wy_Date(const std::string &s);
unsigned year;
unsigned month;
unsigned day;
};

wy_Date::wy_Date(const std::string &s) {
unsigned format = 0;

//! 1/1/1900
if (s.find_first_of("/") != std::string::npos)
format = 0x10;

//! Jan 1, 1900
if (s.find_first_of(",") >= 4 && s.find_first_of(",") != std::string::npos)
format = 0x01;

switch (format) {

//! format = 1/1/1900
case 0x10:
day = std::stoi(s.substr(0, s.find_first_of("/")));
month = std::stoi(s.substr(s.find_first_of("/") + 1,
s.find_first_of("/") - s.find_last_of("/")));
year = std::stoi(s.substr(s.find_last_of("/") + 1, 4));
break;

//! format = January 1, 1900  or Jan 1, 1900
case 0x01:
day = std::stoi(
s.substr(s.find_first_of("1234567890"),
s.find_first_of(",") - s.find_first_of("1234567890")));

if (s.find("Jan") < s.size())
month = 1;
if (s.find("Feb") < s.size())
month = 2;
if (s.find("Mar") < s.size())
month = 3;
if (s.find("Apr") < s.size())
month = 4;
if (s.find("May") < s.size())
month = 5;
if (s.find("Jun") < s.size())
month = 6;
if (s.find("Jul") < s.size())
month = 7;
if (s.find("Aug") < s.size())
month = 8;
if (s.find("Sep") < s.size())
month = 9;
if (s.find("Oct") < s.size())
month = 10;
if (s.find("Nov") < s.size())
month = 11;
if (s.find("Dec") < s.size())
month = 12;

year = std::stoi(s.substr(s.find_last_of(" ") + 1, 4));
break;
}
}

int main() {
Screen myScreen(5, 5, 'X');
const Screen conScreen(5, 5, 'Y');
myScreen.move(4, 0).set('#').dispaly(cout);

// cout << myScreen.Size() << endl;
// cout << endl;
myScreen.display(cout);
// cout << endl;
conScreen.display(cout);
// cout << endl;
Window_mgr manager;
int i = manager.addScreen(myScreen);
int j = manager.addScreen(conScreen);
manager.clear(0);
myScreen.dispaly(cout);
// cout << endl;

Sales_data item("bcd", 2, 5.0);
Sales_data item1;
Sales_data item2 = {"nb1231", 25, 15.99};
print(cout, item2);

Account account;
Account *ap = &account;
// account.initRate();
cout << ap->rate() << endl;
Account acc1;
cout << acc1.rate() << endl;

wy_Date d("99/21/3871");

std::cout << d.day << " " << d.month << " " << d.year << " ";

// double Account::interestRate = initRate();
}

STL操作

#include <algorithm>
#include <cctype>
#include <cmath>
#include <forward_list>
#include <fstream>
#include <iostream>
#include <iterator>
#include <list>
#include <string>
#include <vector>
using namespace std;

void TextToVec(const string FileName, vector<string> &vec) {
ifstream is(FileName);
string buf;
if (is) {
while (getline(is, buf))
vec.push_back(buf);
}
}

void TextToWord(const string FileName, vector<string> &vec) {
ifstream ifs(FileName);
string buf;
if (ifs) {
while (ifs >> buf)
vec.push_back(buf);
}
}

bool Find(vector<int>::iterator begin, vector<int>::iterator end, int n) {

for (; begin != end; begin++) {
if (*begin == n)
return true;
}
if (begin == end)
return false;
}

void insertString(forward_list<string> &flstr, const string &str1,
const string &str2) {
auto curr = flstr.begin();
int flag = 0;
while (curr != flstr.end()) {
if (*curr == str1) {
curr = flstr.insert_after(curr, str2);
flag = 1;
}
curr++;
}
if (!flag)
curr = flstr.insert_after(curr, str2);
}

void Replace(string &s, const string oldVal, const string newVal) {
for (auto beg = s.begin(); beg != s.end(); beg++) {
if (*beg == s.front())
continue;
if (distance(beg, s.end()) < distance(oldVal.begin(), oldVal.end()))
break;
if (string{beg, beg + oldVal.size()} == oldVal) {
auto pos = distance(s.begin(), beg);
/*s.erase(beg, beg + oldVal.size());
s.insert(beg, newVal.begin(), newVal.end());*/
s.replace(beg, beg + oldVal.size(), newVal.begin(), newVal.end());
beg = std::next(s.begin(), pos + newVal.size() - 1);
}
}
}

double cacculate(const vector<string> &vec) {
int sum = 0;
for (auto const &s : vec)
sum += stoi(s);
return sum;
}

int main(int argc, char const *argv[]) {
vector<string> vs = {"my", "name", "is", "zoe"};
double sum = cacculate(vs);
cout << sum << endl;
for (size_t i = 0; i < vs.size(); i++) {
cout << vs[i] << " ";
}
cout << endl;
vs.insert(vs.begin(), "hello");
for (size_t i = 0; i < vs.size(); i++) {
// cout << vs[i] << " ";
}
cout << endl;
list<string> lst;
lst.insert(lst.begin(), vs.begin(), vs.begin() + 2);
for (auto iter = lst.begin(); iter != lst.end(); iter++) {
// cout << *iter << " ";
}
auto result = find(vs.begin(), vs.end(), "zoe");
/*cout << "the position" << (*result)
<< (result == vs.cend() ? "is not present" : "is present") << endl;
int size = vs.size();
cout << size << endl;*/

forward_list<int> flst = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
auto prev = flst.before_begin();
auto curr = flst.begin();
while (curr != flst.end()) {
if (*curr % 2)
curr = flst.erase_after(prev);
else {
prev = curr;
++curr;
}
}
forward_list<string> flstr = {"I",      "love", "my", "cat",
"deeply", "do",   "you"};
string str1{"cat"};
string str2{"dog"};
insertString(flstr, str1, str2);
/*for (auto i = flstr.begin(); i != flstr.end(); i++)
cout << *i << " ";*/
std::vector<std::string> v;
std::string word;

/*while (std::cin >> word) {
v.push_back(word);
std::cout << v.capacity() << "\n";
}*/
string s{"To drive straight thru is a foolish, tho courageous act"};
Replace(s, "thru", "through");
Replace(s, "tho", "though");
std::cout << s << std::endl;
}