Question

char* my_strtok (char* s1,const char* s2){
    char *res = NULL;
    size_t i, j, len1 = mstrlen(s1), len2 = mstrlen(s2);
    for(i=0U; i< len1; i++) {
        for(j=0U; j<len2; j++) {
            if(s1[i] == s2[j]) {
                s1[i] = '\0'; res = (s1 + i+ 1);
                break;
            }
        }
    }
    return res;
}

你能说这是strtok的正确实现吗？或者你可以证明你的实现？

Answer 1

您需要有一个保持输入指针当前位置的位置。使用strspn()和strcspn()作为获取分隔符位置的方法的示例：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// SOME CHECKS OMMITTED!

// helper for testing, not necessary for strtok()
static char *strduplicator(const char *s)
{
  char *dup;
  dup = malloc(strlen(s) + 1);
  if (dup != NULL) {
    strcpy(dup, s);
  }
  return dup;
}


// thread-safe (sort of) version
char *my_strtok(char *in, const char *delim, char **pos)
{
  char *token = NULL;

  // if the input is NULL, we assume that this
  // function run already and use the new position
  // at "pos" instead
  if (in == NULL) {
    in = *pos;
  }
  // skip leading delimiter that are left
  // there from the last run, if any
  in += strspn(in, delim);
  // if it is still not the end of the input
  if (*in != '\0') {
    // start of token is at the current position, set it
    token = in;
    // skip non-delimiters, that is: find end of token
    in += strcspn(in, delim);
    // strip of token by setting first delimiter to NUL
    // that is: set end of token
    if (*in != '\0') {
      *in = '\0';
      in++;
    }
  }
  // keep current position of input in "pos"
  *pos = in;
  return token;
}


int main(void)
{

  char *in_1 = strduplicator("this,is;the:test-for!strtok.");
  char *in_2 = strduplicator("this,is;the:test-for!my_strtok.");

  char *position, *token, *s_in1 = in_1, *s_in2 = in_2;
  const char *delimiters = ",;.:-!";

  token = strtok(in_1, delimiters);
  printf("BUILDIN: %s\n", token);
  for (;;) {
    token = strtok(NULL, delimiters);
    if (token == NULL) {
      break;
    }
    printf("BUILDIN: %s\n", token);
  }

  token = my_strtok(in_2, delimiters, &position);
  printf("OWNBUILD: %s\n", token);
  for (;;) {
    token = my_strtok(NULL, delimiters, &position);
    if (token == NULL) {
      break;
    }
    printf("OWNBUILD: %s\n", token);
  }

  free(s_in1);
  free(s_in2);

  exit(EXIT_SUCCESS);
}

如果你想拥有普通的char *strtok(char *str, const char *delim);，你可以这样做：

static char *pos;
char *own_strtok(char *in, const char *delim)
{
   return my_strtok(in, delim, &pos);
}

函数str[c]spn()非常简单。引用strspn()

的手册页

strspn()函数返回 s 初始段中的字节数，该段仅由 accept 中的字节组成。

size_t my_strspn(const char *s, const char *accept)
{
  const char *delim;
  size_t size = 0;

  // step through the input
  while (*s != '\0') {
    // step through delimiters and test
    for (delim = accept; *delim != '\0'; delim++) {
      if (*s == *delim) {
        break;
      }
    }
    // we are through all of the delimiters without success,
    // terminate
    if (*delim == '\0') {
      break;
    } else {
      size++;
    }
    s++;
  }
  return size;
}

反函数strcspn()更简单。再次引用手册页：

strcspn()函数返回 s 初始段中的字节数，这些字节数不在字符串拒绝中。

size_t my_strcspn(const char *s, const char *reject)
{
  const char *delim;
  size_t size = 0;

  // step through the input
  while (*s != '\0') {
    // step through delimiters and test
    for (delim = reject; *delim != '\0'; delim++) {
      if (*s == *delim) {
        return size;
      }
    }
    size++;
    s++;
  }
  return size;
}

n 输入的大小和 k 分隔符集的大小时间复杂度为O（kn）。理论上， k 的大小不能超过输入字母的大小，我们应该能够假设k << n。但是假设包含分隔符的字符串是唯一的。情况并非总是如此。

strtok(
   "This is a sentence without the last letter of the alphabet.",
   "zzz/* 1,000,000,000 other z's omitted */zzz"
);

所以要小心使用自动生成的分隔符集，并添加一个额外的检查，如果该危险是真的（例如：用户输入）。

在C中实现strtok

1 个答案: