remove_if (not)

[monarch_dodra]

Basically, I have a string, and I want to remove all non alpha chars.

I'm trying to do it using algorithm, so I thought I'd do something like this:

iString.erase(
    std::remove_if(iString.begin(), iString.end(), &isalpha),
    iString.end()
);

The problem is that this removes all the alpha, the oposite of what I want to do.

I would use the algorithm std::copy_if or remove_if_not, but they don't exist. My other choice would be to pass std::not1(isalpha), but that doesn't work, since isalpha is not a function object.

I could write this:

struct isalphafuntor : public std::unary_function<int,bool>
{
    bool operator()(int iChar) const
    {
        return isalpha(iChar);
    }
};

But I would rather avoid it.

So my question is this one:

Can I, in a single line, pass the negated isalpha function to the remove if algorithm? or am I stuck with wrapping isalpha explicitly (or writting isnotalpha)?

[Codeplug]

>> My other choice would be to pass std::not1(isalpha), but that doesn't work ...
You can force the compiler to use the function instead of the macro with "&(::isalpha)". Or just use the C++ version from <locale>.

gg

[monarch_dodra]

>> My other choice would be to pass std::not1(isalpha), but that doesn't work ...
You can force the compiler to use the function instead of the macro with "&(::isalpha)". Or just use the C++ version from <locale>.

gg

I don't understand your solution. The problem with not1 is that it takes a function object, and not a function, so that doesn't solve the problem. same with the one from locale.

Or maybe I'm missing something?

[Codeplug]

Predicate objects in STL can be functions or objects.

gg

[monarch_dodra]

Predicate objects in STL can be functions or objects.

gg

Yes, that's why I can pass isalpha as an argument. however, I'm having trouble building a not1(isalpha) function. Not1 takes only function objects.

How can I negate a function, and pass the result as an argument?

[Plasmator]

Yes, that's why I can pass isalpha as an argument. however, I'm having trouble building a not1(isalpha) function. Not1 takes only function objects.

How can I negate a function, and pass the result as an argument?

That's what std::ptr_fun from the functional header's for.

[monarch_dodra]

That's what std::ptr_fun from the functional header's for.

*facepalms* thankyou Plasmator, that's what I was looking for. And here is what I wrote.

void lcase(std::string& ioString)
{
    ioString.erase(
        std::remove_if(ioString.begin(), ioString.end(), std::not1(std::ptr_fun(&isalpha))),
        ioString.end()
    );
    std::transform(ioString.begin(), ioString.end(), ioString.begin(), std::ptr_fun(&tolower));
}

I'm wondering though, which is more efficient?

std::transform(ioString.begin(), ioString.end(), ioString.begin(), &tolower);
or
std::transform(ioString.begin(), ioString.end(), ioString.begin(), std::ptr_fun(&tolower));

Is there a difference in performance? I heard function objects are faster because the compiler can inline them, but in this case, the end result is that isalpha still has to be called?

[Codeplug]

>> That's what std::ptr_fun from the functional header's for.
Right...sorry, I got stuck on function vs. macro. std::ptr_fun will make it adaptable when it's needed.

#include <iostream>
#include <string>
#include <algorithm>
#include <functional>
#include <cctype>
using namespace std;

int main()
{
    string s = "a1b23c";
    s.erase(remove_if(s.begin(), s.end(), not1(ptr_fun(&(::isalpha)))), 
            s.end());
    cout << s << endl;
    return 0;
}//main

gg

[Codeplug]

>> I'm wondering though, which is more efficient?
Premature optimization?...

I would say they are identical since std::ptr_fun will most likely be optimized away.

For maximum [premature] optimization, you could write a predicate object that used the macro version of tolower. Or assume A-Z and a-z and do it yourself.

gg

[monarch_dodra]

>> I'm wondering though, which is more efficient?
Premature optimization?...

I would say they are identical since std:tr_fun will most likely be optimized away.

For maximum [premature] optimization, you could write a predicate object that used the macro version of tolower. Or assume A-Z and a-z and do it yourself.

gg

I wouldn't call it premature optimization but more of a best practice. I'm not looking to optimize, just to find out which one is best, in general. Thanks anyways

[kempofighter]

I'm wondering though, which is more efficient?

std::transform(ioString.begin(), ioString.end(), ioString.begin(), &tolower);
or
std::transform(ioString.begin(), ioString.end(), ioString.begin(), std::ptr_fun(&tolower));

Is there a difference in performance? I heard function objects are faster because the compiler can inline them, but in this case, the end result is that isalpha still has to be called?

I've read the same thing but I don't think that it justifies turning a library function into a functor in this case. I have a hard time believing that it would significantly improve your program. If you were writing your own predicate, as opposed to using a std library function, then I would always choose a functor over writing a global or static member function. Even then I'm not sure if the performance boost is really significant. I do it because I like the object orientedness of using functors, for lack of a better phrase. When passing a predicate by value to an algorithm, the functor concept seems more intuitive to me but I have never even bothered to measure the performance difference.

If you really wanted to know, you'd have to write a couple of sample programs and study the assembly code of each. You could also use some timestamps or a profiling tool to study the differences if you want. it might be useful to do that one time just to see for yourself what kind of a difference there is.