随手贴点代码记录一下吧，其实啥用没有

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

using namespace std;
void transform(ifstream &mf, ifstream &wf);

int main()
{
    ifstream f1("d:\\m.txt");
    ifstream f2("d:\\t.txt");
    transform(f1,f2);
    return 0;
}

unordered_map<string, string> buildMap(ifstream& fs)
{
    unordered_map<string, string> map;
    string line, key;
    while (fs >> key) {
        getline(fs, line);
        map[key] = line.substr(1);
    }
    return map;
}

string transword(string word, unordered_map<string,string>& map)
{
    auto it = map.find(word);
    return it == map.end() ? word : map[word];
}

void transform(ifstream &mf, ifstream &wf)
{
    unordered_map<string, string> map = buildMap(mf);
    string word, line;
    while (getline(wf, line)) {
        bool head = true;
        istringstream ss(line);
        while (ss >> word) {
            if (head)
                head = false;
            else
                cout << " ";
            cout << transword(word,map);
        }
        cout << endl;
    }
    return;
}

#include <iostream>
#include <map>
#include <string>

using namespace std;
int main()
{
    multimap<string, string> m;
    m = { {"jia","jaa"}, {"yi","yaa"},{"bing","baa"},{"yi","bb"} ,{ "yi","yaa" } ,{ "yi","bb" } };
    //pair<string, string> p = { "yi","bb" };
    //for (auto it = m.find(p.first); (it != m.end()) && (it->first == p.first); )
    //{
    //    if (it->second == p.second)
    //        it = m.erase(it);
    //    else
    //        ++it;
    //}

    string name = m.begin()->first;
    cout << name << ":\n";

    for (const auto &e : m) {
        if (e.first == name)
            cout << e.second << "\t";
        else {
            name = e.first;
            cout << "\n" << name << ": \n";
            cout << e.second << "\t";
        }
    }
    return 0;
}

map<string, vector<int>> m;
auto i = m.find(k);
map<string, vector<int>>::iterator i = m.find(k);

key min
lower_bound m.begin()
upper_bound m.begin()
equal_range pair<m.begin() m.begin()>

key max
lower_bound m.end()
upper_bound m.end()
equal_range pair<m.end() m.end()>

key 
lower_bound m.in()
upper_bound m.in()
equal_range pair<m.in() m.in()>

#include <iostream>
#include <map>
#include <vector>
#include <string>

using namespace std;
int main()
{
    multimap<string, vector<string>> fm;
    string x;
    while ([&x]()->bool {
        std::cout << "Enter 姓?" << endl;
        return (cin >> x&&x != "q");
    }()) {
        std::cout << "Enter 名？" << endl;
        string n;
        auto it = fm.find(x);
        it == fm.cend() ? it = fm.emplace(x,vector<string>()) : it ;
        while (cin >> n&&n != "q")
            it->second.push_back(n);
        cin.clear();
    }
    std::cout << "**********************" << endl;
    for (const auto &s : fm) {
        std::cout << s.first << endl;
        for (const auto &s : s.second) {
            std::cout << s << " ";
            std::cout << endl;
        }
    }
    return 0;
}

#include <iostream>
#include <unordered_map>
#include <string>
#include <algorithm>

std::string sconvert(std::string &s)
{
    auto itl = s.begin();
    while (ispunct(*itl)) {
        ++itl;
    }
    auto itr = s.rbegin();
    while (ispunct(*itr)) {
        ++itr;
    }

    std::string s2(itl, itr.base());
    for (auto &c : s2) {
        if (isupper(c))
            c = tolower(c);
    }

    return s2;
}

int main()
{
    std::unordered_map<std::string, unsigned> wc;
    std::string words;
    while (std::cin >> words) {
        words = sconvert(words);
        //++wc[words];
        auto re = wc.insert({ words,1 });
        if (!re.second)
            ++(re.first->second);
    }
    std::for_each(wc.cbegin(), wc.cend(), [](const std::pair<std::string, unsigned> p) 
    {std::cout << p.first << "\t" << p.second<<std::endl; });
    return 0;
}

#include <vector>
#include <string>
#include <iostream>
#include <utility>
using namespace std;
int main()
{
    vector<string> sv = { "ggg","ere","dfdf","444" };
    vector<int> iv = { 1,3,4 };
    vector<pair<string, int>> v;
    for (int i = 0; i != sv.size() && i != iv.size(); ++i)
        //v.push_back(make_pair(sv[i], iv[i]));
        //v.push_back(pair<string, int>(sv[i], iv[i]));
        v.push_back({ sv[i], iv[i] });
    return 0;
}

#include <vector>
#include <string>
#include <iostream>
#include <sstream>
#include <map>
#include <list>
using namespace std;

