Проверить, является ли одна строка префиксом другой

Если можно разумно игнорировать любые многобайтовые кодировки (например, UTF-8), тогда вы можете использовать _ 1_ для этого:

// 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;
}

Если вы настаиваете на использовании причудливой версии C ++, вы можете использовать алгоритм 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 ++ не 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;

}

Если у вас C ++ 17, вы можете написать лучшую версию этого, используя вместо этого std::string_view:

#include <string>
#include <string_view>

bool prefix(const std::string& a, const std::string& b) {
  if (a.size() > b.size()) {
    return std::string_view(a.c_str(),b.size()) == b;
  }
  else {
    return std::string_view(b.c_str(),a.size()) == a;
  }
}

В g ++ 7 с параметром -O3 это сводится к одному вызову memcmp, что является довольно существенным улучшением по сравнению со старой версией.

Самый простой способ - использовать функции-члены 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's 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;
}

После C ++ 20 мы можем использовать start_with, чтобы проверить, есть ли строка начинается с заданного префикса.

str.starts_with(prefix)

Кроме того, существует end_with для проверки суффикса

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
}

Я думаю, что strncmp ближе всего к тому, что вы ищете.

Хотя, если изменить формулировку, вы можете искать strstr(s2,s1)==s2, что не обязательно является наиболее эффективным способом сделать это. Но вы же не хотите тренироваться n ;-)

Хорошо, хорошо, версия для C ++ будет !s1.find(s2).

Ладно, можно сделать еще больше c ++, примерно так: std::mismatch(s1.begin(),s1.end(),s2.begin()).first==s1.end().