Was i not allowed to do that ?

In this case i'm using chrome official normal release.

I have learned to check my browser settings and plugins after installing software. Software tend to install plugins and change settings without the users permission.
Good example of this is the microsoft's live installer another one is skype.
When detected i removed them because they are always buggy and slow down the browser and make it crash. They also tend to spy and leak personal information. Ads love to query these plugins for information.

Anyway, will you fix this issue soon ? Now that you know it exists. 

No matter how many times i click the sign out link the page reloads and i still see the sign out link.

It's been several months why have you not fixed this issue. It's major security problem. I can't sign in on a public computer with the way this is now.

The workaround  that worked before was that i went to hotmail.com and signed out from there but not even that works now. What the hell have you done ? Isn't microsoft supposed to be really anal about security ?

Please fix it once and for all. Better yet provide an alternative to your all-in-one live account system.

Bit of topic but still relevant:
Having everything in one account is convenient for the lazy and non-security conscious people. But when things go wrong and they will like somebody gets hold the account info and gets in.
Now you are connecting it to windows login too ?!
I'm guessing its for syncing (hyped up but really unstable and crappy "cloud" tech).
That's monopoly again. Integrating live account service with windows !
Will EU have to tell you it's wrong again ?!

Dec 01, 2011 at 11:53 PM, STL wrote

It's very useful to me to see what people are interested in hearing about - thanks for starting this.

So does that mean you have forgotten or lost the requests in previous video threads / comments?
I recall you requesting for what users are interested in and several responded.
Perhaps you should consider them before accepting new requests ?
You really should go through the comments of the videos, there are some good requests there. 

On advanced stl topics:
Not sure how advanced it would be but i'm curious of how you would implement a natural string sort function.

I've seen many versions and i'm curious of how somebody like you with good knowledge-base of the STL and how to use it correctly would implement such a function.

Is that too specific of a request ?

template <typename WP = WPARAM, typename LP = LPARAM, typename R_TYPE>
R_TYPE SendMessage( __in UINT uMsg, __in WP wParam = 0, __in LP lParam = 0)
{
    return reinterpret_cast<R_TYPE>(::SendMessage(nullptr, uMsg, reinterpret_cast<WPARAM>(wParam), reinterpret_cast<LPARAM>(lParam)));
}

I want to be able to things like this without those annoying casts all the time:

SendMessage(1, 1, "test message");
SendMessage(1, "test message"); // using default 0
SendMessage(1); // using defaults 0, 0

Is there i trick i don't know about or will the compiler win this template battle too ?
C++11 standard looks promising for this problem but vsNext not so much, to put it in a civilized manner....
So can this be done in vs2010 ? 

I'm using vs2010, willing to use mingw-gcc but prefers vc2010.

template<typename Functor>
inline scope_guard<Functor> create_scope_guard(const Functor &f) throw()
{
    return scope_guard<Functor>(const_cast<Functor&>(f));
}

C:\test>g++ -Wall -Wextra -std=c++0x -o main.exe test.cpp
test.cpp: In function 'scope_guard<Functor> create_scope_guard(const Functor&) [with Functor = void()]':
test.cpp:100:45:   instantiated from here
test.cpp:85:53: error: invalid use of const_cast with type 'void (&)()', which is a pointer or reference to a function type
test.cpp:86:1: warning: control reaches end of non-void function

template<typename Functor>
class scope_guard {
public:
    explicit scope_guard(Functor &f, false_type) throw()
        : _f(addressof(f))
    {}

    explicit scope_guard(Functor &f, true_type) throw()
        : _f(f)
    {}

    ~scope_guard() throw()

    {
        if( _f != nullptr )
        {
            try
            {
                (*_f)();
            }
            catch(...)
            {
                std::terminate();
            }
        }
    }

    scope_guard(scope_guard<Functor> &&other) throw()
        : _f(other._f)
    {
        other._f = nullptr;
    }

    scope_guard<Functor>& operator=(scope_guard<Functor> &&other) throw()
    {
        if( &other != this )
        {
            _f = other._f;
            other._f == nullptr;
        }
        return *this;
    }
private:
    scope_guard(const scope_guard<Functor>&);
    scope_guard<Functor>& operator=(const scope_guard<Functor>&);

