У меня есть две строки, которые я хотел бы сравнить: String и String: Есть ли библиотечная функция, которая возвращала бы true, когда передала эти две строки, но false для скажем String и OtherString?
Чтобы быть точным, я хочу знать, является ли одна строка префиксом другой.
Используйте std::mismatch. Передайте более короткую строку в качестве первого диапазона итераторов и дольше, чем диапазон второго итератора. Возврат - это пара итераторов, первый - итератор в первом диапазоне, второй - второй. Если первый конец первого диапазона, то вы знаете, что короткая строка является префиксом более длинной строки, например.
std::string foo("foo");
std::string foobar("foobar");
auto res = std::mismatch(foo.begin(), foo.end(), foobar.begin());
if (res.first == foo.end())
{
// foo is a prefix of foobar.
}
Если вы знаете, какая строка короче, процедура проста, просто используйте
std::equal с более короткой строкой. Если вы этого не сделаете,
например, следующее:
bool
unorderIsPrefix( std::string const& lhs, std::string const& rhs )
{
return std::equal(
lhs.begin(),
lhs.begin() + std::min( lhs.size(), rhs.size() ),
rhs.begin() );
}
std::string(X).find(Y) равен нулю тогда и только тогда, когда Y является префиксом X
С string:: compare вы должны написать что-то вроде:
bool match = (0==s1.compare(0, min(s1.length(), s2.length()), s2,0,min(s1.length(),s2.length())));
В качестве альтернативы, если мы не хотим использовать функцию члена length():
bool isPrefix(string const& s1, string const&s2)
{
const char*p = s1.c_str();
const char*q = s2.c_str();
while (*p&&*q)
if (*p++!=*q++)
return false;
return true;
}
Это и эффективно, и удобно:
str.compare(0, pre.size(), pre) == 0
compare выполняется быстро, потому что он использует метод fast traits::compare и не должен копировать какие-либо данные.
Здесь он будет сравнивать символы std::min(str.size(), pre.size()) но если символы в двух диапазонах равны, он также проверяет длину pre и возвращает ненулевое значение, если pre дольше, чем это.
Смотрите документацию на cplusplus.com.
Если вы можете разумно игнорировать любые многобайтовые кодировки (например, UTF-8), вы можете использовать strncmp для этого:
// Yields true if the string 's' starts with the string 't'.
bool startsWith( const std::string &s, const std::string &t )
{
return strncmp( s.c_str(), t.c_str(), t.size() ) == 0;
}
Если вы настаиваете на использовании причудливой версии на С++, вы можете использовать алгоритм std::equal (с дополнительным преимуществом, которое ваша функция также работает для других коллекций, а не только строк):
// Yields true if the string 's' starts with the string 't'.
template <class T>
bool startsWith( const T &s, const T &t )
{
return s.size() >= t.size() &&
std::equal( t.begin(), t.end(), s.begin() );
}
Как насчет просто:
bool prefix(const std::string& a, const std::string& b) {
if (a.size() > b.size()) {
return a.substr(0,b.size()) == b;
}
else {
return b.substr(0,a.size()) == a;
}
}
С++ не C, безопасный, простой, эффективный.
Протестировано с помощью
#include <string>
#include <iostream>
bool prefix(const std::string& a, const std::string& b);
int main() {
const std::string t1 = "test";
const std::string t2 = "testing";
const std::string t3 = "hello";
const std::string t4 = "hello world";
std::cout << prefix(t1,t2) << "," << prefix(t2,t1) << std::endl;
std::cout << prefix(t3,t4) << "," << prefix(t4,t3) << std::endl;
std::cout << prefix(t1,t4) << "," << prefix(t4,t1) << std::endl;
std::cout << prefix(t1,t3) << "," << prefix(t3,t1) << std::endl;
}
Самый простой способ - использовать функции substr() и compare():
string str = "Foobar";
string prefix = "Foo";
if(str.substr(0, prefix.size()).compare(prefix) == 0) cout<<"Found!";
Вы можете использовать это:
для c++ 14 или меньше
bool has_prefix
(const std::string& str, const std::string& prefix) {
return str.find(prefix, 0) == 0;
}
для c++ 17
//it a little faster
auto has_prefix
(const std::string& str, const std::string_view& prefix) -> decltype(str.find(prefix) == 0) {
return str.find(prefix, 0) == 0;
}
Я думаю, strncmp ближе всего к тому, что вы ищете.
Хотя, если вы переформулируете, вы можете искать strstr(s2,s1)==s2, что не обязательно является наиболее эффективным способом сделать это. Но вы не хотите работать n; -)
Хорошо, хорошо, версия С++ будет !s1.find(s2).
Хорошо, вы можете сделать это еще больше С++, что-то вроде этого: std::mismatch(s1.begin(),s1.end(),s2.begin()).first==s1.end().
str1.find(str2) возвращает 0, если целая str2 найдена в индексе 0 str1:
#include <string>
#include <iostream>
// does str1 have str2 as prefix?
bool StartsWith(const std::string& str1, const std::string& str2)
{
return (str1.find(str2)) ? false : true;
}
// is one of the strings prefix of the another?
bool IsOnePrefixOfAnother(const std::string& str1, const std::string& str2)
{
return (str1.find(str2) && str2.find(str1)) ? false : true;
}
int main()
{
std::string str1("String");
std::string str2("String:");
std::string str3("OtherString");
if(StartsWith(str2, str1))
{
std::cout << "str2 starts with str1" << std::endl;
}
else
{
std::cout << "str2 does not start with str1" << std::endl;
}
if(StartsWith(str3, str1))
{
std::cout << "str3 starts with str1" << std::endl;
}
else
{
std::cout << "str3 does not start with str1" << std::endl;
}
if(IsOnePrefixOfAnother(str2, str1))
{
std::cout << "one is prefix of another" << std::endl;
}
else
{
std::cout << "one is not prefix of another" << std::endl;
}
if(IsOnePrefixOfAnother(str3, str1))
{
std::cout << "one is prefix of another" << std::endl;
}
else
{
std::cout << "one is not prefix of another" << std::endl;
}
return 0;
}
Вывод:
str2 starts with str1
str3 does not start with str1
one is prefix of another
one is not prefix of another
Что случилось с "нахождением" и проверкой результата для позиции 0?
string a = "String";
string b = "String:";
if(b.find(a) == 0)
{
// Prefix
}
else
{
// No Prefix
}
bool IsPrefix(const string& prefix, const string& whole)
{
return whole.size() >= prefix.size() && whole.compare(0, prefix.size(), prefix) == 0;
}