c++

[Buttonwood]

Resources

Reading List

CppCon2014 分类合辑 & 十大推荐阅读列表

Websites

1. www.isocpp.org
2. www.stroustrup.com
3. www.open-std.org/jtc1/sc22/wg21/docs/papers

[Buttonwood]

Make Simple Tasks Simple - Bjarne Stroustrup

// old code: 
std::vector<MemoryBuffer>::const_iterator cit = MemVec.cbegin();
for ( ; cit != v.end(); ++cit) {
    if (LookForPattern(*cit)) 
        return true ;
}
return false;

use auto

// first step:
// the oldest C++11 feature
for (auto cit = MemVec.cbegin(); cit!=v.end(); ++cit) {
    if (LookForPattern(*cit)) 
        return true ;
}
return false ;

// second simplification:
for (const auto& x : v)
    if (LookForPattern(x)) 
        return true ;
return false ;


// good:
return find_if(cbegin(v), cend(v), LookForPattern) != cend(v) ;

// tired of writing v.begin(),v.end()
return find_if(v,LookForPattern)!=cend(v);

// range version of std::find_if: 
template<typename Cont, typename Pred>
Iterator<Cont> find_if(Cont& c, Pred p)
{
    return std::find_if(begin(c),end(c),p);
}

// Generalize: Still return by value

template<typename Iter, typename Predicate>
vector<Value_type<Iter>> collect(Iter first, Iter last, Predicate pred)
// copy elements that meets pred() from [first:last)
{
    vector<Value_type<Iter>> res;
    for (auto p = first; p!=last; ++p)
        if (pred(*p)) //
            res.push_back(*p);
    return res;
}

bool odd(int x) { return x % 2; }

void test()
{
    auto lst = { 1, 2, 3, 4, 5, 6 };
    auto ss = collect(begin(lst), end(lst), odd);     // {1,3,5}
}

// 
bool initial_s(const string& s) { return s.size() && s[0]=='s'; }

void user6()
{
    auto strings = collect(istream_iterator<string>{cin},
                   istream_iterator<string>{},
                   initial_s);
}

range/container algorithms

template<typename Sequence, typename Predicate>
vector<Value_type<Sequence>> collect(Sequence seq, Predicate p)
{
    vector<Value_type<Sequence>> res;
    for (const auto& x : seq)
        if (p(x))
            res.push_back(x);
    return res;
}

void user()
{
    // auto ss1 = collect({ 1, 2, 3, 4, 5, 6 }, odd);     // error: Bummer!
    auto lst = { 1, 2, 3, 4, 5, 6 };
    auto ss2 = collect(lst, odd);             // {1,3,5}
    // auto ss3 = collect(cin,  initial_s);      // error: logically impossible
    auto ss4 = collect(Istream_range<string>{cin}, initial_s);
    auto is = Istream_range<string>{cin};
    auto ss5 = collect(is, [](auto& s){ return s.size() && s[0] == 's'; });
}