C Teilstrings / C-string-slicing?

Gibt es nicht; haben Sie Ihren eigenen schreiben.

Ehrlich, Sie brauchen nicht, eine string-slicing-Funktion nur um zu überprüfen, Palindrome innerhalb von Teilstrings:

/* start: Pointer to first character in the string to check.
 * end: Pointer to one byte beyond the last character to check.
 *
 * Return:
 *   -1 if start >= end; this is considered an error
 *    0 if the substring is not a palindrome
 *    1 if the substring is a palindrome
 */
int
ispalin (const char *start, const char *end)
{
  if (start >= end)
    return -1;

  for (; start < end; ++start)
    if (*start != *--end)
      return 0;

  return 1;
}

Mit, dass, können Sie die folgenden:

int
main ()
{
  const char *s = "madam";

  /* i: index of first character in substring
   * n: number of characters in substring
   */
  size_t i, n;

  size_t len = strlen (s);

  for (i = 0; i < len; ++i)
    {
      for (n = 1; n <= len - i; ++n)
        {
          /* Start of substring. */
          const char *start = s + i;

          /* ispalin(s[i:i+n]) in Python */
          switch (ispalin (start, start + n))
            {
            case -1:
              fprintf (stderr, "error: %p >= %p\n", (void *) start, (void *) (start + n));
              break;
            case 0:
              printf ("Not a palindrome: %.*s\n", (int) n, start);
              break;
            case 1:
              printf ("Palindrome: %.*s\n", (int) n, start);
              break;
            } /* switch (ispalin) */
        } /* for (n) */
    } /* for (i) */
}

Natürlich, wenn Sie wirklich wollten, ein string-slicing-Funktion nur für die Ausgabe (da Sie technisch sollte das nicht wirken, eine size_t zu int), und Sie wollen immer noch in der Lage sein, um die Ausgabe zu formatieren leicht, die Antwort von Paul Griffiths sollten reichen ganz gut, oder können Sie mir oder auch einer strncpy oder die nicht-Standard -strlcpy, obwohl Sie alle haben Ihre stärken und Schwächen:

/* dest must have
 *     1 + min(strlen(src), n)
 * bytes available and must not overlap with src.
 */
char *
strslice (char *dest, const char *src, size_t n)
{
  char *destp = dest;

  /* memcpy here would be ideal, but that would mean walking the string twice:
   * once by calling strlen to determine the minimum number of bytes to copy
   * and once for actually copying the substring.
   */
  for (; n != 0 && *src != 0; --n)
    *destp++ = *src++;

  *destp = 0;

  return dest;
}

strslice tatsächlich funktioniert wie eine Kombination von strncpy und die nicht-Standard -strlcpy, obwohl es Unterschiede zwischen diesen drei Funktionen:

• strlcpy schneiden Sie die kopierte Zeichenfolge kurz-fügen Sie eine null-terminator an dest[n - 1], so kopieren genau n bytes vor dem hinzufügen der null-terminator erfordert, dass Sie pass n + 1 als die Größe des Puffers.
• strncpy darf nicht die Zeichenkette beenden an alle, verlassen dest[n - 1] gleich src[n - 1], so würden Sie brauchen, um hinzuzufügen, ein null-terminator selbst, nur für den Fall. Wenn n größer ist als die src Länge der Zeichenfolge, dest wird aufgefüllt mit null-Abschlusszeichen bis n bytes geschrieben wurden.
• strslice wird, kopieren Sie bis zu n bytes, falls erforderlich, wie strncpy und erfordert ein zusätzliches byte für das null-terminator, also ein maximum von n+1 bytes notwendig. Sie nicht verschwenden Zeit mit dem schreiben von unnötigen null-terminatoren als strncpy tut. Dies kann gedacht werden als eine "leichte strlcpy" mit einem kleinen Unterschied in dem, was n Mittel und können verwendet werden, wobei der resultierende string-Länge keine Rolle.

Könnte man auch eine memslice Funktion, wenn Sie wollte, die es erlauben würde, für eingebettete null-Byte, aber es existiert bereits als memcpy.