[C++]Hoe werkt strcmp?

[-DarkShadow-]

Ik zou de source van de standaard c string library willen bekijken, maar ik kan deze nergens vinden. Ik heb de broncode van gcc al doorgespit, maar ik kan alleen de headerfiles vinden. Ik wil dus weten hoe functies als strcmp geimplementeerd zijn. Niet hoe ik ze gebruik!

Al gevonden!

[ Voor 5% gewijzigd door -DarkShadow- op 15-01-2005 16:37 ]

[Rukapul]

probeer eens te kijken naar de source van glibc

[MLM]

sourcecode is over het algemeen niet zo makkelijk te vinden Als dat zo was zou iedereen immers sourcecode van anderen jatten. Het makkelijkst is om open-source door te zoeken naar dit soort dingen. (Strcmp is echter vrij standaard, dus daar is sourcecode vast wel van te vinden)

[-DarkShadow-]

Rukapul schreef op zaterdag 15 januari 2005 @ 16:20:
probeer eens te kijken naar de source van glibc

Hartstikke bedankt Ik heb het gevonden.

[JoetjeF]

[google=strcmp+source] levert onder andere dit op.

[BoAC]

Uit de glibc-library (versie 2.3.3):

C:

int
simple_strcmp (const char *s1, const char *s2)
{
  int ret;

  while ((ret = *(unsigned char *) s1 - *(unsigned char *) s2++) == 0
  && *s1++);
  return ret;
}

int
stupid_strcmp (const char *s1, const char *s2)
{
  size_t ns1 = strlen (s1) + 1, ns2 = strlen (s2) + 1;
  size_t n = ns1 < ns2 ? ns1 : ns2;
  int ret = 0;

  while (n--)
    if ((ret = *(unsigned char *) s1++ - *(unsigned char *) s2++) != 0)
      break;
  return ret;
}

Volgens mij glibc gemakkelijk te downen van inet

[jvaneijk]

Is dit toevallig wat je bedoeld?

C:

/*
FUNCTION
    <<strcmp>>---character string compare
    
INDEX
    strcmp

ANSI_SYNOPSIS
    #include <string.h>
    int strcmp(const char *<[a]>, const char *<[b]>);

TRAD_SYNOPSIS
    #include <string.h>
    int strcmp(<[a]>, <[b]>)
    char *<[a]>;
    char *<[b]>;

DESCRIPTION
    <<strcmp>> compares the string at <[a]> to
    the string at <[b]>.

RETURNS
    If <<*<[a]>>> sorts lexicographically after <<*<[b]>>>,
    <<strcmp>> returns a number greater than zero.  If the two
    strings match, <<strcmp>> returns zero.  If <<*<[a]>>>
    sorts lexicographically before <<*<[b]>>>, <<strcmp>> returns a
    number less than zero.

PORTABILITY
<<strcmp>> is ANSI C.

<<strcmp>> requires no supporting OS subroutines.

QUICKREF
    strcmp ansi pure
*/

#include <string.h>
#include <limits.h>

/* Nonzero if either X or Y is not aligned on a "long" boundary.  */
#define UNALIGNED(X, Y) \
  (((long)X & (sizeof (long) - 1)) | ((long)Y & (sizeof (long) - 1)))

/* DETECTNULL returns nonzero if (long)X contains a NULL byte. */
#if LONG_MAX == 2147483647L
#define DETECTNULL(X) (((X) - 0x01010101) & ~(X) & 0x80808080)
#else
#if LONG_MAX == 9223372036854775807L
#define DETECTNULL(X) (((X) - 0x0101010101010101) & ~(X) & 0x8080808080808080)
#else
#error long int is not a 32bit or 64bit type.
#endif
#endif

#ifndef DETECTNULL
#error long int is not a 32bit or 64bit byte
#endif

