Wie erhält man in C++0x generell das Ende einer Zeichenkette?

Question

template<typename ForwardIterator, typename StringType>
inline bool starts_with(ForwardIterator begin, ForwardIterator end, const StringType& target)
{
    assert(begin < end);
    if (std::distance(std::begin(target), std::end(target)) > std::distance(begin, end))
    {
        return false;
    }
    return std::equal(std::begin(target), std::end(target), begin);
}

Dies scheitert daran, dass std::end gibt eine nach der '\0' wenn StringType ist ein String-Literal, nicht die '\0' . (In dieser Hinsicht ist es ähnlich wie bei der Bereichsbezogene Inkonsistenz der Schleife ) Wie kann man das umgehen?

Answer 1

Passieren Sie eine ordnungsgemäße std::string stattdessen.

Zeichenkettenliterale haben keinen eigenen "Typ"; Ihre Eingabedaten könnten im Grunde als verfälscht angesehen werden.

Vous podría Spezialisierung/Überlastung für char const* die fast werden generell mit Null beendet.

Answer 2

Ihre API ist eine Vorlagen-API. Verwenden Sie die Vorlagenspezialisierung, um spezialisierte Versionen zu erstellen für char* und die eigentlichen Iterator-Typen.

Es gibt auch einen Grund, warum die C++-Standardalgorithmen nur mit Iteratoren und nicht mit Containern arbeiten (wie StringType ).

Answer 3

Wie wäre es, wenn Sie eine kleine Trait-Klasse für Ihren String-Template-Parameter erstellen:

template <typename TString>
struct StringBounds
{
  typedef typename TString::const_iterator citerator;
  static citerator Begin(const TString & s) const { return std::begin(s); }
  static citerator End  (const TString & s) const { return std::end(s); }
};

template <typename TChar, size_t N>
struct StringBounds<TChar[N]>
{
  typedef const TChar * citerator;
  static citerator Begin(const TChar(&s)[N]) const { return s; }
  static citerator End (const TChar(&s)[N]) const { return s + N - 1; }
};

Verwendung:

std::equal(StringBounds<StringType>::Begin(target), StringBounds<StringType>::End(target), begin)