    Functor *_f;
};

template<typename Functor>
inline scope_guard<Functor> create_scope_guard(Functor &f) throw()
{
    return scope_guard<Functor>(f, typename is_function<Functor>::type());
}

inline void noarg_func( void ) {
    cout << "noarg_func" << endl;
}
struct noarg_functor {
    inline void operator()( void ) const {
        cout << "noarg_functor" << endl;
    }
};

void test() {
    auto guard1 = create_scope_guard([](){cout << "noarg_lambda" << endl;});
    auto guard2 = create_scope_guard(noarg_functor());
    auto guard3 = create_scope_guard(noarg_func); // <- Doesn't get inlined
}

int main()
{
    test();
}

Only problem is that this class use of " C4239: nonstandard extension used ..."
which is very bad 

I remember doing something similar. The problem was the same as in your suggestion.

It doesn't work for plain functions, in your case it because of "std::addressof".

I remember trying to use some template magic, traits, is_function<..>, conditional, enable_if,  to make the compiler choose between two version but i failed miserably.

The compiler just didn't want to play ball. Either it's due to bugs in the compiler or me missing some small detail.

I just could figure out why it didn't work. Not even g++'s more helpful error messages helped me.

About 'Mr Crash' auto in class pseudo code: Would have been sweet if auto worked in classes like that. It would have reduced the pain of some template programming though it would surely cause other problems.

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

using namespace std;

template <typename FwdIt, typename OutIt, typename Predicate>
inline FwdIt move_if(FwdIt first, FwdIt last, OutIt out, Predicate pred)
{
    first = find_if(first, last, pred);

    for (auto i = first; i != last; ++i)
    {
        if (pred(*i)) // Should it move it ?
            *out++ = move(*i); // Move it.
        else
            *first++ = move(*i);
    }
    return first;
}

// move_if have become partition_move
template <typename InIt, typename OutIt1, typename OutIt2, typename Predicate>
inline pair<OutIt1, OutIt2> move_if(InIt first, InIt last, OutIt1 out_false, OutIt2 out_true, Predicate pred)
{
    for (auto i = first; i != last; ++i)
    {
        if (pred(*i)) // Should it move it ?
            *out_true++ = move(*i); // Move it.
        else
            *out_false++ = move(*i);
    }
    return make_pair<OutIt1, OutIt2>(out_false, out_true);
}

int main()
{
    auto is_even = [](const char c){return (c % 2) == 0;};

    std::istringstream iss("The quick brown fox jumps over the lazy dog");
    std::istream_iterator<char> begi(iss), endi;

    vector<char> n_f, n_t;
    move_if(begi, endi, back_inserter(n_f), back_inserter(n_t), is_even);

    auto print_vec_char = [](const vector<char> &v) {
        cout << "[" << v.size() << "]";
        for_each(v.cbegin(), v.cend(), [](const char c) {
            cout << " " << c;
        });
        cout << endl;
    };
    
    print_vec_char(n_f);
    print_vec_char(n_t);
}

/* Output:
[19] e q u i c k o w o u m s o e e a y o g
[16] T h b r n f x j p v r t h l z d
*/

> I was assuming that the whole source range would be discarded.

 How would you do it if the source range would be used ?

I a pedant so making my code as efficient as possible is a goal.

Using move_if is more efficient because you need one less container and if you really needed to preserve the input container then partition_copy would do the trick.

Yes it's fuzzy but can be controlled for example with filters or other algorithms.

"is itself fuzzy: what are you actually trying to do here?"

Group files in a more human way.

Mostly its for fun because i will learn something new also want to see if its even possible.

I'm having a hard time finding the right algorithm for the job. There's not really a list of algorithm you can search through for the right one. Turning math formulas into code isn't easy, its actually hard.

So i'm asking for help. Hoping someone here knows something about this subject.

Here's the example code i'm playing with: (Credits for the code goes to Mr Stephan T Lavavej, thank you again !)

#include <stddef.h>
#include <algorithm>
#include <iterator>
#include <numeric>
#include <vector>
using namespace std;

