Сборка strcat без библиотеки и без указателей

как-то не работает

a[strlen(a) + i + 1] = b[i]; добавляет символы после a нулевого символа.

void strcatO(char a[], char b[]) {
    int i = 0;
    for(i = 0; i < strlen(b); ++i) {
      a[strlen(a) + i + 1] = b[i];  // Oops: appending position is off-by-one
    }
    printf("%s", a);
}

strcatO("ab", "cd") заполнит a как 'a', 'b', '\0', 'c', 'd'.

Печать этого с printf("%s", a); печатает только 'a', 'b'.

Чтобы исправить это, код должен добавляться в правильном месте, но это перезаписывает исходный a нулевой символ. Таким образом, вызовы strlen(a) плохи.

Вместо этого и для повышения эффективности выполните не звонить strlen() повторно.

void strcatO(char a[], const char b[]) {
  size_t ai = 0;
  while (a[ai]) {       // go to end of a
    ai++;
  }

  size_t bi = 0;
  while (b[bi]) {        // while not at the end of b ...
    a[ai++] = b[bi++];
  }

  a[ai] = '\0';
  printf("<%s>", a);
}

Детали тонких улучшений:

const в const char b[] означает, что b ссылается на данные, которые эта функция не должна пытаться изменить. Это 1) позволяет этой функции конкатенировать b, если это будет const char [] 2) Позволяет оптимизацию, которую слабый компилятор может не увидеть.

size_t лучше, чем int, для длинных строк, которые могут быть длиннее INT_MAX. size_t — это тип «правильного размера» для длин строк и размеров массивов. OP (исходный постер) действительно имел «без использования библиотеки», а size_t взят из библиотеки, поэтому код мог использовать unsigned или лучше unsigned long в качестве альтернативы.

из ваших проблем вы постоянно вычисляете strlen даром, надеясь, что компилятор оптимизируется, вы можете сделать это:

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

void strcatO(char a[], char b[])
{
   size_t i = strlen(a);
   size_t j;

    for (j = 0; b[j] != 0; ++j)
    {
        a[i++] = b[j];
    }

    a[i] = 0;

    printf("%s\n", a);
}

int main()
{
  char a[20] = "aze";
  char b[] = "rtyu";
  strcatO(a,b);
  return 0;
}

Исполнение :

azertyu

Обратите внимание, что char a[] для параметра равно char *, без указателей равно false ;-)

и указать на проблемы в вашем коде по просьбе Эрика Постпишила:

• a[strlen(a) + i + 1] пишет 1 символ после нужной позиции, должно быть a[strlen(a) + 1] = 0; a[strlen(a)] = b[j];. В некотором смысле это шанс, что вы напишете больше после конца, потому что strlen вернет не начальную длину a, а неопределенное значение из-за вероятного отсутствия нуля символ в остальной части a
• после копии, которую вы пропустите, чтобы добавить нулевой символ

Эта строка:

a[strlen(a) + i + 1] = b[i];

пишет символы на одну позицию дальше, чем вы хотите.

При вызове в вашем примере ваша процедура передается a и b со следующим содержимым:

a[0] = 'e'
a[1] = 'g'
a[2] = 'g'
a[3] = 0

b[0] = 's'
b[1] = 'a'
b[2] = 'm'
b[3] = 'p'
b[4] = 'l'
b[5] = 'e'
b[6] = 0

Вы хотите получить этот результат:

a[0] = 'e'
a[1] = 'g'
a[2] = 'g'
a[3] = 's'
a[4] = 'a'
a[5] = 'm'
a[6] = 'p'
a[7] = 'l'
a[8] = 'e'
a[9] = 0

Однако, поскольку ваш код записывает в a[strlen(a) + i + 1], он записывает первый символ в a[strlen(a) + 0 + 1], то есть a[4]. Вы хотите это в a[3]. Вы можете изменить strlen(a) + i + 1 на strlen(a) + i, но тогда, когда вы напишете первый символ, вы перезапишете завершающий нуль, и strlen больше не будет работать для определения длины. Чтобы исправить это, вы можете запомнить длину a перед входом в цикл. Рассмотрим этот код:

int i = 0;
int LengthOfA = strlen(a);
for (i = 0; i < strlen(b); ++i)
{
    a[LengthOfA + i] = b[i];
}

Это запишет символы в правильное место.

Однако в конце a не ставится нулевой завершающий символ. Для этого мы можем поместить еще один оператор после цикла:

a[LengthOfA + i] = 0;

В этот момент ваша рутина будет работать для обычных ситуаций. Однако мы можем сделать еще два улучшения.

Во-первых, вместо использования int для длин и индексов мы можем использовать size_t. В C ширина int является гибкой, а size_t предоставляется как хороший тип для использования при работе с размерами объектов. Чтобы использовать его, сначала используйте #include <stddef.h>, чтобы получить его определение. Тогда ваш код может быть:

size_t i = 0;
size_t LengthOfA = strlen(a);
for (i = 0; i < strlen(b); ++i)
{
    a[LengthOfA + i] = b[i];
}
a[LengthOfA + i] = 0;

Во-вторых, ваш код номинально вычисляет strlen(b) на каждой итерации. Это расточительно. Длину желательно вычислить один раз и запомнить:

size_t i = 0;
size_t LengthOfA = strlen(a);
size_t LengthOfB = strlen(b);
for (i = 0; i < LengthOfB; ++i)
{
    a[LengthOfA + i] = b[i];
}
a[LengthOfA + i] = 0;

Вы не перезаписываете первый разделитель строки null(\0)

    a[strlen(a) + i + 1] = b[i];

должно быть

int len = strlen(a);

for(i = 0; i < strlen(b); ++i)
{
    a[len + i] = b[i];
}
a[len+i] = '\0'; //Finally null terminate the new string.