C - Подстрока (от POS до POS)

Question

У меня есть массив символов длиной 32, и я хотел бы извлечь из него определенные символы.например

111111000000000000000000111111 <32 символа </p>

Я хотел бы взять символы 0-6, которые были бы 111111

Или даже взять символы 26-31, которые быbe 111111

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

Проверьте это:

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));
}

Answer 3

Использование 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 4

Сначала определите требуемый интерфейс ... возможно:

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

Это принимает целевой (целевой) массив, в который будут скопированы данные, и получает его длину. Данные будут поступать из исходного массива, между позициями src_bgn и src_end. Возвращаемое значение будет -1 для ошибки, и длина вывода (исключая завершающий ноль). Если целевая строка слишком короткая, вы получите ошибку.

Имея этот набор деталей, вы можете довольно легко реализовать тело, и на этот раз вполне может подойти 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 *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.