// <a href="http://en.wikipedia.org/wiki/Levenshtein_distance">http://en.wikipedia.org/wiki/Levenshtein_distance</a>
template <typename FwdIt1, typename FwdIt2> size_t levenshtein_distance(
    FwdIt1 first1, FwdIt1 last1, FwdIt2 first2, FwdIt2 last2) {

    const size_t size1 = distance(first1, last1);
    const size_t size2 = distance(first2, last2);

    if (size1 > size2) {
        return levenshtein_distance(first2, last2, first1, last1);
    }

    vector<size_t> prev(size1 + 1);
    vector<size_t> curr(size1 + 1);

    iota(curr.begin(), curr.end(), 0);

    FwdIt2 iter2 = first2;

    for (size_t j = 0; j < size2; ++j, ++iter2) {
        prev.swap(curr);

        curr[0] = j + 1;

        FwdIt1 iter1 = first1;

        for (size_t i = 0; i < size1; ++i, ++iter1) {
            if (*iter1 == *iter2) {
                curr[i + 1] = prev[i];
            } else {
                curr[i + 1] = min(curr[i], min(prev[i + 1], prev[i])) + 1;
            }
        }
    }

    return curr.back();
}

#include <algorithm>
#include <iostream>
#include <ostream>
#include <regex>
#include <set>
#include <string>
#include <vector>
using namespace std;

struct size_greater {
    template <typename T> bool operator()(const T& a, const T& b) const {
        return a.size() > b.size();
    }
};

vector<vector<string>> fuzzy_grouping(const vector<string>& v) {
    multiset<string, size_greater> s(v.begin(), v.end());

    vector<vector<string>> ret;

    while (!s.empty()) {
        string primary = *s.begin();
        s.erase(s.begin());

        ret.push_back(vector<string>());
        ret.back().push_back(primary);

        const size_t similar = max(static_cast<size_t>(1), primary.size() / 2);

        for (auto i = s.begin(); i != s.end(); ) {
            if (levenshtein_distance(primary.begin(), primary.end(), i->begin(), i->end()) <= similar) {
                ret.back().push_back(*i);
                s.erase(i++);
            } else {
                ++i;
            }
        }
    }

    return ret;
}

int main() {
    const regex r("\\w+");

    vector<string> v;

    for (string s; getline(cin, s); ) {
        v.insert(v.end(), sregex_token_iterator(s.begin(), s.end(), r), sregex_token_iterator());
    }

    vector<vector<string>> groups = fuzzy_grouping(v);

    for (auto i = groups.cbegin(); i != groups.cend(); ++i) {
        for (auto k = i->begin(); k != i->end(); ++k) {
            cout << *k << " ";
        }

        cout << endl;
    }
}

Sometimes i do trust the compiler a bit too much thinking its smart enough to

understand what i'm doing when it can be really stupid and stubborn sometimes.

Here's version 3:

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

using namespace std;

template <typename FwdIt, typename OutIt, typename Predicate>
inline FwdIt move_if(FwdIt first, FwdIt last, OutIt out, Predicate pred)
{
    first = find_if(first, last, pred);
    if (first == last)
        return first; // Nothing to move.

    for (auto i = first; i != last; ++i)
    {
        if (pred(*i)) // Should it move it ?
            *out++ = move(*i); // Move it.
        else
            *first++ = move(*i);
    }
    return first;
}

int main()
{
    vector<int> v(10);
    generate(v.begin(), v.end(), [] () -> int {
        static size_t i = 1;
        return i++ * 11;
    });

    auto is_even = [](const int i){return (i % 2)==0;};
    
    //const size_t size = count_if(v.cbegin(), v.cend(), is_even);
    //vector<int> n(size);
    //auto new_end = move_if(v.begin(), v.end(), n.begin(), is_even);

    // This is slower then the code above when 'vector<int> v(10000);'
    // Naively timed test only using QueryPerformanceCounter
    // Is this what you meant ?
    vector<int> n;
    n.reserve(v.size());
    auto new_end = move_if(v.begin(), v.end(), back_inserter(n), is_even);

    v.erase(new_end, v.end());

    auto print_vec_int = [](const vector<int> &v) {
        cout << "[" << v.size() << "]";
        for_each(v.cbegin(), v.cend(), [](const int i) {
            cout << " " << i;
        });
        cout << endl;
    };

    print_vec_int(v);
    print_vec_int(n);
}

/* Output:
[5] 11 33 55 77 99
[5] 22 44 66 88 110
*/



