C - 子字符串（从 POS 到 POS）

Question

我有一个长度为 32 的字符数组，想从中取出某些字符。 例如

1111110000000000000000000111111 <32个字符

我想采用字符0-6，这将是111111

或者甚至采用字符26-31，这将是111111 code>

char check_type[32];

以上是我的声明方式。

我希望能够做的是定义一个函数或使用一个占据起始位置和结束字符的函数。

我已经研究了很多方法，例如使用 strncpy 和 strcpy 但还没有找到方法。

Answer 1

我会简单地包装 strncpy:

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

/* Creates a sub-string of range [start, end], return value must be freed */
char *substr(char *src, size_t start, size_t end)
{
   size_t sub_len = end - start + 1;
   char * new_str = malloc(sub_len + 1); /* TODO: check malloc's return value */

   strncpy(new_str, src, sub_len);
   new_str[sub_len] = '\0'; /* new_str is of size sub_len + 1 */

   return new_str;
}

int main(void)
{
   char str[] = "111111000000000000000000111111";
   char *sub_str = substr(str, 0, 5);

   puts(sub_str);

   free(sub_str);
   return EXIT_SUCCESS;
}

输出：

111111

Answer 2

使用memcpy。

// Stores s[from..to) in sub.
// The caller is responsible for memory allocation.
void extract_substr(char const *s, char *sub, size_t from, size_t to)
{
    size_t sublen = to - from;
    memcpy(sub, s + from, sublen);
    sub[sublen] = '\0';
}

Answer 3

示例：

char *substr(char *source, int startpos, int endpos)
{
    int len = endpos - startpos + 2; // must account for final 0
    int i = 0;

    char *src, *dst;
    char *ret = calloc(len, sizeof(char));

    if (!ret)
        return ret;

    src = source + startpos;
    dst = ret;

    while (i++ < len)
        *dst++ = *src++;

    *dst = 0;
    return ret;
}

当然，当您不再需要返回代码时，请释放它。您会注意到此函数不会检查 endpos 与 startpos 的有效性。

Answer 4

首先定义所需的接口...也许：

int substring(char *target, size_t tgtlen, const char *source, size_t src_bgn, size_t src_end);

这需要一个将复制数据的目标（目标）数组，并给出其长度。数据将来自源数组，位置 src_bgn 和 src_end 之间。如果出现错误，则返回值为 -1，并且返回输出的长度（不包括终止 null）。如果目标字符串太短，则会出现错误。

有了这组细节，您就可以相当轻松地实现主体，并且 strncpy() 这次可能很合适（通常不合适）。

用法（根据您的问题）：

char check_type[32] = "111111000000000000000000111111";
char result1[10];
char result2[10];

if (substring(result1, sizeof(result1), check_type, 0, 6) <= 0 ||
    substring(result2, sizeof(result2), check_type, 26, 31) <= 0)
    ...something went wrong...
else
    ...use result1 and result2...

Answer 5

检查一下：

char* Substring(char *string, int len, int start, int end) {
  /*
  Creates a substring from a given string.
  Args:
    string: The string whose substring you need to find.
    len: The length of the string.
    start: The start position for the substring.
    end: The end position of the substring (inclusive).
  Returns:
    substring: (of type char*) which is allocated on the heap.
    NULL: on error.
  */

  // Check that the start and end position are valid.
  // If not valid, then return NULL.
  if (start < 0 || start >= len || end < 0 || end >= len) {
    return NULL;
  }

  // Allocate memory to return the substring on the heap.

  char *substring = malloc(sizeof(char) * (end - start + 2));
  int index = 0, i;

  for (i = start; i <= end; i++) {
    substring[index] = string[i];
    index++;
  }

  // End with a null character.
  substring[index] = '\0';
  return substring;
}

int main() {
  char str[] = "11111100000000000000000000111111";
  printf("%s\n", Substring(str, strlen(str), 0, 5));
  printf("%s\n", Substring(str, strlen(str), 26, 31));
}