c++ primer案例学习

第十章 泛型算法

消除重复单词
sort函数在头文件中,排序规则为字典序排序。

void elimDups(vector<string> &vec)
{
	sort(vec.begin(), vec.end());
	auto end_unique = unique(vec.begin(), vec.end());
	vec.erase(end_unique, vec.end());
}
// 重新排序，排序规则为先按大小排序，大小相同的按字典序排序。
bool isShorter(const string &s1, const string &s2)
{
	return s1.size() < s2.size();
}
 
void newElimDups(vector<string> &vec)
{
	elimDups(vec);
	stable_sort(vec.begin(),vec.end(),isShorter);
}

/*
* 求大于等于一个给定长度的单词有多少
*/

#include<algorithm>
using namespace std;


void elimDups (vector<string> &words)
{
    // 先排序，以便查找重复单词,sort默认按照字典排序
    sort(words.begin(), words.end());
    // unique重排输入范围，使得每个单词只出现一次
    // 排列在范围的前部，返回指向不重复区域之后一个位置的迭代器
    auto end_unique = unique(words.begin(), words.end());
    // 使用向量操作erase删除重复单词
    words.erase(end_unique, words.end());
}

void biggies (vector<string> &words, vector<string>::size_type sz)
{
    elimDups(words); // words按字典排序，删除重复单词
    // 按照长度排序，长度相同的维持字典序
    stable_sort(words.begin(), words.end(),  // stable_sort 维持相等元素原有顺序
                [](const string &a, const string &b) 
                    { return a.size() < b.size();});
    auto wc = find_if(words.begin(), words.end(),  // find_if查找第一个具有特定大小的元素，返回指向该元素的迭代器
                      [sz](const string &a) 
                      { return a.size() >= sz;});
    // 计算满足size >= sz的单词数目
    auto count = words.end() - wc;
    // 打印长度大于等于sz的单词，每个单词后面接一个空格
    for_each(wc, words.end(),
             [] (const string &s) {cout << s << " " ;});
    cout << endl;
}

第十一章 关联容器

一个单词转换的map
c++ primer P391,第11章

组织结构：

main.cpp

//
// Created by j on 2021/9/25.
//

#include <iostream>
#include <string>
#include <map>
#include <fstream>
#include <sstream>

using namespace std;

//单词转换函数
const string word_Transform(ifstream &map_file, ifstream &input);
//读入规则文件，生成对应的map映射
map<string, string> buildMap(ifstream &map_file);
//转换操作
const string &Transform(const string &word, const map<string, string> &map);

int main()
{
    ifstream file_stream("D:\\code\\clion_Project\\files\\file.txt"); //待转换的文件,ifstream从文件中读取数据
    ifstream map_stream("D:\\code\\clion_Project\\files\\rule.txt");  //规则文件,创建文件流并与文件绑定
    const string result = word_Transform(map_stream, file_stream);
    cout << result;
    return 0;
}

const string word_Transform(ifstream &map_file, ifstream &input)
{
    string result = "";
    map<string, string> trans_map = buildMap(map_file); // 用map抽象文件的翻译规则
    string line;
    // 每次读入一行待转换的文本
    while (getline(input, line)) {
        stringstream ss(line); // 创建istringsteam对象，从string对象中读入数据
        string word;
        bool first_word = true; // 控制是否打印空格
        // 每次取这行文本中的一个单词
        while (ss >> word) {
            if (first_word) {
                first_word = false;
            }
            else {
                result += " "; // 在单词间打印一个空格
            }
            // 转换每个单词
            result += Transform(word, trans_map);
        }
        result += '\n';
    }
    return result; // 完成一行的转换
}

// 读入规则文件，生成对应的map映射
map<string, string> buildMap(ifstream &map_file)
{
    map<string, string> trans_map; //保存转换规则的map
    string key;                    //键
    string value;                  //值
    string line;
    // 读取第一个单词到key，剩下的所有内容读入value
    while (map_file >> key && getline(map_file, value)) {
        if (value.size() > 1) { // 如果有一个号码则大于1（空格加一个有效的号码）
            trans_map[key] = value.substr(1); // 跳过前导空格（getline会读入前面的空格，遇到换行符结束）
        }
        else {
            throw runtime_error("no rule for " + key);
        }
    }
    return trans_map;
}

//转换操作
const string &Transform(const string &word, const map<string, string> &map)
{
    auto map_iter = map.find(word);
    if (map_iter != map.cend()) {
        return map_iter->second;
    } else {
        return word;
    }
}

rule.txt:

brb be right back
k okay?
y why
r are
u you
pic picture
thk thanks!
18r later

file.txt:

where r u
y dont u send me a pic
k thk 18r