C++ Primer第5版 第十七章课后练习答案
合集《C++ Primer第5版》 课后练习答案 - 丸子球球 - 博客园 (cnblogs.com)
练习17.1
int main(void) {
std::tuple<int, int, int> nums(10, 20, 30);
return 0;
}
练习17.2
std::tuple<string, vector<string>, std::pair<string, int>> duo;
练习17.3
class TextQuery
{
friend class QueryResult;
public:
TextQuery() :text(new StrVec, DebugDelete("TextQuery::StrVec")), query_words(new map<string, std::shared_ptr<set<size_t>>>, DebugDelete("TextQuery::map<string, std::shared_ptr<set<size_t>>>")) {}
TextQuery(ifstream& ifs);
std::tuple<string, std::shared_ptr<set<size_t>>, std::shared_ptr<StrVec>> query(string s) const;
~TextQuery();
private:
std::shared_ptr <StrVec> text;
std::shared_ptr<map<string, std::shared_ptr<set<size_t>>>> query_words;
};
class QueryResult
{
public:
friend std::ostream& print(std::ostream& os, const QueryResult qr);
using QueryIterator = set<size_t>::iterator;
public:
QueryResult(string& w, std::shared_ptr<set<size_t>> n, std::shared_ptr<StrVec> i) :word(w), nos(new set<size_t>, DebugDelete("QueryResult::set<size_t>")), inputs(new StrVec, DebugDelete("QueryResult::StrVec")) {
nos = n;
inputs = i;
}
~QueryResult();
QueryIterator begin() { return nos->begin(); }
QueryIterator end() { return nos->end(); }
std::shared_ptr <StrVec> get_file() { return inputs; }
private:
string word;
std::shared_ptr<set<size_t>> nos;
std::shared_ptr<StrVec> inputs;
};
QueryResult::~QueryResult()
{
}
inline TextQuery::TextQuery(ifstream& ifs) : text(new StrVec, DebugDelete("TextQuery::StrVec")), query_words(new map<string, std::shared_ptr<set<size_t>>>, DebugDelete("TextQuery::map<string, std::shared_ptr<set<size_t>>>"))
{
size_t size=0;
if (ifs) {
for (string line; getline(ifs, line,'.'); ++size)
{
text->push_back(line);
istringstream iss(line);
size = text->size();
for (string text, word; iss >> text; word.clear()) {
std::remove_copy_if(text.begin(), text.end(),
std::back_inserter(word), ispunct);
// use reference avoid count of shared_ptr add.
auto& nos = (*query_words)[word];
if (!nos) nos.reset(new std::set<size_t>);
nos->insert(size);
}
}
}
}
inline std::tuple<string, std::shared_ptr<set<size_t>>, std::shared_ptr<StrVec>> TextQuery::query(string s) const{
static std::shared_ptr<std::set<size_t>> nodate(new std::set<size_t>,DebugDelete("TextQuery::std::set<size_t>"));
auto found = query_words->find(s);
if (found == query_words->end()) {
cout << s + " is not in the text" << endl;
return std::tuple<string, std::shared_ptr<set<size_t>>, std::shared_ptr<StrVec>>(s, nodate, text);
}
else
return std::tuple<string, std::shared_ptr<set<size_t>>, std::shared_ptr<StrVec>>(s, found->second, text);
}
TextQuery::~TextQuery()
{
}
练习17.4
inline vector<matches> findBook(const vector<vector<Sales_data>>& files, const string& book)
<em id="__mceDel">{
vector<matches>ret;
for (auto it = files.cbegin(); it != files.cend(); ++it)
{
auto found = std::equal_range(it->cbegin(), it->cend(), book,
[](const Sales_data & lhs, const Sales_data & rhs){return lhs.isbn().compare(rhs.isbn()) > 0;}
);
if (found.first != found.second)
ret.push_back(std::make_tuple(it - files.cbegin(), found.first, found.second));
}
return ret;
}
inline void reportResults(std::istream& in, std::ostream& os, const std::vector<std::vector<Sales_data>>& files)
{
std::string s;
while (in >> s)
{
auto trans = findBook(files, s);
if (trans.empty())
{
std::cout << s << " not found in any stores" << std::endl;
continue;
}
for (const auto& store : trans)
os << "store " << std::get<0>(store) << " sales: "
<< std::accumulate(std::get<1>(store), std::get<2>(store), Sales_data(s)) <br /> << std::endl; } <br />} <br /></em>
int main(void) {
Sales_data sales_data1("001-01", 1, 100);
Sales_data sales_data2("001-01", 2, 100);
Sales_data sales_data3("001-02", 2, 80);
std::vector<Sales_data> vs1 = { sales_data1, sales_data3 };
std::vector<Sales_data> vs2 = { sales_data2 };
std::vector<std::vector<Sales_data>> vvs = { vs1, vs2 };
reportResults(std::cin, std::cout, vvs);
return 0;
}
练习17.5
typedef std::pair<vector<Sales_data>::size_type, std::pair<vector<Sales_data>::const_iterator, vector<Sales_data>::const_iterator>>matches;
inline vector<matches> findBook(const vector<vector<Sales_data>>& files, const string& book)
{
vector<matches>ret;
for (auto it = files.cbegin(); it != files.cend(); ++it)
{
auto found = std::equal_range(it->cbegin(), it->cend(), book,
[](const Sales_data & lhs, const Sales_data & rhs){return lhs.isbn().compare(rhs.isbn()) > 0;}
);
if (found.first != found.second)
ret.push_back(std::make_pair(it - files.cbegin(), std::make_pair(found.first, found.second)));
}
return ret;
}
inline void reportResults(std::istream& in, std::ostream& os, const std::vector<std::vector<Sales_data>>& files)
{
std::string s;
while (in >> s)
{
auto trans = findBook(files, s);
if (trans.empty())
{
std::cout << s << " not found in any stores" << std::endl;
continue;
}
for (const auto& store : trans)
os << "store " << std::get<0>(store) << " sales: "
<< std::accumulate(store.second.first, store.second.second, Sales_data(s))
<< std::endl;
}
}
int main(void) {
Sales_data sales_data1("001-01", 1, 100);
Sales_data sales_data2("001-01", 2, 100);
Sales_data sales_data3("001-02", 2, 80);
std::vector<Sales_data> vs1 = { sales_data1, sales_data3 };
std::vector<Sales_data> vs2 = { sales_data2 };
std::vector<std::vector<Sales_data>> vvs = { vs1, vs2 };
reportResults(std::cin, std::cout, vvs);
return 0;
}
练习17.6
struct matches
{
vector<Sales_data>::size_type sz;
vector<Sales_data>::const_iterator beg;
vector<Sales_data>::const_iterator end;
matches(vector<Sales_data>::size_type sz1,vector<Sales_data>::const_iterator beg1,vector<Sales_data>::const_iterator end1):sz(sz1),beg(beg1),end(end1){}
};
inline vector<matches> findBook(const vector<vector<Sales_data>>& files, const string& book)
{
vector<matches>ret;
for (auto it = files.cbegin(); it != files.cend(); ++it)
{
auto found = std::equal_range(it->cbegin(), it->cend(), book,
[](const Sales_data & lhs, const Sales_data & rhs){return lhs.isbn().compare(rhs.isbn()) > 0;}
);
if (found.first != found.second)
ret.emplace_back(it - files.cbegin(), found.first, found.second);
}
return ret;
}
inline void reportResults(std::istream& in, std::ostream& os, const std::vector<std::vector<Sales_data>>& files)
{
std::string s;
while (in >> s)
{
auto trans = findBook(files, s);
if (trans.empty())
{
std::cout << s << " not found in any stores" << std::endl;
continue;
}
for (const auto& store : trans)
os << "store " << store.sz << " sales: "
<< std::accumulate(store.beg, store.end, Sales_data(s))
<< std::endl;
}
}
int main(void) {
Sales_data sales_data1("001-01", 1, 100);
Sales_data sales_data2("001-01", 2, 100);
Sales_data sales_data3("001-02", 2, 80);
std::vector<Sales_data> vs1 = { sales_data1, sales_data3 };
std::vector<Sales_data> vs2 = { sales_data2 };
std::vector<std::vector<Sales_data>> vvs = { vs1, vs2 };
reportResults(std::cin, std::cout, vvs);
return 0;
}
练习17.7
我更倾向tuple来写findBook，因为看起来更易理解
练习17.8
返回的Sales_data中的bookNo成员为空
练习17.9
(a) bitset<64> bitvec(32);
// 0000000000000000000000000000000000000000000000000000000000100000
(b) bitset<32> bv(1010101);
// 00000000000011110110100110110101
(c) string bstr; cin >> bstr; bitset<8> bv(bstr);
// 根据输入的str转换成bitset
练习17.10
int main(void) {
std::vector<int> v = { 1, 2, 3, 5, 8, 13, 21 };
std::bitset<32> bit_arr;
std::bitset<32> bit_arr1;
for (auto i : v) {
bit_arr.set(i);
bit_arr1[i] = bit_arr[i];
}
return 0;
}
练习17.11
练习17.12
练习17.13
template<unsigned N>
class ans_test {
template<unsigned N1, unsigned N2>
friend unsigned test(ans_test<N1>& ans, ans_test<N2>& test);
public:
ans_test(std::string& str):ans(str){}
void update_ans(unsigned pos, bool ans) { ans[pos] = ans; }
std::ostream& operator<<(std::ostream os) { os << ans; return os; }
private:
std::bitset<N>ans;
};
template<unsigned N1, unsigned N2>
unsigned test(ans_test<N1>& ans, ans_test<N2>& test) {
if (N1 != N2) {
throw("试卷题目数量不符");
}
unsigned grade = 0;
for (auto i = 0; i < ans.ans.size(); ++i) {
if (ans.ans[i] == test.ans[i])
++grade;
}
return grade;
}
int main(void) {
std::string s1("0101010101");
std::string s2("0101010111");
ans_test<10> q1(s1);
ans_test<10> q2(s2);
std::cout << test(q1,q2) << std::endl;
return 0;
}
练习17.14
int main(void) {
try {
std::regex r("[[:alnum:]]+\\.(cpp|cxx|cc)$", std::regex::icase);
std::cmatch results;
if (std::regex_search("myfile.cc", results, r))
cout << results.str() << endl;
}
catch (std::regex_error e)
{
cout << e.what() << " code: " << e.code() << endl;
}
return 0;
}
练习17.15
int main(void) {
cout << "请输入一个待检测的单词:";
string str;
try {
std::regex r("[[:alpha:]]*[^c]ei[[:alpha:]]*", std::regex::icase);
while (cin >> str && str != "q") {
if (std::regex_search(str, r))
cout << "该单词符合要求:" << str << endl;
else
cout << "该单词不符合要求:" << str << endl;
}
}
catch (std::regex_error e)
{
cout << e.what() << " code: " << e.code() << endl;
}
return 0;
}
练习17.16
int main(void) {
cout << "请输入一个待检测的单词:";
string str;
try {
std::regex r("[^c]ei", std::regex::icase);
while (cin >> str && str != "q") {
if (std::regex_search(str, r))
cout << "该单词符合要求:" << str << endl;
else
cout << "该单词不符合要求:" << str << endl;
}
}
catch (std::regex_error e)
{
cout << e.what() << " code: " << e.code() << endl;
}
return 0;
}
练习17.17
int main(int argc,char*argv[]) {string str;
ifstream ifs(argv[1]);
try {
std::regex r("[[:alpha:]]*[^c]ei[[:alpha:]]*", std::regex::icase);
while (getline(ifs, str)) {
for (std::sregex_iterator it(str.begin(), str.end(), r), end_it; it != end_it; ++it)
cout << it->str() << endl;
}
}
catch (std::regex_error e)
{
cout << e.what() << " code: " << e.code() << endl;
}
return 0;
}
练习17.18
int main(int argc,char*argv[]) {
string str;
ifstream ifs(argv[1]);
std::vector<std::string> vec{ "neighbor","albeit","beige","feint","heir","reign","their",
"counterfeit","foreign","inveigh","rein","veil","deign",
"forfeit","inveigle","seize","veineiderdown","freight",
"leisure","skein","weigheight","heifer","neigh","sleigh",
"weighteither","height","neighbour","sleight","weirfeign",
"heinous","neither","surfeit","weird" };
try {
std::regex r("[[:alpha:]]*[^c]ei[[:alpha:]]*", std::regex::icase);
while (getline(ifs, str)) {
for (std::sregex_iterator it(str.begin(), str.end(), r), end_it; it != end_it; ++it) {
if (find(vec.begin(), vec.end(), it->str()) != vec.end())
continue;
std::cout << it->str() << std::endl;
}
}
}
catch (std::regex_error e)
{
cout << e.what() << " code: " << e.code() << endl;
}
return 0;
}
练习17.19
如果不匹配，则m[4].str()返回空字符串。此时号码依然是合法的
练习17.20
bool valid(const smatch& m)
{
if (m[1].matched)
return m[3].matched && (m[4].matched == 0 || m[4].str() == " ");
else
return !m[3].matched && m[4].str() == m[6].str();
}
练习17.21
struct PersonInfo
{
string name;
vector<string> phones;
};
bool valid(const std::smatch& m)
{
if (m[1].matched)
return m[3].matched && (m[4].matched == 0 || m[4].str() == " ");
else
return !m[3].matched && m[4].str() == m[6].str();
}
std::vector<std::string> s_split(const std::string& in, const std::string& delim) {
std::regex re{ delim };
return std::vector<std::string> {
std::sregex_token_iterator(in.begin(), in.end(), re, -1),
std::sregex_token_iterator()
};
}
int main(int argc, char* argv[])
{
string line, word;
vector<PersonInfo> people;
istringstream record;
ifstream ifs(argv[1]);
std::regex r("(\\()?(\\d{3})(\\))?([-. ])?(\\d{3})([-. ]?)(\\d{4})");
std::smatch m;
std::string s;
while (getline(ifs, line))
{
record.str(line);
PersonInfo info;
record >> info.name;
while (record >> word)
info.phones.push_back(word);
record.clear();
people.push_back(info);
}
for (const auto& person : people)
{
std::ostringstream formatted, badNums;
for (const auto& ph : person.phones)
{
for (std::sregex_iterator it(ph.begin(), ph.end(), r), end_it; it != end_it; ++it)
if (!valid(*it))
{
badNums << " " << ph;
}
else
formatted << " " << (*it)[2] << " " << (*it)[2] << (*it)[2];
}
if (badNums.str().empty())
cout << person.name << " " << formatted.str() << endl;
else
std::cerr << " input error: " << person.name << " invalid number(s)" << badNums.str() << endl;
}
return 0;
}
练习17.22
struct PersonInfo
{
string name;
vector<string> phones;
};
bool valid(const std::smatch& m)
{
if (m[1].matched)
return m[3].matched && (m[4].matched == 0 || m[4].str() == " ");
else
return !m[3].matched && m[4].str() == m[7].str();
}
std::vector<std::string> s_split(const std::string& in, const std::string& delim) {
std::regex re{ delim };
return std::vector<std::string> {
std::sregex_token_iterator(in.begin(), in.end(), re, -1),
std::sregex_token_iterator()
};
}
int main(int argc, char* argv[])
{
string line, word;
vector<PersonInfo> people;
istringstream record;
ifstream ifs(argv[1]);
std::regex r("(\\()?(\\d{3})(\\))?([-. ])?([ ]*)?(\\d{3})([-. ]?)([ ]*)?(\\d{4})");
std::smatch m;
std::string s;
while (getline(ifs, line))
{
record.str(line);
PersonInfo info;
record >> info.name;
while (record >> word)
info.phones.push_back(word);
record.clear();
people.push_back(info);
}
for (const auto& person : people)
{
std::ostringstream formatted, badNums;
for (const auto& ph : person.phones)
{
for (std::sregex_iterator it(ph.begin(), ph.end(), r), end_it; it != end_it; ++it)
if (!valid(*it))
{
badNums << " " << ph;
}
else
formatted << " " << (*it)[2] << " " << (*it)[2] << (*it)[2];
}
if (badNums.str().empty())
cout << person.name << " " << formatted.str() << endl;
else
std::cerr << " input error: " << person.name << " invalid number(s)" << badNums.str() << endl;
}
return 0;
}
练习17.23
(\\d{5})([-])?(\\d{4})?
练习17.24
int main()
{
std::string phone = "(\\()?(\\d{3})(\\))?([-. ])?(\\d{3})([-. ]?)(\\d{4})";
std::regex r(phone);
std::smatch m;
std::string s;
std::string fmt = "$2.$5.$7";
while (std::getline(std::cin, s))
{
std::cout << std::regex_replace(s, r, fmt) << std::endl;
}
return 0;
}
练习17.25
//tx 908.555.1500 (908)5551500
int main()
{
std::string phone = "(\\()?(\\d{3})(\\))?([-. ])?(\\d{3})([-. ]?)(\\d{4})*";
std::regex r(phone);
std::smatch m;
std::string s;
std::string fmt = "$2.$5.$7";
while(std::getline(std::cin, s))
{
std::smatch result;
std::regex_search(s,result,r);
if(!result.empty())
{
std::cout << result.prefix() << result.format(fmt) << std::endl;
}
else
{
std::cout << "Sorry, No match." << std::endl;
}
}
return 0;
}
练习17.26
#include <iostream>
#include <string>
#include <regex>
bool valid(const std::smatch &m)
{
if(m[1].matched)
return m[3].matched && (m[4].matched == 0 || m[4].str() == " ");
else
return !m[3].matched && m[4].str() == m[7].str();
}
int main()
{
std::string phone = "(\\()?(\\d{3})(\\))?([-. ])?([ ]*)?(\\d{3})([-. ]?)([ ]*)?(\\d{4})";
std::regex r(phone);
std::smatch m;
std::string s;
while(std::getline(std::cin, s))
{
std::vector<std::string> vs;
for(std::sregex_iterator it(s.begin(), s.end(), r), end_it; it != end_it; ++it)
if(valid(*it))
vs.push_back(it->str());
if (vs.size() == 0)
{
std::cout << "no matched number" << std::endl;
}else if(vs.size() == 1)
{
std::cout << vs[0] << std::endl;
}else if(vs.size() >1)
{
for(int i = 1; i < vs.size(); ++i)
std::cout << vs[i] << " ";
std::cout << std::endl;
}
}
return 0;
}
练习17.27
bool valid(const std::smatch &m)
{
if(m[3].matched)
return true;
else
return !m[2].matched;
}
int main()
{
std::string mail = "(\\d{5})([-])?(\\d{4})?";
std::regex r(mail);
std::smatch m;
std::string s;
std::string fmt = "$1-$3";
while(std::getline(std::cin, s))
{
std::cout << std::regex_replace(s, r, fmt) << std::endl;
}
return 0;
}
练习17.28
int main()
{
std::uniform_int_distribution<unsigned>u(0,RAND_MAX);
std::default_random_engine e;
for (auto i = 0; i < 10; ++i)
cout << u(e) << " ";
return 0;
}
练习17.29
练习17.30
void random(size_t cnt) {
std::uniform_int_distribution<unsigned>u(0, RAND_MAX);
std::default_random_engine e;
for (auto i = 0; i < cnt; ++i) {
cout << u(e) << " ";
}
}
void random(size_t cnt,unsigned seed) {
std::uniform_int_distribution<unsigned>u(0, RAND_MAX);
std::default_random_engine e(seed);
for (auto i = 0; i < cnt; ++i) {
cout << u(e) << " ";
}
}
void random(size_t cnt,unsigned seed,unsigned max,unsigned min) {
std::uniform_int_distribution<unsigned>u(min, max);
std::default_random_engine e(seed);
for (auto i = 0; i < cnt; ++i) {
cout << u(e) << " ";
}
}
int main()
{
unsigned seed, max, min;
cin >> seed >> max >> min;
random(10);
cout << endl;
random(10,seed);
cout << endl;
random(10,seed,max,min);
return 0;
}
练习17.31
每次循环都会重置随机数引擎和分布对象，导致每步循环都会生成相同的值
练习17.32
会报错，while条件中用到了resp
练习17.33
const string& transform(const string& s, const map<string, string>& m)
{
auto map_iter = m.find(s);
if (map_iter != m.end()) {
return map_iter->second;
}
// if find the word in map, return the phrase. else return the origin word.
else {
return s;
}
}
unordered_map<string, string> buildMap(ifstream& map_file)
{
unordered_map<string, string> trans_map;
string key, value;
while (map_file >> key && getline(map_file, value)) {
if (value.size() > 1) {
trans_map[key] = value.substr(1); // 去掉value前的空格
}
else {
throw runtime_error("no rules for " + key);
}
}
return trans_map;
}
const string& transform(const string& s, const unordered_map<string, string>& m)
{
static std::default_random_engine e(time(0));
static std::uniform_int_distribution<unsigned> u(0, 1);
auto map_iter = m.find(s);//当find替换成下标运算符，若关键还未在map中，下标操作会插入一个具有给定关键字的元素
if (map_iter != m.end()) {
return string(1,(map_iter->second)[u(e)]);
}
else {
return s;
}
}
void wordTransform(ifstream& map_file, ifstream& input)
{
auto trans_map = buildMap(map_file);
string text;
while (getline(input, text)) {
istringstream stream(text);
string word;
bool first_word = true;
while (stream >> word) {
if (first_word) {
first_word = false;
}
else {
cout << " ";
}
cout << transform(word, trans_map);
}
cout << endl;
}
}
int main(int argc, char* argv[])
{
string transform_file = argv[1];
string input_file = argv[2];
ifstream trans(transform_file);
ifstream input(input_file);
if (trans && input) {
wordTransform(trans, input);
}
else {
cout << "open file error!" << endl;
}
return 0;
}
练习17.34
int main(int argc, char* argv[])
{
cout << "alpha bool values: " << std::boolalpha << true << " " << false
<< "\ndefault bool values: " << std::noboolalpha << true << " " << false << endl;
cout << std::showbase
<< "default: " << 20 << " " << 1024
<< "\nin octal: " << std::oct << 20 << " " << 1024
<< "\nin hex: " << std::hex << 20 << " " << 1024
<< "\nin uppercase hex: " << std::uppercase << 20 << " " << 1024 << std::nouppercase
<< "\nin decimal: " << std::dec << 20 << " " << 1024
<< std::noshowbase << endl;
cout << "Precision: " << cout.precision() << ", Value: " << sqrt(2.0)
<< "\nPrecision: " << cout.precision(12) << ", Value: " << sqrt(2.0)
<< "\nPrecision: " << std::setprecision(3) << cout.precision() << ", Value: " << sqrt(2.0) << endl;
cout << "default format: " << 100 * sqrt(2.0)
<< "\nscientific: " << std::scientific << 100 * sqrt(2.0)
<< "\nfixed decimal:" << std::fixed << 100 * sqrt(2.0)
<< "\nhexadecimal" << std::hexfloat << 100 * sqrt(2.0)
<< "\nuse defaults" << std::defaultfloat << 100 * sqrt(2.0) << endl;
cout << std::showpoint << 10.0 << '\n' << std::noshowpoint << 10.0 << endl;
int i = -16;
double d = 3.14159;
cout << "i: " << std::setw(12) << i << "next col" << '\n'
<< "d: " << std::setw(12) << d << "next col" << '\n';
cout << std::left
<< "i: " << std::setw(12) << i << "next col" << '\n'
<< "d: " << std::setw(12) << d << "next col" << '\n'
<< std::right
<< "i: " << std::setw(12) << i << "next col" << '\n'
<< "d: " << std::setw(12) << d << "next col" << '\n'
<< std::internal
<< "i: " << std::setw(12) << i << "next col" << '\n'
<< "d: " << std::setw(12) << d << "next col" << '\n'
<< std::setfill('#')
<< "i: " << std::setw(12) << i << "next col" << '\n'
<< "d: " << std::setw(12) << d << "next col" << '\n'
<< std::setfill(' ');
char ch;
cin >> std::noskipws;
while (cin >> ch)
cout << ch;
cin >> std::skipws;
return 0;
}
练习17.35
int main(int argc, char* argv[]) {
cout << std::hexfloat << std::uppercase << sqrt(2.0);
}
练习17.36
int main(int argc, char* argv[]) {
cout << std::hexfloat << std::uppercase << std::setw(12) << sqrt(2.0) << '\n'
<< std::hexfloat << std::uppercase << std::setw(12) << sqrt(3.0) << '\n'
<< std::hexfloat << std::uppercase << std::setw(12) << sqrt(4.0) << '\n'
<< std::hexfloat << std::uppercase << std::setw(12) << sqrt(5.0) << '\n';
}
练习17.37
int main(int argc, char* argv[]) {
std::fstream fs(argv[1]);
char tmp[200];
while (fs.getline(tmp, 200, '\n')) {
std::cout << tmp << std::endl;
std::cout << fs.gcount() << std::endl;
}
}
练习17.38
int main(int argc, char* argv[]) {
std::fstream fs(argv[1]);
char tmp[200];
while (fs.getline(tmp, 200, '\n')) {
std::cout << tmp << std::endl;
//std::cout << fs.gcount() << std::endl;
}
}
练习17.39
int main(int argc, char* argv[])
{
std::fstream inOut(argv[1], std::fstream::ate | std::fstream::in | std::fstream::out);
if (!inOut)
{
std::cerr << "Unable to open file!" << std::endl;
return EXIT_FAILURE;
}
auto end_mark = inOut.tellg();
inOut.seekg(0, std::fstream::beg);
size_t cnt = 0;
std::string line;
while (inOut && inOut.tellg() != end_mark && getline(inOut, line))
{
cnt += line.size() + 1;
auto mark = inOut.tellg();
inOut.seekp(0, std::fstream::end);
inOut << cnt;
if (mark != end_mark) inOut << " ";
inOut.seekg(mark);
}
inOut.seekp(0, std::fstream::end);
inOut << "\n";
return 0;
}