When ever i see 'back_inserter' i think of performance loss. Is that incorrect ?

What do you think about that 'find_if' "optimization" ?

5. I know its bad to write code when tired but coding just flows when tired. Oh the dilemma  

6. Nice catch. Btw how big of an issue is that ? Cant the compiler optimize that away ?

7. I'm not used to doing that kind of math but i understand what you mean.

Naively i just run a few tests and see which runs the fastest.
The only goal i have is to make it a performant and correct as possible.

Learning something new in the process is always fun too.
"reallocation overhead (which usually isn't a big deal)"
That surprised me a bit. Isn't (&&) and std::move's main reason for existing just
because of reducing reallocation overhead ?

Now i'm a bit confused. When writing algorithms shouldn't you have reallocation
overhead in mind or are there some simple guidelines you can follow  ?

8. See code, please.

9. I wasn't really concentrating on optimizing the debug print code but i would have
changed it eventually anyway.
Performance issues bug me until i fix them.

10. But it will not hurt performance right or is it bad in some way ?

"Yes, that was intentional."
Explain more, please. Explain your thinking.
If the algorithm didnt clean up after itself then the programer would need to do extra work
 Good example here would be 'remove_if' algorithm
Also it would leave the input container in a less performant state.
That is using it as is would eat extra cpu cycles.

How big of an issue is it really that move_if use forward iterators ?

I'm beginning to understand the many decisions you must be making working on the STL
for every single function. Your C++ kung fu must indeed be strong ;)
How do you know when to stop: optimizing / correction cleaning and move on to the next thing ?

1. I'm not sure what the difference is between forward iterators and input iterators.
Isn't forward iterator the most generic iterator ? I'll have to refresh my c++ knowledge.

2. Yes, it did feel wrong using a container. Using a container is less general too. Now when i think about it, i should have gone for the more general way.

2 and 3: At the time i was thinking that the programmer would usually alloc up a new container with the needed size anyway so why not do it in the function. But yes it does limit its usability.

4. What do you mean ? 
move_if reuses the input iterator which results in more efficiency then partition_copy.
I based move_if on how remove_if works.

Here's version 2 - how move_if should have been in the first place

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

using namespace std;

template <typename InputIt, typename OutIt, typename Predicate>
inline InputIt move_if(InputIt first, InputIt last, OutIt out, Predicate pred)
{
    if (first == last)
        return last; // Empty so nothing to move
    InputIt new_end = first;
    for (auto i = first; i != last; ++i)
    {
        if (pred(*i)) // Should it move it ?
            *out++ = move(*i);
        else
            *new_end++ = move(*i);
    }
    return new_end;
}

int main()
{
    vector<int> v(10);
    generate(v.begin(), v.end(), [] () -> int {
        static size_t i = 1;
        return i++ * 11;
    });

    auto is_prime = [](int i){return (i % 2)==0;};
    const size_t size = count_if(v.cbegin(), v.cend(), is_prime);
    vector<int> n(size);
    auto new_end = move_if(v.begin(), v.end(), n.begin(), is_prime);
    v.erase(new_end, v.end());

    auto print_vec_int = [](vector<int> v) {
        cout << "[" << v.size() << "]";
        for_each(v.cbegin(), v.cend(), [](const int &i) {
            cout << " " << i;
        });
        cout << endl;

    };

    print_vec_int(v);
    print_vec_int(n);
}

/* Output:
[5] 11 33 55 77 99
[5] 22 44 66 88 110
*/

Your suggestion of using make_move_iterator() with copy_if() while the moving works it doesn't fix up the input container.

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

using namespace std;

int main()
{
    vector<int> v(10);
    generate(v.begin(), v.end(), [] () -> int {
        static size_t i = 1;
        return i++ * 11;
    });

    auto is_prime = [](int i){return (i % 2)==0;};
    const size_t size = count_if(v.cbegin(), v.cend(), is_prime);
    vector<int> n(size);
    copy_if(make_move_iterator(v.begin()), make_move_iterator(v.end()), n.begin(), is_prime);

    auto print_vec_int = [](vector<int> v) {
        cout << "[" << v.size() << "]";
        for_each(v.cbegin(), v.cend(), [](const int &i) {
            cout << " " << i;
        });
        cout << endl;

    };

    print_vec_int(v);
    print_vec_int(n);
}

