Использование concat в C без строковых библиотечных функций или обозначений массива

Question

Моя задача - иметь возможность объединить две строки и вернуть новую строку с помощью указателей.Предполагается, что он возвращает новую строку, но в настоящее время возвращает пустое пространство.Вот мой код:

char* concat(char* first, char* second){
    int string1Len = strlen(first);
    int string2Len = strlen(second);
    int length = string1Len + string2Len;
    char* string = malloc(sizeof(char)*length);
    int i;
    while(i < string1Len){
        *(string + i) = *first;
        first+= 1;
        i+= 1;
    }
    while( i < length){
        *(string + i) = *second;
        second+= 1;
        i+= 1;
    }

    return string;
}

Answer 1

Ошибки кода OP

Индекс не инициализирован

// int i;
int i = 0;

Нет добавленных или выделенных нулевых символов

// char* string = malloc(sizeof(char)*length);
char* string = malloc(length + 1);
....
*(string + i) ='\0'; // add this
return string;

---

Незначительные элементы

sizeof (char) всегда 1

//char* string = malloc(sizeof(char)*length);
char* string = malloc(length);  // Also +1 as noted above

int может быть слишком узким

// int i;
size_t i;

Невозможно использовать strlen()

"без функций библиотеки строк"

В распределении отсутствует проверка

char* string = malloc(...);
if (string == NULL) {  // add
  return NULL;
}

Поскольку исходные строки не изменены, используйте const.

Это позволяет более широко использовать функцию и потенциально оптимизировать.

//char* concat(char* first, char* second){
char* concat(const char* first, const char* second){

---

Несколько непроверенных альтернативных кодов.Обратите внимание, нет целочисленных переменных.

char* concat(const char* first, const char* second) {
  const char *p1 = first;
  while (*p1) {
    p1++;
  }
  const char *p2 = second;
  while (*p2) {
    p2++;
  }
  char* string = malloc((p1 - first) + (p2 - second) + 1);
  if (string) {
    char *ps = string;
    while ((*ps = *first++)) {
      ps++;
    }
    while ((*ps = *second++)) {
      ps++;
    }
  }
  return string;
}

Answer 2

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

// You should use char const * as your function don't need to change the character of your input string
char *concat(char const *first, char const *second) { // put * on the variable name not the type
    assert(first && second); // test only include for debug build concat expect valid string
    size_t first_len = strlen(first); // strlen() return a size_t
    size_t second_len = strlen(second);
    // you could check for overflow case here
    size_t length = first_len + second_len; // malloc take a size_t as argument
    char *string = malloc(length + 1); // don't forget the nul terminate byte, sizeof(char) == 1
    if (!string) { // don't forget to check malloc() error
        return NULL;
    }
    size_t i = 0; // don't forget to initialize your variable
    while (*first) {
        string[i++] = *first++; // use [] notation is more readeable  in that case
    }
    while (*second) {
        string[i++] = *second++;
    }
    string[i] = '\0'; // never forget the nul terminate byte
    return string;
}

int main(void) {
    char *my_amazing_new_string = concat("Stack ", "Overflow");
    if (!my_amazing_new_string) {
        return EXIT_FAILURE;
    }
    printf("%s", my_amazing_new_string);
    free(my_amazing_new_string);
}

Answer 3

Строка Библиотеки?Я никогда не использую их: P

char * concat(char * dest, const char * src)
{
    // creates a pointer to `dest` so we can return it from from its start position.
    char * ptr = dest;          
    // increament dest until the nul-terminated which is 0 (false//loop stops).
    while (*dest) dest++;   
    // so we assign dest pointer to src pointer while increamenting them.   
    while (*dest++ = *src++);   
    // return the `dest` pointer.
    return ptr;                 
}

Обратите внимание, что вам нужно выделить первый параметр самостоятельно, потому что эта функция сама объединяет указатель dest, поэтому возвращаемое значение (равно Необязательно ^^).

Я также заметил, что по какой-то причине ... каждый выделяет память в самой функции, поэтому
я сделал 2nd версию, однако, это не таккак 1-й (хотя вам понадобится возвращаемое значение).

char * concat(char * s1, const char * s2)
{
    size_t i = 0;
    // length of s1.
    while (*s1++) i++;
    size_t s1_len = i; i = 0;
    s1 -= s1_len + 1;
    // length of s2.
    while (*s2++) i++;
    size_t s2_len = i; i = 0;
    s2 -= s2_len + 1;
    // allocates memory.
    char * newStr = (char *)malloc((s1_len + s2_len)+1); // +1 is for the nul-terminated character.
    if(!newStr) return newStr; // if malloc fails, return (null) pointer.
    // points to position 0 of the 1st string.
    char * ptr = newStr;
    // copies the content of s1 to the new string
    while (*ptr++ = *s1++);
    // get back to the nul-terminated to overwrite it.
    *ptr--;
    // concentrate
    while (*ptr++ = *s2++);
    // return the `newStr` pointer.
    return newStr;                  
}

Answer 4

Помимо унифицированного int i = 0, ваш код выглядит нормально.Это сработало на моей машине:

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

char* concat(char* first, char* second){
    int string1Len = strlen(first);
    int string2Len = strlen(second);
    int length = string1Len + string2Len;
    char* string = malloc(sizeof(char)*length + 1);
    assert(string);
    int i=0;
    while(i < string1Len){
        string[i] = *first;
        first+= 1;
        i+= 1;
    }
    while(i < length){
        string[i] = *second;
        second += 1;
        i += 1;
    }
    string[i] = '\0';
    return string;
}

int main(){
        char* x = "foo";
        char* y = "bar";
        printf("%s\n", concat(x, y));
        // prints 'foobar'
}

PS используйте string[i] вместо *(string + i), обычно считается более читабельным.