数据读进set，进行后处理

#include <iostream>
#include <vector>
#include <cstddef>
#include <string>
#include <sstream>
#include <fstream>
#include <algorithm>
#include <cmath>
#include <set>
#include <limits>
#include <functional>
#include <numeric>

template <class DataType>
void ReadMatFromFile(std::string &filename, std::vector<std::vector<DataType> > &lines_feat) {
    std::ifstream vm_info(filename.c_str());
    std::string lines;
    DataType var;
    std::vector<DataType> row;

    lines_feat.clear();

    while(!vm_info.eof()) {
        getline(vm_info, lines);
        if(lines.empty())
            break;
        std::stringstream stringin(lines);
        row.clear();

        while(stringin >> var) {
            row.push_back(var);
        }
        lines_feat.push_back(row);
    }
}

void ReadStringFromFile(std::string &filename, std::vector<std::string> &in_string) {
    std::ifstream vm_info(filename.c_str());
    std::string lines, var;

    while(!vm_info.eof()) {
        getline(vm_info, lines);
        if(lines.empty())
            break;
        std::stringstream stringin(lines);

        while(stringin >> var) {
            in_string.push_back(var);
        }
    }
}

void ReadDataFromFile(std::string &filename, std::vector<std::string> &lines_feat) {
    std::ifstream vm_info(filename.c_str());
    std::string lines;

    lines_feat.clear();

    while(!vm_info.eof()) {
        getline(vm_info, lines);
        if(lines.empty())
            break;

        lines_feat.push_back(lines);
    }
}

void ReadSetFromFile(std::string &filename, std::set<std::string> &lines_feat) {
    std::ifstream vm_info(filename.c_str());
    std::string lines;

    lines_feat.clear();

    while(!vm_info.eof()) {
        getline(vm_info, lines);
        if(lines.empty())
            break;

        lines_feat.insert(lines);
    }
}

void ProcessSet(std::set<std::string> &s1, std::set<std::string> &s2) {
    std::set<std::string>::const_iterator it=s1.begin(), find_it;

    for(; it!=s1.end(); ++it) {
        find_it=s2.find(*it);
        if(find_it == s2.end()) {
            std::cout<<*it<<", not found.\n";
        }
    }
}

std::string lowerCase(const std::string& s) {
    std::string lower(s);
    for(size_t i=;i<s.length();++i) {
        lower[i]=tolower(lower[i]);
    }
    return lower;
}

std::string letters(const std::string& s) {
    std::string letter;
    for(size_t i=;i<s.length();++i) {
        char ch=s.at(i);
        bool flag=false;
        if((ch>= && ch<=)) {
            ch=ch+;
            flag=true;
        }
        else if((ch>= && ch<=) || (ch>= && ch<=)) {
            flag=true;
        }
        else {
            ;
        }
        if(flag) {
            letter.push_back(ch);
        }
    }
    letter.push_back('\0');
    return letter;
}

template <class T1, class T2>
int MatMultiply(const std::vector<std::vector<T1> > &Mata, const std::vector<std::vector<T2> > &Matb, std::vector<std::vector<T1> > &MatOut) {
    if(Mata.at().size() != Matb.size()) {
        std::cout<<"not match!\n";
        return -;
    }
    for(size_t i=; i<Mata.size(); ++i) {
        for(size_t j=; j<Matb.at().size(); ++j) {
            std::vector<T2> col;
            col.clear();
            for(size_t k=; k<Matb.size(); ++k) {
                col.push_back(Matb.at(k).at(j));
            }
            MatOut.at(i).at(j)=inner_product(Mata.at(i).begin(), Mata.at(i).end(), col.begin(), );
        }
    }
    return ;
}

template <class T1, class T2, class T3>
void outer_product(const std::vector<T1> &inst1, const std::vector<T2> &inst2, std::vector<std::vector<T3> > &out) {
    std::vector<T3> temp_row(inst2.size());

    for(typename::std::vector<T1>::const_iterator it=inst1.begin();it!=inst1.end();++it) {
        transform(inst2.begin(), inst2.end(), temp_row.begin(), bind2nd(std::multiplies<T1>(), *it));
        out.push_back(temp_row);
    }
}

std::vector<std::string> split(const std::string& s, char delimiter) {
    std::vector<std::string> tokens;
    std::string token;
    std::istringstream tokenStream(s);

    while(std::getline(tokenStream, token, delimiter)) {
        tokens.push_back(token);
    }
    return tokens;
}

int stringtoint(const std::string& s) {
    std::istringstream iss(s);
    int num;
    return iss>>num?num:;
}

void printip(const std::string& s) {
    std::vector<std::string> temp, ip_segment;

    temp=split(s, '-');
    ip_segment=split(temp.front(), '.');

    std::string ip_start=ip_segment.back(), ip_end=temp.back();
    int start, end;
    start=stringtoint(ip_start);
    end=stringtoint(ip_end);

    for(size_t i=start;i<=end;++i) {
        std::cout<<ip_segment[]<<"."<<ip_segment[]<<"."<<ip_segment[]<<"."<<i<<"\n";
    }
}

template <class T>
void Display2DVector(std::vector<std::vector<T> > &vv) {
    for(size_t i=;i<vv.size();++i) {
        for(typename::std::vector<T>::const_iterator it=vv.at(i).begin();it!=vv.at(i).end();++it) {
            std::cout<<*it<<" ";
        }
        std::cout<<"\n";
    }
    std::cout<<"--------the total of the 2DVector is "<<vv.size()<<std::endl;
}

int main() {
    std::string file1("iplist1"), file2("iplist2");
    std::set<std::string> s_ip1, s_ip2;

    ReadSetFromFile(file1, s_ip1);
    ReadSetFromFile(file2, s_ip2);

    ProcessSet(s_ip1, s_ip2);

    return ;
}