/* Output:
[10] 11 22 33 44 55 66 77 88 99 110
[5] 22 44 66 88 110
*/

Using your example code (slightly modified):

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

using namespace std;

int main()
{
    vector<string> dst;

    {
        vector<string> src;

        src.push_back("The Motion Picture");
        src.push_back("The Wrath Of Khan");
        src.push_back("The Search For Spock");
        src.push_back("The Voyage Home");
        src.push_back("The Final Frontier");
        src.push_back("The Undiscovered Country");
        src.push_back("Generations");
        src.push_back("First Contact");
        src.push_back("Insurrection");
        src.push_back("Nemesis");
        src.push_back("Star Trek");

        copy_if(
            make_move_iterator(src.begin()),
            make_move_iterator(src.end()),
            back_inserter(dst),
            [](const string& s) {
                return s != "The Final Frontier";
        });

        for (auto i = src.begin(); i != src.end(); ++i) {
            cout << "\"" << *i << "\""<< endl;
        }
    }

    cout << endl;

    for (auto i = dst.begin(); i != dst.end(); ++i) {
        cout << "\"" << *i << "\""<< endl;
    }
}

/* Output:
""
""
""
""
"The Final Frontier"
""
""
""
""
""
""

"The Motion Picture"
"The Wrath Of Khan"
"The Search For Spock"
"The Voyage Home"
"The Undiscovered Country"
"Generations"
"First Contact"
"Insurrection"
"Nemesis"
"Star Trek"

*/

Both your code and Burkholder's code have a big overhead.
Is there a way to minimize the overhead like in my example ? 

Like this little code example:

inline void normal_function(int v) {
    cout << "normal_function: " << v << endl;
}

template <typename Function>
class sop {
    Function f_;
public:
    sop(Function fun) : f_(fun) {}
    ~sop() {
        f_();
    }
};

void t_sop()
{
    auto l = [](){
        normal_function(123);
    };
    sop<decltype(l)> s(l);
}

int main()
{
    t_sop();
    return 0;
}

Generated code in win32 release mode:

    t_sop();
00291000  mov         eax,dword ptr [__imp_std::endl (292044h)]  
00291005  mov         ecx,dword ptr [__imp_std::cout (292068h)]  
0029100B  push        eax  
0029100C  push        7Bh  
0029100E  push        offset string "normal_function: " (292114h)  
00291013  push        ecx  
00291014  call        std::operator<<<std::char_traits<char> > (2910F0h)  
00291019  add         esp,8  
0029101C  mov         ecx,eax  
0029101E  call        dword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (292050h)]  
00291024  mov         ecx,eax  
00291026  call        dword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (29204Ch)]  

Shouldn't you be able to achieve this with the power of c++0x but without this big overhead ?

What's your opinion of it (improvements, bugs, etc...) ?

template <typename FwdIt, typename Container, typename Predicate>
inline FwdIt move_if(FwdIt first, FwdIt last, Container &cont, Predicate pred)
{
    if (first == last)
        return last; // Empty so nothing to move
    const size_t size = count_if(first, last, pred);
    if (size == 0)
        return last; // Nothing to move
    cont.resize(size);
    FwdIt new_end = first;
    auto c = cont.begin();
    for (auto i = first; i != last; ++i)
    {
        if (pred(*i)) // Should it move it ?
            *c++ = move(*i);
        else
            *new_end++ = move(*i);
    }
    return new_end;
}

How you use it:

int main()
{
    vector<int> v(10);
    generate(v.begin(), v.end(), [] () -> int {
        static size_t i = 1;
        return i++ * 11;
    });

    vector<int> n;
    auto new_end = move_if(v.begin(), v.end(), n, [](int i){return (i % 2)==0;});
    v.erase(new_end, v.end());

    auto print_vec_int = [](vector<int> v) {
        cout << "[" << v.size() << "]";
        for_each(v.cbegin(), v.cend(), [](const int &i) {
            cout << " " << i;
        });
        cout << endl;

    };

    print_vec_int(v);
    print_vec_int(n);
}
/* Output:
[5] 11 33 55 77 99
[5] 22 44 66 88 110
*/