int main()
{
    map<string, list<int>> m;
    string line;
    string word;
    int no = 1;
    while (getline(cin, line)) {
        istringstream is(line);
        while (is >> word) {
            m[word].push_back(no);
        }
        ++no;
    }
    for (const auto &e : m) {
        cout << e.first << ":\n";
        for (const auto &i : e.second)
            cout << i << " ";
        cout << endl;
    }
    return 0;
}

#include <vector>
#include <string>
#include <iostream>
using namespace std;

int main()
{
    string word;
    vector<string> v;
    while (cin >> word) {
        if (find(v.cbegin(), v.cend(), word) == v.cend())
            v.push_back(word);
    }
    for (const auto &s : v)
        cout << s << endl;
    return 0;
}

#include <iostream>
#include <map>
#include <vector>
#include <string>

using namespace std;
int main()
{
    map<string, vector<string>> fm;
    string x;
    while ([&x]()->bool {
        cout << "Enter 姓?" << endl;
        return (cin >> x&&x != "q");
    }()) {
        cout << "Enter 名？" << endl;
        string n;
        while (cin >> n&&n != "q")
            fm[x].push_back(n);
        cin.clear();
    }
    cout << "**********************" << endl;
    for (const auto &s : fm) {
        cout << s.first << endl;
        for (const auto &s : s.second) {
            cout << s << " ";
            cout << endl;
        }
    }
    return 0;
}

#include <iostream>
#include <map>
#include <string>
#include <algorithm>

std::string sconvert(std::string &s)
{
    auto itl = s.begin();
    while (ispunct(*itl)) {
        ++itl;
    }
    auto itr = s.rbegin();
    while (ispunct(*itr)) {
        ++itr;
    }

    std::string s2(itl, itr.base());
    for (auto &c : s2) {
        if (isupper(c))
            c = tolower(c);
    }

    return s2;
}

int main()
{
    std::map<std::string, unsigned> wc;
    std::string words;
    while (std::cin >> words) {
        words = sconvert(words);
        ++wc[words];
    }
    std::for_each(wc.cbegin(), wc.cend(), [](const std::pair<std::string, unsigned> p) 
    {std::cout << p.first << "\t" << p.second<<std::endl; });
    return 0;
}

#include <iostream>
#include <list>
#include <string>

using namespace std;

int main()
{
    list<string> v{ "fsfdgdsg","dfsd","sdf","ddddddd","sdf","dfsd","23","343433","23" };
    v.sort();
    cout << v.size() << endl;
    v.unique();
    cout << v.size() << endl;
    for (auto &s : v)
        cout << s << endl;

    return 0;
}

#include <iostream>
#include <vector>
#include <list>
#include <iterator>
#include <algorithm>