int
_DEFUN (strcmp, (s1, s2),
    _CONST char *s1 _AND
    _CONST char *s2)
{ 
#if defined(PREFER_SIZE_OVER_SPEED) || defined(__OPTIMIZE_SIZE__)
  while (*s1 != '\0' && *s1 == *s2)
    {
      s1++;
      s2++;
    }

  return (*(unsigned char *) s1) - (*(unsigned char *) s2);
#else
  unsigned long *a1;
  unsigned long *a2;

  /* If s1 or s2 are unaligned, then compare bytes. */
  if (!UNALIGNED (s1, s2))
    {  
      /* If s1 and s2 are word-aligned, compare them a word at a time. */
      a1 = (unsigned long*)s1;
      a2 = (unsigned long*)s2;
      while (*a1 == *a2)
        {
          /* To get here, *a1 == *a2, thus if we find a null in *a1,
         then the strings must be equal, so return zero.  */
          if (DETECTNULL (*a1))
        return 0;

          a1++;
          a2++;
        }

      /* A difference was detected in last few bytes of s1, so search bytewise */
      s1 = (char*)a1;
      s2 = (char*)a2;
    }

  while (*s1 != '\0' && *s1 == *s2)
    {
      s1++;
      s2++;
    }
  return (*(unsigned char *) s1) - (*(unsigned char *) s2);
#endif /* not PREFER_SIZE_OVER_SPEED */
}

[-DarkShadow-]

BoAC schreef op zaterdag 15 januari 2005 @ 16:33:
Uit de glibc-library (versie 2.3.3):

C:

int
simple_strcmp (const char *s1, const char *s2)
{
  int ret;

  while ((ret = *(unsigned char *) s1 - *(unsigned char *) s2++) == 0
  && *s1++);
  return ret;
}

int
stupid_strcmp (const char *s1, const char *s2)
{
  size_t ns1 = strlen (s1) + 1, ns2 = strlen (s2) + 1;
  size_t n = ns1 < ns2 ? ns1 : ns2;
  int ret = 0;

  while (n--)
    if ((ret = *(unsigned char *) s1++ - *(unsigned char *) s2++) != 0)
      break;
  return ret;
}

Volgens mij glibc gemakkelijk te downen van inet

Die code is natuurlijk niet interessant. Kijk maar naar de functienamen.

Aan allen: Ik heb het al lang gevonden!

Verwijderd schreef op zaterdag 15 januari 2005 @ 17:01:
Nu wil ik niet flauw doen, maar het is handig als je post waar je de oplossing gevonden hebt. Voor het geval mensen in de toekomst hetzelfde probleem hebben.

Ik wil ook niet flauw doen, maar er staan inmiddels verschillende oplossingen.

[ Voor 24% gewijzigd door -DarkShadow- op 15-01-2005 18:05 ]

[Verwijderd]

Nu wil ik niet flauw doen, maar het is handig als je post waar je de oplossing gevonden hebt. Voor het geval mensen in de toekomst hetzelfde probleem hebben.

[BoAC]

-DarkShadow- schreef op zaterdag 15 januari 2005 @ 16:36:
[...]

Die code is natuurlijk niet interessant. Kijk maar naar de functienamen.

Aan allen: Ik heb het al lang gevonden!

Mijn fout ik sorry bedoelde:

C:

/* Compare S1 and S2, returning less than, equal to or
   greater than zero if S1 is lexicographically less than,
   equal to or greater than S2.  */
int
strcmp (p1, p2)
     const char *p1;
     const char *p2;
{
  register const unsigned char *s1 = (const unsigned char *) p1;
  register const unsigned char *s2 = (const unsigned char *) p2;
  unsigned reg_char c1, c2;

  do
    {
      c1 = (unsigned char) *s1++;
      c2 = (unsigned char) *s2++;
      if (c1 == '\0')
 return c1 - c2;
    }
  while (c1 == c2);

  return c1 - c2;
}

_{Keek bij de test}

[.oisyn]

En ik wil niet flauw doen, maar voor simpele zoekvragen is P&W niet bedoelt