如何在C中连续添加字符串元素？

Question

我想连续添加字符串元素，例如st[]="morty"，我想重复它的元素，例如七次。它应该是st[]="mortymo"。我写了一个函数，如下所示。 （长度函数是strlen）。

    void repeat(char* st,int n){
         int i,k=0,l=length(st);
         char* ptr;
         ptr=(char*)malloc((n+1)*sizeof(char));
         for (i=0;i<n;i++){
              *(ptr+i)=*(st+k);
              k++;
              if(k==l)k=0;
         }
    }

Answer 1

下面的程序重复原始字符串中的字符。代码中的评论：

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

 char* repeat(const char* st, size_t n){
         // use `const` to note that pointer `st` will not be modified
         // for purity you may want to use type `size_t` since returning type of strlen is `size_t` 

         size_t i, k=0;
         size_t l = strlen(st);

         // do not use (char *) cast
         char* ptr = malloc((n+1)*sizeof(char)); // allocate enough room for characters + NULL

         for (i=0; i< n; i++)
         {
              ptr[i] = st[k]; // use index for readability
              k++;

            if (k == l)
                k=0;
         }

         ptr[i] = 0; // terminate the string


    return ptr;
 }

int main( )
{
    char *str = "12345";

    str = repeat(str, 15);

    printf("%s\n",str);

    free (str); // free the allocated memory inside the repeat function

    return 0;
}

OUTPUT：

123451234512345 

Answer 2

在你的repeat函数中，你分配了ptr来保存重复的字符串，但你没有返回或将它分配给st。您可以修改repeat函数，如下所示：

    char* repeat(char* st,int n){
         int i,k=0,l=strlen(st);
         char* ptr;
         ptr=(char*)malloc((n+1)*sizeof(char));
         for (i=0;i<n;i++){
              *(ptr+i)=*(st+k);
              k++;
              if(k==l)k=0;
         }
        *(ptr+n) = '\0';
        return ptr;
    }

    /* some code*/
    char *st = "morty";
    st = repeat(st, 7);

这样你就可以在st之后存储重复字符串的结果。

Answer 3

如果我已正确理解了作业，那么你需要一个像演示程序中所示的功能。

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

char * repeat( const char *s, size_t n )
{
    char *p = NULL;

    size_t len = strlen( s );

    if ( len == 0 ) n = 0;

    p = ( char * )malloc( n + 1 );

    if ( p )
    {
        size_t i = 0;

        for ( size_t j = 0; i < n; i++ )
        {
            p[i] = s[j];
            if ( ++j == len ) j = 0;
        }

        p[i] = '\0';
    }


    return p;
}

int main(void) 
{
    char *s = "Hi, Zusaetlich.";

    char *p = repeat( s, 2 * strlen( s ) );

    puts( p );

    free( p );

    return 0;
}

程序输出是

Hi, Zusaetlich.Hi, Zusaetlich.

请注意，该函数的设计方式是，如果原始字符串为空，则结果字符串也为空，因为没有任何内容可以重复。

至于你的函数，它至少有一个内存泄漏，因为函数中分配的内存没有被释放。

此外，由于原始字符串未更改，因此应使用const说明符限定相应的参数。并且第二个参数应该具有类型size_t，因为至少函数strlen具有返回类型size_t。

因此，应该在演示程序中显示该函数。

Answer 4

由于您不打算修改st的内容，请继续并将其声明为const。由于您打算在函数中分配新字符串，因此应将其返回给调用者。

char *repeat(const char* st,int n){

你的问题不需要k。调用标准函数。

     int i,l=strlen(st);
     char* ptr;

不要施放malloc的结果，因为这可以掩盖C中的致命错误.sizeof(char)总是1.检查malloc调用成功的结果。

     ptr=malloc(n+1);
     if (ptr == NULL) return NULL;

     for (i=0;i<n;i++){

使用[]以惯用方式访问数组。请注意，每当k执行时，i都会递增，但是您正在应用k的模运算。但是，C有一个模运算符，您可以直接在i上使用它。

          ptr[i]=st[i%l];
     }

确保新字符串是NUL终止。声明您的函数返回结果，但您的实现无法执行此操作。

     ptr[n] = '\0';
     return ptr;
}

C有很多函数可以调用来为你复制，而不是你编写的逐字节循环。您的实现很简单，但下面是一个替代方案，还包括解决方案中缺少的其他错误检查。

（有些人可能会对使用sprintf感到不满，但它正在被正确使用。）

char *
repeat (const char *st, int n) {
    int l = st ? strlen(st) : 0;
    char *ret = (st && n > 0 ? malloc(n+1) : 0), *p = ret;
    while (ret && n > 0) {
        p += sprintf(p, "%.*s", (l < n ? l : n), st);
        n -= l;
    }
    return ret ? ret : "(nil)";
}

Try it online!