YOY_

C++ Primer 第五版部分课后题答案

当时刚学C++的时候买了这本书，一开始前面看的一知半解，索性就先缓缓，等学完学校的C++课程（中途自己也写了不少c++的代码），一段时间之后又拿起这本书去看，感觉还是挺有滋味的，这本书对我印象中的C++做了很大的扩展，个人认为这本书不太适合刚学C++就去看，而是写了一定的代码，对C++有一个大体的了解之后再去看会别有一番滋味(犇请无视这句话)。在看书的过程中自己也写了上面的课后练习题，现在整理一下，也跟大家分享一下，下面是9~12 15~16章的课后题编程题的答案

（第八章之前的都没保存/(ㄒoㄒ)/~~）：

当时保存的时候是按节保存的,比如练习9.3、练习9.4 练习9.5、练习9.6 是在9.2.1节练习里面的题

9.2.1节练习：

#include 
#include 

std::vector::iterator fun(std::vector::iterator isb,std::vector::iterator ise,int y){
    while(isb s={1,2,3};
    std::vector::iterator is=s.begin();
    //if(fun(is,s.end(),2)) cout<<"OK"<

9.3.1节练习：

#include 
#include 
#include 
#include 

int main()
{
    std::string temp;
    std::dequedq;
    for(int i=1;i<=3;++i){
        std::cin>>temp;
        dq.push_front(temp);
    }
    auto x=dq.begin(); //std::deque::iterator x;
    while(x < dq.end() && std::cout<<" "<<*(x++));
    std::cout<l;
    for(int i=1;i<=3;++i){
        std::cin>>temp;
        l.push_front(temp);
    }
    auto y=l.begin();
    while(y!=l.end() && std::cout<<" "<<*(y++)); //list中无 > <操作 使用!=代替
    std::cout<



 9.3.3节练习：


#include 
#include 
#include 
#include 

int main()
{
    int ia[]={0,1,1,2,3,5,8,13,21,55,89};
    std::vector vec={0,1,1,2,3,5,8,13,21,55,89};
    std::list lis={0,1,1,2,3,5,8,13,21,55,89};

    auto i=vec.begin();
    while(i!=vec.end())
        if(*i % 2)i=vec.erase(i);
        else i++;

    auto j=lis.begin();
    while(j!=lis.end())
        if(*j % 2==0)j=lis.erase(j);
        else j++;

    for(auto x:vec) std::cout<<" "<


 9.5.3节练习：

练习9.47：

#include 
#include 


int main()
{
    std::string temp("ab2c3d7R4");
    std::string digit("0123456789");
    std::string word;
    for(int i=0;i<24;++i){
        word+=(char)('a'+i);
        word+=(char)('A'+i);
    }
    std::string::size_type pos=0;
    while((pos=temp.find_first_of(word,pos))!=std::string::npos) std::cout<


 练习9.49:


#include 

int main()
{
    std::string temp("bdfghijklpqty");
    std::string s;
    while(std::cin>>s){
        std::string::size_type pos=0;
        while((pos=s.find_first_not_of(temp,pos))!=std::string::npos)std::cout<


 练习9.50：


#include 
#include 

int main()
{
    std::vector vec={"1","2","3","4","5"};
    int sum1=0;
    for(auto x:vec) sum1+=stoi(x);  //codeblock（12.11）报错，vs2012也报，本汪编译器不支持
    std::cout<
练习9.51：


#include 

class A{
    public :
        A(const std::string s="10/12/1994"){
            std::string sign=" ,/";
            auto pos=s.find_first_of(sign);
            month=s.substr(0,pos);
            day=s.substr(pos+1,s.find_first_of(sign,pos+1)-pos-1);
            year=s.substr(s.find_last_of(sign)+1);
        }
        void print(){
            std::cout<
#include 
#include 
#include 
#include 
#include 
#include 

using namespace std;
int main()
{
    int a1[]={1,2,3,4,5,6};
    int a2[sizeof(a1)/sizeof(a1)];
    auto ret=copy(begin(a1),end(a1),begin(a2));

    return 0;
}

*/


 练习10.1：


#include 
#include 
#include 
#include 
#include 

using namespace std;
int main()
{
    std::vector vec={1,2,3,4,5,6,7,12,3,4,6,7,3,6,9,2,6,3,3,3,3,3,3};
    std::cout< lis={"q","e","sdg","zvgs","123g","545","qwe","uyt","qwe"};
    std::cout<


 10.2.1节练习：


/*
#include 
#include 
#include 
#include 
#include 

using namespace std;

class A{
    public :
        A(const string s="1/1/1990"):month("jan"),day("1"),year("1994"){
            string sign=" ,/";
            auto pos=s.find_first_of(sign);
            month=s.substr(0,pos);
            day=s.substr(pos+1,s.find_first_of(sign,pos+1)-pos-1);
            year=s.substr(s.find_last_of(sign)+1);
        }
        void print(){
            cout<
#include 
#include 
#include 
int main()
{
    std::vector vec={1,2,3,4,5,6,7,8,9};
    std::cout< vec_str={"a","b","c","d"};
    std::cout<
10.2.2节练习：


#include 
#include 
#include 
#include 
#include 

int main()
{
//10.6
    int num[]={1,2,3,4,5,6};
    std::fill_n(std::begin(num),std::end(num)-std::begin(num),0);
    for(auto x:num) std::cout< vec;
    std::listlst;
    int i;
    while(std::cin>>i) lst.push_back(i);
    std::copy(lst.cbegin(),lst.cend(),back_inserter(vec)); //vec未申请空间，所以使用插入迭代器
    for(auto x:vec) std::cout< vecc;
    vecc.reserve(10);
    //虽然分配了内存 但size()=0 vecc.begin()==vecc.end() capacity()=10
    std::fill_n(vecc.begin(),10,0);
    for(auto x:vecc) std::cout<
10.2.3节练习：


#include 
#include 
#include 
#include 
#include 

void elimDups(std::vector &vec){
    std::sort(vec.begin(),vec.end());
    auto uni=std::unique(vec.begin(),vec.end()); //把重复单词忘末尾放，返回指向不重复范围的后一个迭代器
    vec.erase(uni,vec.end());
    for(auto x:vec) std::cout< vec={"the","quick","red","fox","jumps","over","the","slow","red","turtle"};
    elimDups(vec);
    return 0;
}
// the quick red fox jumps over the slow red turtle
10.3.1节练习：


#include 
#include 
#include 
#include 
#include 

void elimDups(std::vector &vec){
    std::sort(vec.begin(),vec.end());
    auto uni=std::unique(vec.begin(),vec.end()); //把重复单词忘末尾放，返回指向不重复范围的后一个迭代器
    vec.erase(uni,vec.end());
    for(auto x:vec) std::cout< vec={"the","quick","red","fox","jumps","over","the","slow","red","turtle"};
    elimDups(vec);
    std::stable_sort(vec.begin(),vec.end(),isShortter);
    for(auto x:vec) std::cout<


 10.3.2节练习：

练习10.16：

#include 
#include 
#include 

void elimDups(std::vector &vec){
    std::sort(vec.begin(),vec.end());
    auto uni=std::unique(vec.begin(),vec.end()); //把重复单词忘末尾放，返回指向不重复范围的后一个迭代器
    vec.erase(uni,vec.end());
    std::cout<<"after unique_sort and erase :"<>x>>y;
    auto fun2=[x](const int y){return x+y;};
    std::cout< vec={"the","quick","red","fox","jumps","over","the","slow","red","turtle"};
    elimDups(vec);
    std::stable_sort(vec.begin(),vec.end(),[](const std::string &a,const std::string &b){return a.size()>n;
    auto iter=find_if(vec.begin(),vec.end(),
                      [n](const std::string &s){
                            return s.size()>=n;
                        });
    auto count=vec.end()-iter;
    for_each(iter,vec.end(),[](const std::string &s){std::cout<
练习10.18：


#include 
#include 
#include 


void elimDups(std::vector &vec){
    std::sort(vec.begin(),vec.end());
    auto uni=std::unique(vec.begin(),vec.end()); //把重复单词忘末尾放，返回指向不重复范围的后一个迭代器
    vec.erase(uni,vec.end());
    std::cout<<"after unique_sort and erase :"< vec={"the","quick","red","fox","jumps","over","the","slow","red","turtle"};
    elimDups(vec);
    stable_sort(vec.begin(),vec.end(),[](const std::string &a,const std::string &b){return a.size()>n;
    auto iter=partition(vec.begin(),vec.end(),
                      [n](const std::string &s){
                            return s.size()
10.3.3节练习：


#include 
#include 
#include 

int main()
{
    std::vector vec={"the","quick","red","fox","jumps","over","the","slow","red","turtle"};
    auto x=count_if(vec.begin(),vec.end(),[](const std::string &s){
                    return s.size()>=6;});
    std::cout<


 10.3.4节练习：


#include 
#include 
#include 
#include 

using namespace std::placeholders; // bind_n操作

bool check_size(const int &x,std::string::size_type sz){return x>=sz;}

int main()
{
    std::vector vec={1,3,6,8,0,3,5,12,4,2};
    std::string s="woqu";
    auto f=bind(check_size,_1,s.size());
    for(auto x:vec)
        if(f(x)){
            std::cout<
10.4.1节练习：


#include 
#include 
#include 
#include 
#include 

int main()
{
//10.27
    std::list lst={1,2,2,2,2,2,2,2,6,8};
    std::list lst1;
    unique_copy(lst.begin(),lst.end(),back_inserter(lst1));
    std::cout<<"old array:";
    for_each(lst.begin(),lst.end(),[](const int &x){std::cout< vec={1,2,3,4,5,6,7,8,9};
    std::vector  front_vec,back_vec,rand_vec;
    auto iter=vec.begin();
    //copy(vec.begin(),vec.end(),front_inserter(front_vec));
    copy(vec.begin(),vec.end(),back_inserter(back_vec));
    copy(vec.begin(),vec.end(),inserter(vec,iter));
   // std::cout<<"front:";
    //for_each(front_vec.begin(),front_vec.end(),[](const int &x){std::cout<
10.4.2节练习：


#include 
#include 
#include 
#include 
#include 

//10.33
void fun(const std::string &inf_file,const std::string &outf1_file,const std::string &outf2_file){
    std::ifstream inf;
    inf.open(inf_file);
    std::istream_iterator inf_iter(inf),eof;

    std::ofstream outf1;
    outf1.open(outf1_file);
    std::ofstream outf2;
    outf2.open(outf2_file);

    std::ostream_iterator outf1_iter(outf1),outf2_iter(outf2);
    while(inf_iter!=eof){
        if((*inf_iter)%2) outf1<<*inf_iter;
        else outf2<<*inf_iter;
        inf_iter++;
    }
    std::cout<<"从文件\""< in_iter(inf); //in_ter 从文件流inf中读取类型为std::string的值
    std::istream_iterator eof;  //文件结束位置
    std::vector vec(in_iter,eof); //把文件的字符串读入vec中
    auto iter=vec.begin();
    while(iter!=vec.end()) std::cout<<*iter++<<" ";
    std::cout< in(std::cin); //in从输入流cin中读取类型为int的值
    std::istream_iterator eof2;  //输入流结束位置
    std::vector vec2(in,eof2);   //输入的数据读入vec2
    sort(vec2.begin(),vec2.end()); //排序
    std::ostream_iterator out(std::cout," ");  //把类型为int的值写到输出流out中，每个值后加空格
    copy(vec2.begin(),vec2.end(),out);//vec2的值读出到out中
    std::cout< out2(std::cout," ");
    unique_copy(vec2.begin(),vec2.end(),out2); //不重复的复制
    std::cout<
10.4.3节练习：


#include 
#include 
#include 
#include 
#include 

int main()
{
    //10.34 10.35
    std::vector  vec={1,2,3,4,5,6,7,8,9};
    std::vector::reverse_iterator reiter=vec.rbegin(); //反向迭代器
    while(reiter!=vec.rend()) std::cout<<*reiter++<<" ";
    std::cout<::iterator iter=vec.begin();    //普通迭代器
    while(iter!=vec.end()) std::cout<<*iter++<<" ";
    std::cout< lis={1,2,3,0,6,4,0,1,3,2}; //查找最后一个0，返回其迭代器
    std::list::reverse_iterator lis_reiter=find(lis.rbegin(),lis.rend(),0);
    std::cout<<*lis_reiter< vec2={1,2,3,4,5,6,7,8,9,10}; // 取其中 3~7 的位置复制给std::list
    std::list  lis2;
    auto vec2_iter=vec2.begin();
    copy(vec2_iter+2,vec2_iter+7,back_inserter(lis2));//后插迭代器实现

    for(auto x:lis2) std::cout<
11.1.1节练习：


#include 
#include 
#include 
#include 

//algorithm提供的string转换字母大小写函数写法
std::string fun(std::string &s){
    transform(s.begin(),s.end(),s.begin(), ::tolower);
    std::string s2;
    for(auto x:s) if(islower(x)) s2+=x; //去标点
    return s2;
}
int main()
{
    std::map m;
    std::string word;
    while(std::cin>>word && word!="end") m[fun(word)]++;

    for(const auto &x:m)
        std::cout<


 11.2.1节练习：


#include 
#include 
#include 
#include 


int main()
{
    std::map > name;
    std::string first_name,last_name;
    while(std::cin>>first_name>>last_name && first_name!="end")
        (name[first_name]).push_back(last_name);

    for(auto x:name){
        std::cout<
11.2.3节练习~练习11.12、练习11.13：


#include 
#include 
#include 
#include 
#include 

int main()
{
    //11.12 11.13
    std::vector  > vec1,vec2,vec3;
    std::pair pa;
    while(std::cin>>pa.first>>pa.second){
        vec1.push_back({pa.first,pa.second});
        vec2.push_back(std::pair(pa.first,pa.second));
        vec3.push_back(pa);
    }
    for(auto x:vec1) std::cout<
练习11.14：


#include 
#include 
#include 
#include  //pair
#include 

int main()
{
    //11.14
    std::map > > name;
    std::string first_name;
    std::pair last_name;
    while(std::cin>>first_name>>last_name.first>>last_name.second && first_name!="end")
        (name[first_name]).push_back(last_name);

    for(auto x:name){
        std::cout<
11.3.2节练习：


#include 
#include 
#include 

int main()
{
    //11.20
    std::map word_count;
    std::string word;
    while(std::cin>>word && word!="end"){
        std::pair< std::map::iterator,bool> ite=word_count.insert({word,1});
        if(!ite.second) ite.first->second++;
    }
    for(auto x:word_count)
         std::cout< name;
    std::string first_name,last_name;
    while(std::cin>>first_name>>last_name && first_name!="end")
        name.insert({first_name,last_name});

    for(auto x:name)
        std::cout<
11.3.5节练习：


#include 
#include 
#include 
#include 
#include 
#include 

int main()
{
    //11.31
    std::multimap book={{"oyy","c++ prime"},
                                    {"oyy","java plus"},
                                    {"oyy","english"},
                                    {"awei","math"},
                                    {"awei","computer"},
                                    {"baobao","taijiong"},
                                    {"baobao","gangjiong"},
                                    };
    std::string find_name="baoba";
    auto ite=book.find(find_name);
    while(ite!=book.end() && ite->first==find_name){
        ite=book.erase(ite);
    }
    for(auto x:book) std::cout<
11.3.6节练习：


#include 
#include 
#include 
#include 

int main()
{
//11.33
    //读取转换规则
    std::ifstream readfile("test1.txt");
    std::map tran;
    std::string word_first,word_second,temp;
    while(readfile>>word_first && getline(readfile,word_second))
        tran[word_first]=word_second.length()==0?word_first:word_second.substr(1);

    //读取要转的内容
    std::ifstream readfile2("test2.txt");
    std::string sentc,word;
    while(getline(readfile2,sentc)){
        std::istringstream in(sentc);
        while(in>>word){
            if(tran.find(word)!=tran.end()) std::cout<


 12.1.1节练习：


#include 
#include 
#include 
#include 
#include 

//12.2
class StrBlob{

typedef std::vector  vstring;

public:
    StrBlob():data(std::make_shared()){}
    StrBlob(std::initializer_list lis):data(std::make_shared(lis)){}
    vstring::size_type size()const {return data->size();}
    void push_back(const std::string &s){data->push_back(s);}
    void pop_back(){
        check(0,"pop on empty StrBlob");
        data->pop_back();
    }
    std::string &front(){
        check(0,"front on empty StrBlob");
        return data->front();
    }
    std::string &back(){
        check(0,"back on empty StrBlob");
        return data->back();
    }

private:
    std::shared_ptr data; // emory
    void check(vstring::size_type i,const std::string &s)const {
        if(data->size()<=i) throw std::out_of_range(s); // stdexcept
    }
};
int main()
{
    //12.1
    StrBlob b1{};
    {
        StrBlob b2={"a","an","the"};
        b1=b2;
        b2.push_back("about");
    }
    std::cout<
12.1.2节练习：


#include 
#include 
#include 

//12.6
std::vector *new_vecint(){
    return new std::vector;
}
void read_data(std::istream &in,std::vector *&pv){ //普通指针 引用指针
    int x;
    in>>x;
    pv->push_back(x);
}

void print(std::vector *&pv){
    for(auto x:*pv) std::cout< > ptr_vecint(){ //智能指针
    return std::make_shared > ();
    //return  shared_ptr> (new vector(p));
}

void ptr_read_data(std::istream &in,std::shared_ptr > &spv){
    int x;
    in>>x;
    spv->push_back(x);
}
void ptr_print(std::shared_ptr > spv){
    for(auto x:*spv) std::cout<
12.1.6节练习：


#include 
#include 
#include 
#include 
#include 
#include 
#include 

class StrBlob{
typedef std::vector  vstring;
public:
    friend class StrBlobPtr;
    StrBlob():data(std::make_shared()){}
    StrBlob(std::initializer_list lis):data(std::make_shared(lis)){}
    vstring::size_type size()const {return data->size();}
    void push_back(const std::string &s){data->push_back(s);}
    void pop_back(){
        check(0,"pop on empty StrBlob");
        data->pop_back();
    }
    std::string &front(){
        check(0,"front on empty StrBlob");
        return data->front();
    }
    std::string &back(){
        check(0,"back on empty StrBlob");
        return data->back();
    }
private:
    std::shared_ptr data; // memory
    void check(vstring::size_type i,const std::string &s)const {
        if(data->size()<=i) throw std::out_of_range(s); //stdexcept
    }
};
//12.19 12.20
class StrBlobPtr{
typedef std::vector  vstring;
public :
    StrBlobPtr():curr(0){}
    StrBlobPtr(StrBlob &a,size_t sz=0):wptr(a.data),curr(sz){}
    std::string &deref() const {
        auto p=check(curr,"dereference past end");
        return (*p)[curr];
    }
    StrBlobPtr& incur(){
        check(curr,"increment past end of StrBlobPtr");
        ++curr;
        return *this;
    }
    bool empty(){
        if(curr < wptr.lock()->size()) return false;
        return true;
    }
private:
    std::shared_ptr check(size_t i,const std::string &msg)const {
        auto ret=wptr.lock();
        if(!ret) throw std::runtime_error("unbound StrBlobPtr");
        if(ret->size() <= i)
            throw std::out_of_range(msg);
        return ret;
    }
    std::weak_ptr wptr;
    size_t curr;
};

int main()
{
    //12.20
    std::ifstream in("in.txt");
    std::string word_s;
    StrBlob sb;
    while(getline(in,word_s)){   //从文件读入数据
        std::stringstream sin(word_s);
        std::string word;
        while(sin>>word) sb.push_back(word);
        sb.push_back("\n");
    }

    StrBlobPtr sbp(sb);  //使用StrBlob 指针类型输出StrBlob
    while(!sbp.empty()){
        std::cout<
12.2.1节练习：


#include 
#include 
#include 
#include 
#include 

int main()
{
    //12.23
    char sc1[]="woqu",sc2[]=" nimeide";
    char *q=new char[strlen(sc1)+strlen(sc2)+1];
    strcpy(q,sc1);
    strcat(q,sc2);
    std::cout<> size;
    char* input = new char[size + 1]();
    std::cin.ignore(); //读取多余回车
    std::cout << "input the string: ";
    std::cin.get(input, size + 1);
    std::cout << input;
    delete[] input;

    return 0;
}


 12.2.2节练习：



#include 
#include 

//12.26
int main()
{
    int n;
    std::cout<<"please input size:";
    std::cin>>n;
    std::cin.ignore();
    std::allocator t;  //定义类型对象
    auto const p = t.allocate(n); //申请内存
    auto q=p;
    std::string word;
    while(q!=p+n && std::cin>>word) t.construct(q++,word); //调用构造函数
    while(q!=p){
        std::cout<<*--q<
12.3.1节练习：


#include 
#include 
#include 
#include 
#include 
#include 
#include 

//12.28
typedef std::vector::size_type line;

int main()
{
    std::vector text;
    std::map > sign;
    std::string file_name;
    std::cout<<"enter file name : "<>file_name;
    std::cin.ignore();
    std::ifstream file_input(file_name);
    std::string senten,word;

    while(getline(file_input,senten)){ //读入文件内容
        text.push_back(senten);
        std::stringstream word_in(senten);
        line len=text.size();
        while(word_in>>word) sign[word].insert(len);
    }

    while(true){  //查询
        std::cout<<"enter the query word and enter q to quit : ";
        std::cin>>word;
        std::cin.ignore();
        if(word=="q") break;
        auto loc=sign.find(word);
        if(loc==sign.cend()) std::cout<<"not find "<second)
                std::cout<<"(line "<
12.3.2节练习：

练习12.30：

#include 
#include 
#include 
#include 
#include 
#include 
#include 
//12.30 同12.27
class TextQuery;
class QueryResult;
using line=std::vector::size_type;
//文件查询类，存错整个文件内容 以及每个单词出现的行数   定义查询函数返回一个查询结果类
class TextQuery{
public :
    //构造函数 获取一个文件输入对象 构造 sign p_text
    TextQuery(std::ifstream& in):p_text(new std::vector){
        std::string senten;  //读取每行的句子
        while(getline(in,senten)){
            p_text->push_back(senten);
            auto len=p_text->size();
            std::stringstream word_in(senten);
            std::string word;
            while(word_in>>word){
                auto isok=sign.find(word);
                 //若该单词还为出现过，申请新的空间
                if(isok==sign.cend()) sign[word].reset(new std::set);
                sign[word]->insert(len);
            }
        }
    }
     //该函数的定义必须在QueryResult 完整定义后定义，这里只做声明
    QueryResult query(const std::string &s)const ;
private :
    std::shared_ptr > p_text;  //存内容
    std::map > > sign; //存每个单词所在行位置数
};

//查询结果类 包括查询的单词 以及该单词所在的所有行数 单词所在行的句子(即必须获取所有内容)
class QueryResult{
private:
    std::string word;   //查询的单词
    std::shared_ptr > p_line; //该单词的行号
    std::shared_ptr >p_text; //存句子
public :
    //print要使用里面的成员
    friend std::ostream& print(std::ostream& out,const QueryResult& qr);
    QueryResult(std::string s,
                std::shared_ptr > pl,
                std::shared_ptr > pv):
                word(s),p_line(pl),p_text(pv){}
};
QueryResult TextQuery::query(const std::string &s)const{
    std::shared_ptr > null_ptr(new std::set );
    auto isok=sign.find(s);
    //若未找到，返回第二个参数为新申请的初始化的空间
    if(isok==sign.cend()) return QueryResult(s,null_ptr,p_text);
    else return QueryResult(s,isok->second,p_text);
}
std::ostream& print(std::ostream& out,const QueryResult &qr){
    out<at(x-1)<>s) || s=="q") break;
        print(std::cout,tq.query(s))<
练习12.32：


#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
//12.32
class StrBlob{

typedef std::vector  vstring;

public:
    StrBlob():data(std::make_shared()){}
    StrBlob(std::initializer_list lis):data(std::make_shared(lis)){}
    vstring::size_type size()const {return data->size();}
    void push_back(const std::string &s){data->push_back(s);}
    void pop_back(){
        check(0,"pop on empty StrBlob");
        data->pop_back();
    }
    std::string &front(){
        check(0,"front on empty StrBlob");
        return data->front();
    }
    std::string &back(){
        check(0,"back on empty StrBlob");
        return data->back();
    }
    std::string at(int x){
        return data->at(x);
    }
private:
    std::shared_ptr data; // emory
    void check(vstring::size_type i,const std::string &s)const {
        if(data->size()<=i) throw std::out_of_range(s); // stdexcept
    }
};

class TextQuery;
class QueryResult;
using line=std::vector::size_type;
//文件查询类，存错整个文件内容 以及每个单词出现的行数   定义查询函数返回一个查询结果类
class TextQuery{
public :
    //构造函数 获取一个文件输入对象 构造 sign p_text
    TextQuery(std::ifstream& in):p_text(new StrBlob){
        std::string senten;  //读取每行的句子
        while(getline(in,senten)){
            p_text->push_back(senten);
            auto len=p_text->size();
            std::stringstream word_in(senten);
            std::string word;
            while(word_in>>word){
                auto isok=sign.find(word);
                 //若该单词还为出现过，申请新的空间
                if(isok==sign.cend()) sign[word].reset(new std::set);
                sign[word]->insert(len);
            }
        }
    }
     //该函数的定义必须在QueryResult 完整定义后定义，这里只做声明
    QueryResult query(const std::string &s)const ;
private :
    std::shared_ptr p_text;  //存内容
    std::map > > sign; //存每个单词所在行位置数
};

//查询结果类 包括查询的单词 以及该单词所在的所有行数 单词所在行的句子(即必须获取所有内容)
class QueryResult{
private:
    std::string word;   //查询的单词
    std::shared_ptr > p_line; //该单词的行号
    std::shared_ptrp_text; //存句子
public :
    //print要使用里面的成员
    friend std::ostream& print(std::ostream& out,const QueryResult& qr);
    QueryResult(std::string s,
                std::shared_ptr > pl,
                std::shared_ptr pv):
                word(s),p_line(pl),p_text(pv){}
};
QueryResult TextQuery::query(const std::string &s)const{
    std::shared_ptr > null_ptr(new std::set );
    auto isok=sign.find(s);
    //若未找到，返回第二个参数为新申请的初始化的空间
    if(isok==sign.cend()) return QueryResult(s,null_ptr,p_text);
    else return QueryResult(s,isok->second,p_text);
}
std::ostream& print(std::ostream& out,const QueryResult &qr){
    out<at(x-1)<>s) || s=="q") break;
        print(std::cout,tq.query(s))<
练习12.33：


#include 
#include 
#include 
#include 
#include 
#include 
#include 
//12.30 同12.27

class TextQuery;
class QueryResult;
using line=std::vector::size_type;
//文件查询类，存错整个文件内容 以及每个单词出现的行数   定义查询函数返回一个查询结果类
class TextQuery{
public :
    //构造函数 获取一个文件输入对象 构造 sign p_text
    TextQuery(std::ifstream& in):p_text(new std::vector){
        std::string senten;  //读取每行的句子
        while(getline(in,senten)){
            p_text->push_back(senten);
            auto len=p_text->size();
            std::stringstream word_in(senten);
            std::string word;
            while(word_in>>word){
                auto isok=sign.find(word);
                 //若该单词还为出现过，申请新的空间
                if(isok==sign.cend()) sign[word].reset(new std::set);
                sign[word]->insert(len);
            }
        }
    }
     //该函数的定义必须在QueryResult 完整定义后定义，这里只做声明
    QueryResult query(const std::string &s)const ;
private :
    std::shared_ptr > p_text;  //存内容
    std::map > > sign; //存每个单词所在行位置数
};

//查询结果类 包括查询的单词 以及该单词所在的所有行数 单词所在行的句子(即必须获取所有内容)
class QueryResult{
private:
    std::string word;   //查询的单词
    std::shared_ptr > p_line; //该单词的行号
    std::shared_ptr >p_text; //存句子
public :
    //print要使用里面的成员
    friend std::ostream& print(std::ostream& out,const QueryResult& qr);
    QueryResult(std::string s,
                std::shared_ptr > pl,
                std::shared_ptr > pv):
                word(s),p_line(pl),p_text(pv){}
    std::set::iterator begin(){   //begin
        return p_line->begin();
    }
    std::set::iterator end(){   //end
        return p_line->end();
    }
    std::shared_ptr > get_file(){ //get_file
        return p_text;
    }
};
QueryResult TextQuery::query(const std::string &s)const{
    std::shared_ptr > null_ptr(new std::set );
    auto isok=sign.find(s);
    //若未找到，返回第二个参数为新申请的初始化的空间
    if(isok==sign.cend()) return QueryResult(s,null_ptr,p_text);
    else return QueryResult(s,isok->second,p_text);
}
std::ostream& print(std::ostream& out,const QueryResult &qr){
    out<at(x-1)<>s) || s=="q") break;
        print(std::cout,tq.query(s))<
15.2.1节练习：


#include 

//15.3
class Quote{
public :
    Quote()=default;
    Quote(const std::string &book,double sales_price):bookNo(book),price(sales_price){}
    std::string isbn()const {return bookNo;}
    virtual double net_price(std::size_t n) const {return n*price;}
    friend double print_total(std::ostream&,const Quote&,size_t );
private:
    std::string bookNo;
protected:
    double price=0.0;
};

double print_total(std::ostream &os,const Quote &item,size_t n){
    double ret=item.net_price(n);
    os<<"isbn: "<
15.2.2节练习：


#include 
#include 

//15.5 15.6 15.7
class Quote{
public :
    Quote()=default;
    Quote(const std::string &book,double sales_price):bookNo(book),price(sales_price){}
    std::string isbn()const {return bookNo;}
    virtual double net_price(std::size_t n) const {return n*price;}
    friend double print_total(std::ostream&,const Quote&,size_t );
private:
    std::string bookNo;
protected:
    double price=0.0;
};

class Bulk_quote:public Quote{
public :
    Bulk_quote()=default;
    Bulk_quote(const std::string &book,double sales_price,std::size_t num,double disc):
        Quote(book,sales_price),min_num(num),discount(disc){};
    double net_price(std::size_t n) const{
        if(n>=min_num) return n*price*discount;
        else return n*price;
    }
private:
    std::size_t min_num;
    double discount;
};

class huodong_quote:public Quote{
public :
    huodong_quote()=default;
    huodong_quote(const std::string book,double sales_price,std::size_t num,double disc):
        Quote(book,sales_price),max_num(num),discount(disc){}
    double net_price(std::size_t n)const {
        if(n<=max_num) return n*price*discount;
        else return net_price(max_num)+(n-max_num)*price;
    }
private:
    double discount;
    size_t max_num;
};
double print_total(std::ostream &os,const Quote &item,size_t n){
    double ret=item.net_price(n);
    os<<"isbn: "<
15.3节练习：


#include 
#include 


//15.11  debug()
class Quote{
public :
    Quote()=default;
    Quote(const std::string &book,double sales_price):bookNo(book),price(sales_price){}
    std::string isbn()const {return bookNo;}
    virtual double net_price(std::size_t n) const {return n*price;}
    friend double print_total(std::ostream&,const Quote&,size_t );
    virtual void debug(){
        std::cout<<"类成员及类型如下所示:"<=min_num) return n*price*discount;
        else return n*price;
    }
    void debug()override{
        Quote::debug();
        std::cout<<"size_t : min_num"<
15.4节练习：


#include 
#include 


//15.15 15.16
class Quote{
public :
    Quote()=default;
    Quote(const std::string &book,double sales_price):bookNo(book),price(sales_price){}
    std::string isbn()const {return bookNo;}
    virtual double net_price(std::size_t n) const {return n*price;}
    friend double print_total(std::ostream&,const Quote&,size_t );
private:
    std::string bookNo;
protected:
    double price=0.0;
};
double print_total(std::ostream &os,const Quote &item,size_t n){
    double ret=item.net_price(n);
    os<<"isbn: "<=off_num) return n*price*discount;
        else return n*price;
    }
};

class huodong_quote:public Disc_quote{
public :
    huodong_quote()=default;
    huodong_quote(const std::string book,double sales_price,std::size_t num,double disc):
        Disc_quote(book,sales_price,num,disc){}
    double net_price(std::size_t n)const override{
        if(n<=off_num) return n*price*discount;
        else return net_price(off_num)+(n-off_num)*price;
    }
};
int main()
{
    Bulk_quote b("高数",20,5,0.5);
    huodong_quote h("线代",20,5,0.5);
    print_total(std::cout,b,6);
    print_total(std::cout,h,6);
    return 0;
}
15.5节练习：


#include 
#include 

//15.21 15.22
class Graph{
public :
    Graph()=default;
    Graph(double x):r(x){}
    virtual double get_area()=0;
    virtual double get_value()=0;
protected:
    double r;
    const double Pi=3.1415926;
};

class Grid:public Graph{
public :
    Grid()=default;
    Grid(double x):Graph(x){}
    double get_area(){return r*r;}
    double get_value(){return 0.0;}
};
class Circle:public Graph{
public :
    Circle()=default;
    Circle(double x):Graph(x){}
    double get_area(){return Pi*r*r;}
    double get_value(){return 0.0;}
};

class Ball:public Graph{
public :
    Ball()=default;
    Ball(double x):Graph(x){}
    double get_area(){return 4.0*Pi*r*r;}
    double get_value(){return 4.0*Pi*r*r*r/3.0;}
};

class Cone:public Graph{
public :
    Cone()=default;
    Cone(double x,double y):Graph(x),height(y){}
    double get_area(){return Pi*r*r+Pi*r*sqrt(height*height+r*r);}
    double get_value(){return Pi*height*r*r/3.0;}
protected:
    double height;
};
int main()
{
    Grid g(2.0);
    Circle ci(2.0);
    Ball b(2.0);
    Cone co(2.0,3.0);
    std::cout<<"Grid : "<
15.7.3节练习：


#include 

//15.26
class Quote{
public :
    Quote()=default;
    Quote(const std::string &book,double sales_price):bookNo(book),price(sales_price){
        std::cout<<"Quote construct "<bookNo=qu.bookNo;
        this->price=qu.price;
        std::cout<<"Quote copy "<min_num=bkq.min_num;
        this->discount=bkq.discount;
        std::cout<<"Bulk_quote copy "<
15.8节练习：


#include 
#include 
#include 
#include 

//15.28 15.29
class Quote{
public :
    Quote()=default;
    Quote(const std::string &book,double sales_price):bookNo(book),price(sales_price){}
    std::string isbn()const {return bookNo;}
    virtual double net_price(std::size_t n) const {return n*price;}
    friend double print_total(std::ostream&,const Quote&,size_t );
private:
    std::string bookNo;
protected:
    double price=0.0;
};

class Bulk_quote:public Quote{
public :
    Bulk_quote()=default;
    Bulk_quote(const std::string &book,double sales_price,std::size_t num,double disc):
        Quote(book,sales_price),min_num(num),discount(disc){};
    double net_price(std::size_t n) const{
        if(n>=min_num) return n*price*discount;
        else return n*price;
    }
private:
    std::size_t min_num;
    double discount;
};
double print_total(std::ostream &os,const Quote &item,size_t n){
    double ret=item.net_price(n);
    os<<"isbn: "< vec1;
    vec1.push_back(Bulk_quote("高数",20,8,0.5));//只是把其中Quote的部分拷贝给vec1了
    vec1.push_back(Bulk_quote("高数",20,5,0.5));
    double sum1=0.0;
    for(auto x:vec1){
        sum1+=print_total(std::cout,x,7);
    }
    std::cout<<"total_price:"< > vec2;
    vec2.push_back(std::make_shared("高数",20,8,0.5)); //指针动态绑定
    vec2.push_back(std::make_shared("高数",20,5,0.5));
    double sum2=0.0;
    for(auto x:vec2){
        sum2+=print_total(std::cout,*x,7);
    }
    std::cout<<"total_price:"<
15.8.1节练习：


#include 
#include 
#include 

//15.30
class Quote{
public :
    Quote()=default;
    Quote(const std::string &book,double sales_price):bookNo(book),price(sales_price){}
    std::string isbn()const {return bookNo;}
    virtual double net_price(std::size_t n) const {return n*price;}
    friend double print_total(std::ostream&,const Quote&,size_t );
   // virtual Quote *clone()const &{return new Quote(*this);} 编译器不支持
private:
    std::string bookNo;
protected:
    double price=0.0;
};

class Bulk_quote:public Quote{
public :
    Bulk_quote()=default;
    Bulk_quote(const std::string &book,double sales_price,std::size_t num,double disc):
        Quote(book,sales_price),min_num(num),discount(disc){};
    //Bulk_quote *clone()const &{return new Bulk_quote(*this);}
    double net_price(std::size_t n) const{
        if(n>=min_num) return n*price*discount;
        else return n*price;
    }
private:
    std::size_t min_num;
    double discount;
};

double print_total(std::ostream &os,const Quote &item,size_t n){
    double ret=item.net_price(n);
    os<<"isbn: "< sale){ item.insert(sale); }
    //void add_item(const Quote &sale){
    //    item.insert(std::shared_ptr(sale.clone()));
    //}
    //输出
    double total_receipt(std::ostream& os)const{
        double sum=0.0;
        //upper_bound(*iter) 指向下一个关键字
        //item.count(*iter) 计算关键字为*iter的元素个数
        for(auto iter=item.cbegin();iter!=item.cend();iter=item.upper_bound(*iter)){
            sum+=print_total(os,**iter,item.count(*iter));
        }
        os<<"Total Sale: "< &lhs,const std::shared_ptr &rhs){
        return lhs->isbn()isbn();
    }
    std::multiset,decltype(cmp)*> item{cmp};
};
int main()
{
    Basket b;
    for(int i=1;i<=5;++i) b.add_item(std::make_shared("高数",20,5,0.5));
    for(int i=1;i<=7;++i) b.add_item(std::make_shared("线代",30,5,0.5));
    //for(int i=1;i<=5;++i) b.add_item(Bulk_quote("高数",20,5,0.5));
    //for(int i=1;i<=7;++i) b.add_item(Bulk_quote("线代",30,5,0.5));
    b.total_receipt(std::cout);
    return 0;
}


 15.92~15.93节练习：


#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

class TextQuery;
class QueryResult;
using line=std::vector::size_type;
//文件查询类，存错整个文件内容 以及每个单词出现的行数   定义查询函数返回一个查询结果类
class TextQuery{
public :
    //构造函数 获取一个文件输入对象 构造 sign p_text
    TextQuery(std::ifstream& in):p_text(new std::vector){
        std::string senten;  //读取每行的句子
        while(getline(in,senten)){
            p_text->push_back(senten);
            auto len=p_text->size();    //对应行号 即从1开始
            std::stringstream word_in(senten);
            std::string word;
            while(word_in>>word){
                auto isok=sign.find(word);
                 //若该单词还为出现过，申请新的空间
                if(isok==sign.cend()) sign[word].reset(new std::set);
                sign[word]->insert(len);
            }
        }
    }
     //该函数的定义必须在QueryResult 完整定义后定义，这里只做声明
    QueryResult query(const std::string &s)const ;
private :
    std::shared_ptr > p_text;  //存内容
    std::map > > sign; //存每个单词所在行位置数
};

//查询结果类 包括查询的单词 以及该单词所在的所有行数 单词所在行的句子(即必须获取所有内容)
class QueryResult{
private:
    std::string word;   //查询的单词
    std::shared_ptr > p_line; //该单词的行号
    std::shared_ptr >p_text; //存句子
public :
    //print要使用里面的成员
    friend std::ostream& print(std::ostream& out,const QueryResult& qr);
    QueryResult(std::string s,
                std::shared_ptr > pl,
                std::shared_ptr > pv):
                word(s),p_line(pl),p_text(pv){}
    std::set::iterator begin(){   //begin
        return p_line->begin();
    }
    std::set::iterator end(){   //end
        return p_line->end();
    }
    std::shared_ptr > get_file(){ //get_file
        return p_text;
    }
};
QueryResult TextQuery::query(const std::string &s)const{
    std::shared_ptr > null_ptr(new std::set );
    auto isok=sign.find(s);
    //若未找到，返回第二个参数为新申请的初始化的空间
    if(isok==sign.cend()) return QueryResult(s,null_ptr,p_text);
    else return QueryResult(s,isok->second,p_text);
}
std::ostream& print(std::ostream& out,const QueryResult &qr){
    out<at(x-1)<eval(t);}//Query_base::eval()
    std::string rep()const {return q->rep();} //Query_base::rep()
private:
    Query(std::shared_ptr query):q(query){} //构造函数，接受一个Query_base指针
    std::shared_ptr q;  //通过该指针实现多态
};

class WordQuery:public Query_base{ //直接调用TextQuery的query函数即可
    friend class Query;
    WordQuery(const std::string &s):query_word(s){}
    QueryResult eval(const TextQuery &t)const {return t.query(query_word);}
    std::string rep()const {return query_word;}
    std::string query_word;
//    Query::Query(const std::string &s):q(new WordQuery(s)){}
};
//Query的构造函数,接受一个string 把一个WordQuery(s)赋给Query:q
inline Query::Query(const std::string &s):q(new WordQuery(s)){}
class NotQuery:public Query_base{
    friend Query operator~(const Query &);
    NotQuery(const Query &q):query(q){} //构造函数 获取一个Query参数
    std::string rep()const {return "~("+query.rep()+")";}
    QueryResult eval(const TextQuery&) const ;
    Query query;
};
//重载运算符，返回一个指向NotQuery类型的指针 绑定到Query
inline Query operator~(const Query &operand){
    return std::shared_ptr(new NotQuery(operand));
}

class BinaryQuery:public Query_base{
protected:
    //构造函数获得左右操作对象 及操作方法
    BinaryQuery(const Query &l,const Query &r,std::string s):lhs(l),rhs(r),opSym(s){}
    std::string rep()const{ return "("+lhs.rep()+" "+opSym+" "+rhs.rep()+")";}
    Query lhs,rhs; //两个运算对象
    std::string opSym; //运算符
};

class AndQuery:public BinaryQuery{
    friend Query operator&(const Query&,const Query);
public :
    AndQuery(const Query &left,const Query &right):BinaryQuery(left,right,"&"){}
    QueryResult eval(const TextQuery&)const;
};
//重载运算符返回一个指向 AndQuery类型的指针 绑定到Query
inline Query operator&(const Query &lhs,const Query &rhs){
    return std::shared_ptr(new AndQuery(lhs,rhs));
}
class OrQuery:public BinaryQuery{
    friend Query operator|(const Query &,const Query&);
public :
    OrQuery(const Query &left,const Query &right):BinaryQuery(left,right,"|"){}
    QueryResult eval(const TextQuery&)const;
};
//重载运算符返回一个指向 OrQuery类型的指针 绑定到Query
inline Query operator|(const Query &lhs,const Query &rhs){
    return std::shared_ptr(new OrQuery(lhs,rhs));
}
//重载输出运算符，输出Query指向的rep(),可注释
std::ostream & operator<<(std::ostream &os,const Query &query){return os< >(left.begin(),left.end());
    ret_lines->insert(right.begin(),right.end());
    return QueryResult(rep(),ret_lines,left.get_file());
}
//调用函数 set_intersection(beg1,end1,beg2,end2,dest)函数实现
QueryResult AndQuery::eval(const TextQuery& text)const{
    auto left=lhs.eval(text),right=rhs.eval(text);
    auto ret_lines=std::make_shared >();
    set_intersection(left.begin(),left.end(),right.begin(),right.end(),
                        inserter(*ret_lines,ret_lines->begin()));
    return QueryResult(rep(),ret_lines,left.get_file());
}

QueryResult NotQuery::eval(const TextQuery&text)const {
    auto result=query.eval(text);  //result相当于一个WordQuery的结果
    auto ret_lines=std::make_shared >(); //新建一个 *set
    auto beg=result.begin(),end=result.end();
    auto sz=result.get_file()->size();//查询内容的总行数
    //for(auto &x:result) std::cout<insert(n);
        else if(beg!=end)++beg;
    }
    return QueryResult(rep(),ret_lines,result.get_file());
}
void runQueries(std::ifstream &infile){
    TextQuery tq(infile);
    while(true){
        std::cout<<"enter word to look for, or q to quit: ";
        std::string s;
        if(!(std::cin>>s) || s=="q") break;
        print(std::cout,tq.query(s))<


 16.1.1节练习：


#include 
#include 
#include 
#include 
#include 

//16.2
template  int  compare(const T& a,const T& b){
    if(a>b) return 1;
    else if(a v1={1,2,3,4},v2={2,3,4};
    std::cout< T1 find1(T1 beg,T1 end,const T2& temp){
    while(beg!=end)
        if(*beg==temp) return beg;
        else ++beg;
    return end;
}
void fun4(){
    std::vector a={1,3,4,5};
    auto iter=find1(a.begin(),a.end(),3);
    std::cout<<*iter< ls={"wo","qu","dou","bi"};
    auto iter2=find1(ls.begin(),ls.end(),"qu");
    std::cout<<*iter2< void print(const T (&p)[N]){
   for(int i=0;i T* begin(T (&p)[N]){
    if(N>1) return p;
    else return NULL;
}
template  T* end(T (&p)[N]){
    if(N>1)return p+N;
    else return NULL;
}
void fun6(){
    int num[]={1,2,3,4,5};
    char s[]="woqufule";
    std::for_each(begin(num),end(num),
                  [](const int &x){std::cout< constexpr unsigned size_array(T (&p)[N]){
    return N;
}
void fun7(){
    int num[]={1,2,3,4};
    std::cout<
16.1.2节练习：


#include 
#include 
#include 
#include 
#include 

//16.12
template  class BlobPtr;
template  class Blob{
    friend BlobPtr ;
public:
    typedef typename std::vector::size_type  size_type;
    Blob():data(std::make_shared >()){}
    Blob(std::initializer_list lis):data(std::make_shared >(lis)){}
    size_type size()const {return data->size();}
    void push_back(const T &s){data->push_back(s);}
    void pop_back(){
        check(0,"pop on empty Blob");
        data->pop_back();
    }
    T &front(){
        check(0,"front on empty Blob");
        data->front();
    }
    T &back(){
        check(0,"back on empty Blob");
        return data->back();
    }
    T &operator[](size_type t);
private:
    std::shared_ptr > data; // emory
    void check(size_type i,const std::string &s)const {
        if(data->size()<=i) throw std::out_of_range(s); // stdexcept
    }
};
template 
T &Blob::operator[](size_type t){
    check(t,"subscript out of range");
    return (*data)[t];
}

template  class BlobPtr{
public :
    BlobPtr():curr(0){}
    BlobPtr(Blob &a,size_t sz=0):wptr(a.data),curr(sz){}
    T &operator*()const{
        auto p=check(curr,"derefence past end");
        return (*p)[curr];
    }
    BlobPtr& operator++(){
        BlobPtr ret=*this;
        curr++;
       // ++*this;
        return ret;
    }
    BlobPtr& operator--(){
        BlobPtr ret=*this;
        curr--;
       // --*this;
        return ret;
    }
private:
    std::shared_ptr > check(std::size_t t,const std::string &msg)const {
        auto ret=wptr.lock();
        if(!ret) throw std::runtime_error("unbound BlobPtr");
        else if(t>=ret->size())throw std::out_of_range(msg);
        return ret;
    }
    std::weak_ptr > wptr;
    std::size_t curr;
};


int main()
{
//16.12
    Blob b1={"a","an","the"};
    for(auto i=0;i pb(b1);
    for(int i=0;i
16.1.2节练习：


#include 
#include 
//16.14 16.15
template  class Screen{
    typedef std::string::size_type pos;
public:
    Screen()=default;
    Screen(char c):contents(H*W,c){}
    char get()const { return contents[cursor];} //取当前焦点的值
    Screen &move(pos r,pos c){  //移动焦点
        if(r<1) throw std::out_of_range("out of screen");
        cursor =(r-1)*width +c;
        return *this;
    }
    Screen &operator<<(const char &c){  //输出当前焦点的值
        contents[cursor] =c;
        return *this;
    }
    Screen &operator>>(char &c){    //输入当前焦点的值
        c=contents[cursor];
        return *this;
    }

    friend std::ostream &operator<<(std::ostream &os,const Screen &c ){ //输出屏幕
        for(int i=0;i src('x');
    src.move(5,5);
    src<<'c';
    std::cout<
16.1.3节练习：


#include 
#include 
#include 
#include 

//16.19
template  void print(T& pack){
    for(auto &x:pack) std::cout< void print2(T& pack){
    for(auto it=pack.begin();it!=pack.end();++it) std::cout<<*it<<" ";
    std::cout< vec={1,2,3,4,5};
    print(vec);
    print2(vec);
    std::list li={'w','o','q','u'};
    print(li);
    print2(li);
    std::set st={6,7,8};
    print(st);
    print2(st);
    return 0;
}


 16.1.4节练习：


#include 
//16.21
class DebugDelete{
public :
    DebugDelete(std::ostream &s = std::cerr):os(s){} //构造函数
    template  void operator()(T *p)const{ //重载()运算符
        os<<"deleteing unique_ptr"<
16.1.4节练习：


#include 
#include 
#include 
#include 

template  class Blob{
public:
    typedef typename std::vector::size_type  size_type;
    Blob():data(std::make_shared >()){}
    Blob(std::initializer_list lis):data(std::make_shared >(lis)){}
    size_type size()const {return data->size();}
    void push_back(const T &s){data->push_back(s);}
    void pop_back(){
        check(0,"pop on empty Blob");
        data->pop_back();
    }
    T &front(){
        check(0,"front on empty Blob");
        data->front();
    }
    T &back(){
        check(0,"back on empty Blob");
        return data->back();
    }
    T &operator[](size_type t);
    //16.24
    Blob(typename std::vector::iterator b,typename std::vector::iterator e){
        data=std::make_shared >(b,e);
    }
private:
    std::shared_ptr > data; // emory
    void check(size_type i,const std::string &s)const {
        if(data->size()<=i) throw std::out_of_range(s); // stdexcept
    }
};
int main()
{
    std::vector v={1,2,3};
    Blob b(v.begin(),v.end());
    std::cout<


 未完待续。。。

最超值的Mac——Mac mini 初心么么哒
你知道最超值的Mac是什么吗？自2005年以来，Macmini一直是Apple台式机产品线中的主要产品。最初推出是为了让对Mac好奇的Mac进入Apple生态系统的一种简单方式，现在新的AppleSiliconMacmini可能是任何寻找新Mac的人的最有吸引力的购买。什么是AppleSiliconMacmini？M1Macmini是Apple最小的台式电脑，同时也是最快的台式电脑之一。最新型号由
暑假训练总结 G_Meteor
不知不觉暑假就要这样结束了，这个假期主要在弄ACM了，但是由于家里原因并没有来学校参加集训，而是在家里跟着学知识点刷题做练习赛。编程作为计算机的基础以及入门知识，其重要性自然不用说，而且大一刚开始就是学算法，当时感觉编程挺感兴趣的，然后参加那个新生编程赛。刚开始接触到ACM也是在这次新生编程比赛上吧，当时听到学长对ACM的介绍后，感觉挺感兴趣的，再加上当时感觉编程也是挺有意思的，然后大一寒假就加入
综述论文“A Survey of Zero-Shot Learning: Settings, Methods, and Applications” 硅谷秋水机器学习机器学习神经网络深度学习
该零样本学习综述，发表于ACMTrans.Intell.Syst.Technol.10,2,Article13(January2019)摘要：大多数机器学习方法着重于对已经在训练中看到其类别的实例进行分类。实际上，许多应用程序需要对实例进行分类，而这些实例的类以前没有见过。零样本学习（Zero-ShotLearning）是一种强大而有前途的学习范例，其中训练实例涵盖的类别与想分类的类别是不相交的。
【Hot100】LeetCode—64. 最小路径和山脚ice #Hot100 leetcode 算法
目录1-思路题目识别动规五部曲2-实现⭐64.最小路径和——题解思路3-ACM实现原题链接：64.最小路径和1-思路题目识别识别1：给一个二维数组grid，每次只能向下或者向右移动一步识别2：求移动到右下角的最小路径和动规五部曲求的是路径的和，与不同路径的区别在于是否加上当前grid[i][j]的值2-实现⭐64.最小路径和——题解思路classSolution{publicintminPathS
【Hot100】LeetCode—763. 划分字母区间山脚ice #Hot100 leetcode 哈希算法
目录1-思路哈希表+双指针2-实现⭐763.划分字母区间——题解思路3-ACM实现原题链接：763.划分字母区间1-思路哈希表+双指针①找到元素最远的出现位置：哈希表②根据最远出现位置，判断区间的分界线：双指针实现1-定义一个哈希数组，判断最远出现的位置：int[]hash=newint[27]遍历字符串，记录最远出现位置2-分割点利用数组，收集结果intleft=0;intright=0;记录左
redis cluster之Gossip协议 tracy_668
什么是Gossip协议Gossipprotocol也叫EpidemicProtocol（流行病协议），实际上它还有很多别名，比如：“流言算法”、“疫情传播算法”等。这个协议的作用就像其名字表示的意思一样，非常容易理解，它的方式其实在我们日常生活中也很常见，比如电脑病毒的传播，森林大火，细胞扩散等等。Gossipprotocol最早是在1987年发表在ACM上的论文《EpidemicAlgorith
卡码网C++基础课 | 1. A+B问题I TimeManager1 c++开发语言
之前一直有在学习c++，陆陆续续也跟着代码随想录刷了一些力扣，但是总感觉在自己的基本功不够扎实，尤其是在遇见ACM输入输出模式的时候，所以就想着跟着卡尔的基础课教程系统性地学习一遍，就在这里记录一下自己的小心得吧，也算是一种小小的打卡，希望自己能够坚持下去！加油！1.在该问题中，输入输出是靠内置库iostream实现的，里面有两个基础类型：istream和ostream，也就是输入输出流，在声明了
【笔试题汇总】华为春招笔试题题解 2024-3-20 PXM的算法星球大厂面试题华为面试数据结构算法
这里是paoxiaomo，一个现役ACMer，之后将会持续更新算法笔记系列以及笔试题题解系列本文章面向想打ICPC/蓝桥杯/天梯赛等程序设计竞赛，以及各个大厂笔试的选手感谢大家的订阅➕和喜欢有什么想看的算法专题可以私信博主（本文题面由清隆学长收集）01.K小姐的魔法药水问题描述K小姐是一位魔法师，她最近在研究一种神奇的魔法药水。这种药水由一系列魔法材料制成，每种材料都有一个正整数的魔法值。K小姐按
【华为笔试题汇总】2024-05-22-华为春招笔试题-三语言题解(Python/Java/Cpp) 春秋招笔试突围华为春秋招笔试题汇总最新互联网春秋招试题合集华为 python java 算法
大家好这里是清隆学长，一枚热爱算法的程序员✨本系列打算持续跟新小米近期的春秋招笔试题汇总～ACM银牌|多次AK大厂笔试｜编程一对一辅导感谢大家的订阅➕和喜欢清隆这边最近正在收集近一年互联网各厂的笔试题汇总，如果有需要的小伙伴可以关注后私信一下清隆领取，会在飞书进行同步的跟新。文章目录01.获取公共链表片段问题描述输入格式输出格式样例输入样例输出数据范围题解参考代码02.矿车运输成本问题描述输入格式
四、使用MoveGroup C++接口——运动学（二）阿白机器人 MoveIt 2机器人运动规划 c++
目录前言1.运动学插件（KinematicsPlugin）2.碰撞检测（CollisionChecking）3.碰撞对象（CollisionObjects）4.允许碰撞矩阵（AllowedCollisionMatrix,ACM）前言运动学是研究物体运动的几何属性而不涉及力或质量的科学。在机器人学中，运动学涉及到机器人的机械臂和关节如何运动。1.运动学插件（KinematicsPlugin）Move
java mp3转m4a_轻松在你的Android App中转换音频文件，支持格式：WAV, AAC, MP3, M4A, WMA 和FLAC.... Kada Liao java mp3转m4a
AndroidAudioConverterConvertaudiofilesinsideyourAndroidappeasily.ThisisawrapperofFFmpeg-Android-Javalib.Supportedformats:AACMP3M4AWMAWAVFLACLibsize:~9mbHowToUse1-AddthispermissionintoyourAndroidManife
【Hot100】LeetCode—118. 杨辉三角山脚ice #Hot100 leetcode 算法
目录1-思路模拟2-实现⭐118.杨辉三角——题解思路3-ACM实现原题链接：118.杨辉三角1-思路模拟1-定义grid2-实现递推公式3-初始化4-遍历递推收集结果2-实现⭐118.杨辉三角——题解思路classSolution{publicList>generate(intnumRows){int[][]grid=newint[numRows][numRows];//初始化for(inti=
【Hot100】LeetCode—215. 数组中的第K个最大元素山脚ice #Hot100 leetcode 算法
目录1-思路快速选择2-实现⭐215.数组中的第K个最大元素——题解思路3-ACM实现原题连接：215.数组中的第K个最大元素1-思路快速选择第k大的元素的数组下标：inttarget=nums.length-k1-根据partition分割的区间来判断当前处理方式如果返回的int等于target说明找到了，直接返回如果返回的int小于target说明要在当前区间的右侧寻找，也就是[pivotIn
图像去噪技术：自适应均值滤波器（ACmF）潦草通信狗均值算法算法人工智能图像处理信息与通信 matlab
在图像处理领域，噪声是影响图像质量和视觉感知的主要因素之一。椒盐噪声是一种常见的噪声类型，它随机地将像素值改变为最小值或最大值，严重影响图像的视觉效果。为了解决这一问题，我们开发了一种自适应均值滤波器（ACmF），它能够有效地去除椒盐噪声，同时保留图像的重要细节。一、ACmF算法简介ACmF算法是一种基于局部像素值的自适应去噪方法。它通过分析图像的局部区域，对噪声像素进行智能处理，以恢复图像的原始
代码随想录+力扣刷题记录+华为机考准备记录梁慢慢慢慢 leetcode 算法数据结构
为了准备华为机考的刷题记录，已压线过背景：数据结构与算法零基础，此前没有刷过题，会Python。学习路线按照代码随想录的顺序刷题，刷题平台：力扣以上大致过了一遍后开始刷华为机考真题（cdsn上购买的真题，刷题平台是购买的真题中的OJ平台，也是ACM模式）总共用时1个月。完成情况：力扣80个题+华为2024年机考真题。大部分题目都只做过1次，掌握得很不牢固，机考的时候也是压线过。时间比较紧急，做到后
释放oracle undo表空间,undo表空间释放 IBEANI 释放oracle undo表空间
一.概述:使用IMPDP工具导入大表(166G)数据时,报undo表空间不能扩展,导入工作失败.手工停止了impdp后,undo表空间存在无法自动释放的故障.本文主要描述如何通过重建undo表空间来手工释放undo表空间.数据库环境的描述:OS:AIX6.1+HACMP5.3DB:ORACLE10.2.0.5RAC二.问题的描述impdp导入数据时,报ora-30036错误$impdpuser/p
【最新华为OD机试E卷】日志采集系统(100分)多语言题解-(Python/C/JavaScript/Java/Cpp) 春秋招笔试突围华为od python c语言
大家好这里是春秋招笔试突围，一枚热爱算法的程序员✨本系列打算持续跟新华为OD-E/D卷的三语言AC题解ACM金牌️团队|多次AK大厂笔试｜编程一对一辅导感谢大家的订阅➕和喜欢最新华为OD机试D卷目录，全、新、准，题目覆盖率达95%以上，支持题目在线评测，专栏文章质量平均94分最新华为OD机试目录:https://blog.csdn.net/Qmtdearu/article/details/1393
mac版QQ聊天信息备份与导出方法 iHTCboy
前言最近，我司终于更换新电脑的计划落实啦！！！Macmini3.0GHz双核IntelCorei7处理器(TurboBoost高达3.5GHz)16GB1600MHzLPDDR3SDRAM1TB融合硬盘IntelIrisGraphics图形处理器非常值的可贺！然而，就是新电脑，一切都是新！一切都是白！！非常多工具的数据需要迁移，开发环境需要配置，最近也打算总结一下新电脑配置方面的文章，作为自己备份
数据结构之查找点一下我的id
http://www.bjfuacm.com/problem/287/#includeusingnamespacestd;#defineOK1#defineMAXSIZE10000typedefintStatus;typedefintElementType;typedefintKeyType;typedefstruct{ElementType*data;intlength;}SqList;Stat
【Hot100】LeetCode—153. 寻找旋转排序数组中的最小值山脚ice #Hot100 leetcode java 算法
目录1-思路二分2-实现⭐33.搜索旋转排序数组——题解思路3-ACM实现原题链接：153.寻找旋转排序数组中的最小值1-思路二分左区间二分找分界点，二分找到旋转后的分界点即可以nums[mid]为基准，对比nums[0]即可找到区间分界点2-实现⭐33.搜索旋转排序数组——题解思路classSolution{publicintfindMin(int[]nums){intleft=0;intrig
【Hot100】LeetCode—33. 搜索旋转排序数组山脚ice #Hot100 leetcode 算法
目录1-思路二分2-实现⭐33.搜索旋转排序数组——题解思路3-ACM实现原题链接：33.搜索旋转排序数组1-思路二分①左区间二分、②寻找目标值所处区间、③二分目标值①左区间二分——>找到最后一个比nums[0]大的元素，也就是前半段即nums[mid]>=nums[0]②寻找目标值所在区间if(target>=nums[0])——>left=0;else{left=left+1;right=nu
acm会议什么档次_盘点AI国际顶级会议 weixin_39531992 acm会议什么档次
人工智能(英文全称ArtificialIntelligence,缩写为AI)从其字面意思理解是由人制造出来在机器上体现出的类似于人类的智能，其技术研究包含机器视觉、机器学习、自然语言处理、机器运动和控制等众多方面。如同四大时装周是世界时尚潮流的风向标，人工智能领域的国际顶尖会议也往往汇集了人工智能各分支技术的最新发展状态和未来发展方向。今天，小编就来为大家盘点一下人工智能领域的国际顶级会议。\\\
【Hot100】LeetCode—20. 有效的括号山脚ice #Hot100 leetcode java 算法
目录1-思路栈实现2-实现⭐20.有效的括号——题解思路3-ACM实现原题链接：20.有效的括号1-思路栈实现遇到一个左括号，将对应的右括号压栈处理否则弹出栈顶元素，比较和当前括号是否一致，不一致返回false三种情况①左右不匹配②左多右少，判断在最后返回st.isEmpty()上③左少右多，判断在elseif(st.isEmpty()||c!=st.peek())2-实现⭐20.有效的括号——题
查找并输出一个句子中的最长单词 MasterTomato ACM ACM 字符串
2019年4月11日ACM校赛小结第一次打ACM，发现自己真的是什么也不会。没关系，先总结一下这一次有思路但是没有做出来的题吧。在一句英文中寻找最长单词【T4】最长单词编写一个函数，输入一行字符，将此字符串中最长的单词输出。输入仅一行，多个单词，每个单词间用一个空格隔开。单词仅由小写字母组成。所有单词的长度和不超过100000。如有多个最长单词，输出最先出现的。【样例】Input：Iamastud
牛客刷题|HJ20 密码验证合格程序, HJ16 购物单，H17坐标移动 Huiwen_Z 笔试刷题数据结构 python 牛客
ACM输入输出处理参考：【python&ACM输入输出的处理：sys.stdin.readline().strip().split())】_sys.stdin.readline()输入去除掉空格-CSDN博客line2=sys.stdin.readline()#读一行a='8dajia8hao8'b=a.strip()#移除字符串开头和结尾的空格或换行符c=b.strip('8')#移除字符串开头
牛客网暑期ACM多校训练营（第二场）J.farm (随机数+二维树状数组) Fushicho_XF 树状数组 ACM 算法
题目链接时间限制：C/C++4秒，其他语言8秒空间限制：C/C++262144K，其他语言524288K64bitIOFormat:%lld题目描述WhiteRabbithasarectangularfarmlandofn*m.Ineachofthegridthereisakindofplant.Theplantinthej-thcolumnofthei-throwbelongsthea[i][j
【python】python指南（十四）：**操作符解包字典传参 LDG_AGI Python python 开发语言人工智能机器学习图像处理深度学习计算机视觉
目录一、引言二、**操作符应用2.1**操作符介绍2.2**操作符案例三、总结一、引言对于算法工程师来说，语言从来都不是关键，关键是快速学习以及解决问题的能力。大学的时候参加ACM/ICPC一直使用的是C语言，实习的时候做一个算法策略后台用的是php，毕业后做策略算法开发，因为要用spark，所以写了scala，后来用基于storm开发实时策略，用的java。至于python，从日常用hive做数
【秋招笔试】8.28得物秋招(算法岗)-三语言题解春秋招笔试突围最新互联网春秋招试题合集算法
大家好这里是春秋招笔试突围，一起备战大厂笔试ACM金牌团队️|多次AK大厂笔试｜编程一对一辅导✨本系列打算持续跟新春秋招笔试题感谢大家的订阅➕和喜欢和手里的小花花✨笔试合集传送们->春秋招笔试合集本专栏已收集100+套笔试题，笔试真题会在第一时间跟新题面描述等均已改编，如果和你笔试题看到的题面描述不一样请理解，做法和题目本质基本不变。感谢各位朋友们的订阅，你们的支持是我们创作的最大动力
【秋招笔试】8.21华为秋招-三语言题解春秋招笔试突围华为春秋招笔试题汇总最新互联网春秋招试题合集华为
大家好这里是春秋招笔试突围，一起备战大厂笔试ACM金牌团队️|多次AK大厂笔试｜编程一对一辅导✨本系列打算持续跟新春秋招笔试题感谢大家的订阅➕和喜欢和手里的小花花✨笔试合集传送们->春秋招笔试合集本专栏已收集100+套笔试题，笔试真题会在第一时间跟新题面描述等均已改编，如果和你笔试题看到的题面描述不一样请理解，做法和题目本质基本不变。感谢各位朋友们的订阅，你们的支持是我们创作的最大动力
【浙江工业大学、中国人工智能学会自然计算与数字智能城市专委会联合主办|ACM独立出版|往届均已见刊并完成EI、SCOPUS检索】第四届机器学习与计算机应用国际学术会议(ICMLCA 2023) 艾思科蓝 AiScholar 人工智能机器学习信息与通信图像处理人机交互计算机视觉数据分析
第四届机器学习与计算机应用国际学术会议(ICMLCA2023)定于2023年10月27-29日在中国杭州隆重举行。本届会议将主要关注机器学习和计算机应用面临的新的挑战问题和研究方向，着力反映国际机器学习和计算机应用相关技术研究的新进展。大会网站：https://ais.cn/u/iMrIjq（更多会议详情）截稿时间：以官网信息为准收录检索：EICompendex，Scopus【往届已见刊并完成EI
C/C++Win32编程基础详解视频下载择善Zach 编程 C++Win32
课题视频：C/C++Win32编程基础详解视频知识：win32窗口的创建 windows事件机制主讲：择善Uncle老师学习交流群：386620625 验证码：625 --
Guava Cache使用笔记 bylijinnan java guava cache
1.Guava Cache的get/getIfPresent方法当参数为null时会抛空指针异常我刚开始使用时还以为Guava Cache跟HashMap一样，get(null)返回null。实际上Guava整体设计思想就是拒绝null的，很多地方都会执行com.google.common.base.Preconditions.checkNotNull的检查。 2.Guava
解决ora-01652无法通过128（在temp表空间中） 0624chenhong oracle
解决ora-01652无法通过128（在temp表空间中）扩展temp段的过程一个sql语句后，大约花了10分钟，好不容易有一个结果，但是报了一个ora-01652错误，查阅了oracle的错误代码说明：意思是指temp表空间无法自动扩展temp段。这种问题一般有两种原因：一是临时表空间空间太小，二是不能自动扩展。分析过程：既然是temp表空间有问题，那当
Struct在jsp标签不懂事的小屁孩 struct
非UI标签介绍：控制类标签： 1：程序流程控制标签 if elseif else <s:if test="isUsed"> <span class="label label-success">True</span> </
按对象属性排序换个号韩国红果果 JavaScript 对象排序
利用JavaScript进行对象排序，根据用户的年龄排序展示 <script> var bob={ name;bob, age:30 } var peter={ name;peter, age:30 } var amy={ name;amy, age:24 } var mike={ name;mike, age:29 } var john={
大数据分析让个性化的客户体验不再遥远蓝儿唯美数据分析
顾客通过多种渠道制造大量数据，企业则热衷于利用这些信息来实现更为个性化的体验。分析公司Gartner表示，高级分析会成为客户服务的关键，但是大数据分析的采用目前仅局限于不到一成的企业。挑战在于企业还在努力适应结构化数据，疲于根据自身的客户关系管理（CRM）系统部署有效的分析框架，以及集成不同的内外部信息源。然而，面对顾客通过数字技术参与而产生的快速变化的信息，企业需要及时作出反应。要想实
java笔记4 a-john java
操作符 1，使用java操作符操作符接受一个或多个参数，并生成一个新值。参数的形式与普通的方法调用不用，但是效果是相同的。加号和一元的正号（+）、减号和一元的负号（-）、乘号（*）、除号（/）以及赋值号（=）的用法与其他编程语言类似。操作符作用于操作数，生成一个新值。另外，有些操作符可能会改变操作数自身的
从裸机编程到嵌入式Linux编程思想的转变------分而治之：驱动和应用程序 aijuans 嵌入式学习
笔者学习嵌入式Linux也有一段时间了，很奇怪的是很多书讲驱动编程方面的知识，也有很多书将ARM9方面的知识，但是从以前51形式的（对寄存器直接操作，初始化芯片的功能模块）编程方法，和思维模式，变换为基于Linux操作系统编程，讲这个思想转变的书几乎没有，让初学者走了很多弯路，撞了很多难墙。笔者因此写上自己的学习心得，希望能给和我一样转变
在springmvc中解决FastJson循环引用的问题 asialee 循环引用 fastjson
我们先来看一个例子： package com.elong.bms; import java.io.OutputStream; import java.util.HashMap; import java.util.Map; import co
ArrayAdapter和SimpleAdapter技术总结百合不是茶 android SimpleAdapter ArrayAdapter 高级组件基础
ArrayAdapter比较简单，但它只能用于显示文字。而SimpleAdapter则有很强的扩展性，可以自定义出各种效果 ArrayAdapter;的数据可以是数组或者是队列 // 获得下拉框对象 AutoCompleteTextView textview = (AutoCompleteTextView) this
九封信 bijian1013 人生励志
有时候，莫名的心情不好，不想和任何人说话，只想一个人静静的发呆。有时候，想一个人躲起来脆弱，不愿别人看到自己的伤口。有时候，走过熟悉的街角，看到熟悉的背影，突然想起一个人的脸。有时候，发现自己一夜之间就长大了。 2014，写给人
Linux下安装MySQL Web 管理工具phpMyAdmin sunjing PHP Install phpMyAdmin
PHP http://php.net/ phpMyAdmin http://www.phpmyadmin.net Error compiling PHP on CentOS x64 一、安装Apache 请参阅http://billben.iteye.com/admin/blogs/1985244 二、安装依赖包 sudo yum install gd
分布式系统理论 bit1129 分布式
FLP One famous theory in distributed computing, known as FLP after the authors Fischer, Lynch, and Patterson, proved that in a distributed system with asynchronous communication and process crashes,
ssh2整合(spring+struts2+hibernate)-附源码白糖_ eclipse spring Hibernate mysql 项目管理
最近抽空又整理了一套ssh2框架，主要使用的技术如下： spring做容器，管理了三层(dao,service,actioin)的对象 struts2实现与页面交互(MVC)，自己做了一个异常拦截器，能拦截Action层抛出的异常 hibernate与数据库交互 BoneCp数据库连接池，据说比其它数据库连接池快20倍，仅仅是据说 MySql数据库项目用eclipse
treetable bug记录 braveCS table
// 插入子节点删除再插入时不能正常显示。修改： //不知改后有没有错，先做个备忘 Tree.prototype.removeNode = function(node) { // Recursively remove all descendants of +node+ this.unloadBranch(node); // Remove
编程之美-电话号码对应英语单词 bylijinnan java 算法编程之美
import java.util.Arrays; public class NumberToWord { /** * 编程之美电话号码对应英语单词 * 题目： * 手机上的拨号盘，每个数字都对应一些字母，比如2对应ABC，3对应DEF.........，8对应TUV，9对应WXYZ， * 要求对一段数字，输出其代表的所有可能的字母组合
jquery ajax读书笔记 chengxuyuancsdn jQuery ajax
1、jsp页面 <%@ page language="java" import="java.util.*" pageEncoding="GBK"%> <% String path = request.getContextPath(); String basePath = request.getScheme()
JWFD工作流拓扑结构解析伪码描述算法 comsci 数据结构算法工作活动 J#
对工作流拓扑结构解析感兴趣的朋友可以下载附件，或者下载JWFD的全部代码进行分析 /* 流程图拓扑结构解析伪码描述算法 public java.util.ArrayList DFS(String graphid, String stepid, int j)
oracle I/O 从属进程 daizj oracle
I/O 从属进程　　I/O从属进程用于为不支持异步I/O的系统或设备模拟异步I/O.例如，磁带设备(相当慢)就不支持异步I/O.通过使用I/O 从属进程，可以让磁带机模仿通常只为磁盘驱动器提供的功能。就好像支持真正的异步I/O 一样，写设备的进程(调用者)会收集大量数据，并交由写入器写出。数据成功地写出时，写入器(此时写入器是I/O 从属进程，而不是操作系统)会通知原来的调用者，调用者则会
高级排序:希尔排序 dieslrae 希尔排序
public void shellSort(int[] array){ int limit = 1; int temp; int index; while(limit <= array.length/3){ limit = limit * 3 + 1;
初二下学期难记忆单词 dcj3sjt126com english word
kitchen 厨房 cupboard 厨柜 salt 盐 sugar 糖 oil 油 fork 叉；餐叉 spoon 匙；调羹 chopsticks 筷子 cabbage 卷心菜；洋白菜 soup 汤 Italian 意大利的 Indian 印度的 workplace 工作场所 even 甚至；更 Italy 意大利 laugh 笑 m
Go语言使用MySQL数据库进行增删改查 dcj3sjt126com mysql
目前Internet上流行的网站构架方式是LAMP，其中的M即MySQL, 作为数据库，MySQL以免费、开源、使用方便为优势成为了很多Web开发的后端数据库存储引擎。MySQL驱动Go中支持MySQL的驱动目前比较多，有如下几种，有些是支持database/sql标准，而有些是采用了自己的实现接口,常用的有如下几种: http://code.google.c...o-mysql-dri
git命令 shuizhaosi888 git
---------------设置全局用户名： git config --global user.name "HanShuliang" //设置用户名 git config --global user.email "[email protected]" //设置邮箱 ---------------查看环境配置 git config --li
qemu-kvm 网络 nat模式 (四) haoningabc kvm qemu
qemu-ifup-NAT #!/bin/bash BRIDGE=virbr0 NETWORK=192.168.122.0 GATEWAY=192.168.122.1 NETMASK=255.255.255.0 DHCPRANGE=192.168.122.2,192.168.122.254 TFTPROOT= BOOTP= function check_bridge()
不要让未来的你，讨厌现在的自己 jingjing0907 生活奋斗工作梦想
故事one 　23岁，他大学毕业，放弃了父母安排的稳定工作，独闯京城，在家小公司混个小职位，工作还算顺手，月薪三千，混了混，混走了一年的光阴。　　　　24岁，有了女朋友，从二环12人的集体宿舍搬到香山民居，一间平房，二人世界，爱爱爱。偶然约三朋四友，打扑克搓麻将，日子快乐似神仙；　　　　25岁，出了几次差，调了两次岗，薪水涨了不过百，生猛狂飙的物价让现实血淋淋，无力为心爱银儿购件大牌
枚举类型详解一路欢笑一路走 enum 枚举详解 enumset enumMap
枚举类型详解一.Enum详解 1.1枚举类型的介绍 JDK1.5加入了一个全新的类型的”类”—枚举类型，为此JDK1.5引入了一个新的关键字enum,我们可以这样定义一个枚举类型。 Demo:一个最简单的枚举类 public enum ColorType { RED
第11章动画效果（上） onestopweb 动画
index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
Eclipse中jsp、js文件编辑时，卡死现象解决汇总 ljf_home eclipse jsp卡死 js卡死
使用Eclipse编辑jsp、js文件时，经常出现卡死现象，在网上百度了N次，经过N次优化调整后，卡死现象逐步好转，具体那个方法起到作用，不太好讲。将所有用过的方法罗列如下： 1、取消验证 windows–>perferences–>validation 把除了manual 下面的全部点掉，build下只留 classpath dependency Valida
MySQL编程中的6个重要的实用技巧 tomcat_oracle mysql
每一行命令都是用分号(;)作为结束对于MySQL，第一件你必须牢记的是它的每一行命令都是用分号(;)作为结束的，但当一行MySQL被插入在PHP代码中时，最好把后面的分号省略掉，例如： mysql_query("INSERT INTO tablename(first_name,last_name)VALUES('$first_name',$last_name')");
zoj 3820 Building Fire Stations(二分+bfs) 阿尔萨斯 Build
题目链接：zoj 3820 Building Fire Stations 题目大意：给定一棵树，选取两个建立加油站，问说所有点距离加油站距离的最大值的最小值是多少，并且任意输出一种建立加油站的方式。解题思路：二分距离判断，判断函数的复杂度是o(n)，这样的复杂度应该是o(nlogn)，即使常数系数偏大，但是居然跑了4.5s，也是醉了。判断函数里面做了3次bfs，但是每次bfs节点最多

C++ Primer 第五版 部分课后题答案

你可能感兴趣的:(acm)

C++ Primer 第五版部分课后题答案