int main()
{
    std::vector<int> v{ 1,2,4,0,9 };

    //10.34
    std::ostream_iterator<int> os(std::cout, " ");
    copy(v.rbegin(), v.rend(), os);
    std::cout << std::endl;


    //10.35
    for (auto it = v.cend(); it != v.begin();) {
        std::cout << *--it << " ";
    }
    std::cout << std::endl;

    //10.36
    std::list<int> lt{ 1,2,4,0,9 };
    auto it = std::find(lt.rbegin(), lt.rend(), 0);
    std::cout << *it++ << std::endl;
    std::cout << *it << std::endl;

    //10.37
    std::vector<int> ivec{ 1, 2, 3, 4, 5, 6, 7,8,9,0 };
    std::list<int> l;
    std::reverse_copy(ivec.begin() + 3, ivec.begin() + 7, back_inserter(l));
    for (auto it = l.cbegin(); it != l.cend();++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    return 0;
}

#include <iostream>
#include <algorithm>
#include <vector>
#include <list>
#include <iterator>


int main()
{
    std::vector<int> v1{ 1, 2, 3, 4, 5, 6, 7,8,9 };
    std::list<int> v2;
    std::list<int> v3;
    std::list<int> v4;
    std::list<int> v5;

    copy(v1.begin(), v1.end(), back_inserter(v2));
    copy(v1.begin(), v1.end(), front_inserter(v3));
    copy(v1.begin(), v1.end(), inserter(v4, v4.end()));
    copy(v1.begin(), v1.end(), inserter(v5, v5.begin()));
    for (auto i : v2)
        std::cout << i << std::endl;
    std::cout << std::endl;
    for (auto i : v3)
        std::cout << i << std::endl;
    std::cout << std::endl;
    for (auto i : v4)
        std::cout << i << std::endl;
    std::cout << std::endl;
    for (auto i : v5)
        std::cout << i << std::endl; 
    return 0;
}

#include <iostream>
#include <algorithm>
#include <vector>
#include <list>
#include <string>
#include <functional>

using namespace std;
using namespace placeholders;

bool check_size(int i, const string &s)
{
    return i > s.size();
}

int main()
{
    vector<int> v{ 1,2,3,4,6,4,2 };
    vector<int>::const_iterator it = find_if(v.cbegin(), v.cend(), bind(check_size, _1, "dfd"));
    cout << *it << endl;
    return 0;
}

#include <iostream>
using namespace std;
int main()
{
    int i = 10;

    auto ff=[&i]() {if (i != 0) { --i; return false; }
    else return true; };
    while(!ff())
        cout << i << endl;

    return 0;
}

#include <iostream>
#include <algorithm>
#include <vector>
#include <list>
#include <string>

using namespace std;

int main()
{
    vector<string> v{ "fsfdgdsg","dfsd","sdf","ddddddd","23","343433","34" };
    int sz = 6;
    auto i = count_if(v.cbegin(), v.cend(), [=](const string& s) {return s.size() > sz; });
    cout << i << endl;
    return 0;
}

#include <iostream>
#include <algorithm>
#include <vector>
#include <list>
#include <string>
#include <functional>

using namespace std;
void bigger(vector<string> &v, vector<string>::size_type sz);

int main()
{
    vector<string> v{ "fsfdgdsg","dfsd","sdf","ddddddd","23","343433","34" };
    bigger(v, 6);
    return 0;
}

bool check_size(const string &s, string::size_type sz)
{
    return s.size() >= sz;
}

void bigger(vector<string> &v, vector<string>::size_type sz)
{
    sort(v.begin(), v.end());
    auto it = unique(v.begin(), v.end());
    v.erase(it, v.end());
    //stable_sort(v.begin(), v.end(), [](const string &s1, const string &s2) {return s1.size() < s2.size(); });

    //auto it2 = find_if(v.begin(), v.end(), [sz](const string &s) {return s.size() >= sz; });
    //for_each(it2, v.end(), [](const string &s) {cout << s << " "; });
    auto it2 = stable_partition(v.begin(), v.end(), bind(check_size, placeholders::_1, sz));
    for_each(v.begin(), it2, [](const string &s) {cout << s << " "; });

}

#include <iostream>
#include <algorithm>
#include <vector>
#include <list>
#include <string>

using namespace std;

bool foo(const string &s)
{
    return 5 <= s.size();
}

int main()
{
    vector<string> words = { "23515","555","dfd","12","hello","fddfdfdf","ewreret","23515","555","dfd","12" };
    vector<string>::iterator lin = partition(words.begin(), words.end(), foo);
    for (auto it=words.begin(); it != lin; ++it)
        cout << *it << " ";
    cout << endl;
    return 0;
}

#include <iostream>
#include <algorithm>
#include <vector>
#include <list>
#include <string>
#include <numeric>

using namespace std;
vector<string> elim(istream& is);
void print(vector<string>& v);
bool isShorter(const string& s1, const string& s2);

int main()
{
    vector<string> vec=elim(cin);
    stable_sort(vec.begin(), vec.end(), isShorter);
    print(vec);
    return 0;
}

vector<string> elim(istream& is)
{
    vector<string> v;
    string s;
    while (is >> s)
        v.push_back(s);
    cout << "vector:" << v.size() << endl;
    print(v);

    sort(v.begin(), v.end());
    cout << "sort:" << v.size() << endl;
    print(v);

    auto it = unique(v.begin(), v.end());
    cout << "unique:" << v.size() << endl;
    print(v);

    v.erase(it, v.cend());
    cout << "erase:" << v.size() << endl;
    print(v);

    return v;
}

void print(vector<string>& v)
{
    for (const auto s : v)
        cout << s << " ";
    cout << endl;
    return;
}

bool isShorter(const string& s1, const string& s2)
{
    return s1.size() < s2.size();
}

#include <iostream>
#include <algorithm>
#include <vector>
#include <list>
#include <string>
#include <numeric>
#include <memory>

using namespace std;
shared_ptr<vector<string>> elim(istream& is);
void print(vector<string>& v);
bool isShorter(const string& s1, const string& s2);

int main()
{
    auto vec = elim(cin);
    stable_sort(vec->begin(), vec->end(), isShorter);
    print(*vec);
    return 0;
}

shared_ptr<vector<string>> elim(istream& is)
{
    shared_ptr<vector<string>> v(new vector<string>);
    string s;
    while (is >> s)
        v->push_back(s);
    cout << "vector:" << v->size() << endl;
    print(*v);

    sort(v->begin(), v->end());
    cout << "sort:" << v->size() << endl;
    print(*v);

    auto it = unique(v->begin(), v->end());
    cout << "unique:" << v->size() << endl;
    print(*v);

    v->erase(it, v->cend());
    cout << "erase:" << v->size() << endl;
    print(*v);

    return v;
}

void print(vector<string>& v)
{
    for (const auto s : v)
        cout << s << " ";
    cout << endl;
    return;
}

bool isShorter(const string& s1, const string& s2)
{
    return s1.size() < s2.size();
}