std :: vector中的字符串验证

Question

I am working on a code where I need to validate a std::vector filled with multiple std::string objects. The logic is that I need to check if all of the objects are valid or not. If yes then display a message saying that input vector is valid, error otherwise. Here is what I have so far.

#include<iostream>
#include<vector>
#include<numeric>
#include<boost/foreach.hpp>

short multiply(short s1,short s2)
{
    return s1*s2;
}
bool validate(const std::vector<std::string> &in)
{
    std::vector<short>check(in.size(),0);
    auto checkitr = check.begin();

    BOOST_FOREACH(std::string str,in)
    {
        for(auto itr = str.begin(); itr != str.end(); ++itr)
        {
            if(*itr == 'c')
            {
                *checkitr = 1;
                break;
            }
        }
        ++checkitr;
    }
    short product = std::accumulate(check.begin(),check.end(),1,multiply);

    return ( (product) ? true : false );
}

int main()
{
    std::string s1("abcd");
    std::string s2("lncd");
    std::vector<std::string>iVec;

    iVec.push_back(s1);
    iVec.push_back(s2);

    bool isValid = validate(iVec);

    if(isValid){
        std::cout<<"This Vector is valid   "<<std::endl;    
    }
    else
    {   
        std::cout<<"This is an invalid vector  "<<std::endl;        
    }

    iVec.push_back(std::string("ghkd"));

    isValid = validate(iVec);

    if(isValid){
        std::cout<<"This Vector is valid  "<<std::endl;

    }
    else
    {
        std::cout<<"This is an invalid vector  "<<std::endl;
    }   

    return 0;
}

This runs fine and gives me the result that I need.My question is, Is there any other better/performance efficient approach in standard algorithm or boost library that I can use instead of my current approach?

Answer 1

It would have been nice to include a description of what the validation algorithm should validate, but I suppose the source is self-documenting. To find out whether a vector of strings contains only strings that contain a c , I'd use

#include <algorithm> // for std::none_of
#include <iterator>  // for std::begin, std::end

bool validate(const std::vector<std::string> &in)
{
  return std::none_of(std::begin(in),
                      std::end  (in),
                      [](std::string const &s) {
                        return s.find('c') == std::string::npos;
                      });
}

std::none_of checks if no element in a range satisfies a condition, and the [](std::string const &s) { ... } is a lambda expression that describes the condition std::none_of is supposed to use. Put together, this checks whether there is a string that doesn't contain a c in the vector, returns true if there wasn't and false if there was.

The main runtime advantage over your code of this is that it stops checking as soon as it finds a string that doesn't contain a c ; other than that, it is mostly shorter (unless the implementation of std::string::find contains clever optimizations, which is not impossible).

Side note: It would be possible to leave out many of the std:: in that code because of argument-dependent name lookup . I left some out in the original code but put them back in after @BoBTFish commented on it to avoid confusion; I tend to leave them out for begin and end because I'm used to doing it. This is because of a (somewhat) useful trick in the context of templates that has no real bearing on the above function, but here it is (if you're interested):

If you want this validation routine to work for more than vectors, you could write

template<typename Container>
bool validate(Container &&in)
{
  using std::begin;
  using std::end;

  return std::none_of(begin(std::forward<Container>(in)),
                      end  (std::forward<Container>(in)),
                      [](std::string const &s) {
                        return s.find('c') == std::string::npos;
                      });
}

This is adapted from a similar technique for std::swap described in Effective C++ by Scott Meyers; the useful thing about it is that if there are fitting implementations of begin(...) and end(...) in the namespace where the type to which Container refers is defined, they are preferred over std::begin and std::end -- which is good because if they exist, it is sane to assume that they provide a better fit.

(Granted that std::begin and std::end 's default behavior of using the .begin() and .end() member functions makes such implementations of begin and end mostly unnecessary, but I have seen stranger things in real-life code.)

EDIT: I didn't think of std::none_of right away; the original solution used std::find_if . std::find_if also works, of course, but std::none_of is rather obviously a better fit.