如何打印由字符组成的字符串，该字符在C中重复了可变的次数？

在Python中，可以使用

打印“X”*4打印
XXXX
在C语言中有什么简单的等价物吗？
不太可能。在C语言中，您需要使用循环。
不太可能。在C语言中，您需要使用循环。
不太可能。在C语言中，您需要使用循环。
不太可能。在C中，您需要使用一个循环。
C没有太多的内置/标准库，因此您必须经历分配一个新缓冲区并将四个字符串连接到它的过程，然后释放缓冲区，只需打印四次“X”就更简单了

int i;
for (i=0; i<4; ++i) {
   printf("X");
}
printf("\n");

但正如您所看到的，结果几乎一样长。
C没有太多内置/标准库，因此您必须经历分配新缓冲区并将四个字符串连接到它的过程，然后释放缓冲区，只需打印四次“X”就更简单了

int i;
for (i=0; i<4; ++i) {
   printf("X");
}
printf("\n");

但正如您所看到的，结果几乎一样长。
C没有太多内置/标准库，因此您必须经历分配新缓冲区并将四个字符串连接到它的过程，然后释放缓冲区，只需打印四次“X”就更简单了

int i;
for (i=0; i<4; ++i) {
   printf("X");
}
printf("\n");

但正如您所看到的，结果几乎一样长。
C没有太多内置/标准库，因此您必须经历分配新缓冲区并将四个字符串连接到它的过程，然后释放缓冲区，只需打印四次“X”就更简单了

int i;
for (i=0; i<4; ++i) {
   printf("X");
}
printf("\n");

但正如你所见，结果几乎一样长。
是的。欢迎来到C:

int i;
for (i=0; i<4; i++)
    printf("X");

inti；
对于（i=0；i是的。欢迎来到C:

int i;
for (i=0; i<4; i++)
    printf("X");

inti；
对于（i=0；i是的。欢迎来到C:

int i;
for (i=0; i<4; i++)
    printf("X");

inti；
对于（i=0；i是的。欢迎来到C:

int i;
for (i=0; i<4; i++)
    printf("X");

inti；
对于（i=0；i否），C中没有标准库可以做到这一点，但您可以自己轻松实现。C中的一个简单实现：

char * strmul(const char * src, size_t times) {
    size_t s_len = strlen(src);
    char * res = (char*)malloc(s_len * times + 1);
    int i;
    for(i = 0; i < times; i++) {
       strcpy(res + s_len * i, src);
    }
    return res;
}

char*strmul（常量char*src，大小\u t次）{
尺寸=标准长度（src）；
char*res=（char*）malloc（s_len*倍+1）；
int i；
对于（i=0；i<次；i++）{
strcpy（res+s_len*i，src）；
}
返回res；
}


@ikegami建议的改进版本

char * strmul(const char * src, size_t times) {
    size_t s_len = strlen(src);
    char * res = (char*)malloc(s_len * times + 1);
    int i;
    for(i = 0; i < times; i++) {
       memcpy(res + s_len * i, src);
    }
    res[s_len * times + 1] = '\0';
    return res;
}

char*strmul（常量char*src，大小\u t次）{
尺寸=标准长度（src）；
char*res=（char*）malloc（s_len*倍+1）；
int i；
对于（i=0；i<次；i++）{
memcpy（res+s_len*i，src）；
}
res[s_len*倍+1]='\0'；
返回res；
}
不，C中没有标准库可以做到这一点，但您可以自己轻松实现。C中的一个简单实现：

char * strmul(const char * src, size_t times) {
    size_t s_len = strlen(src);
    char * res = (char*)malloc(s_len * times + 1);
    int i;
    for(i = 0; i < times; i++) {
       strcpy(res + s_len * i, src);
    }
    return res;
}

char*strmul（常量char*src，大小\u t次）{
尺寸=标准长度（src）；
char*res=（char*）malloc（s_len*倍+1）；
int i；
对于（i=0；i<次；i++）{
strcpy（res+s_len*i，src）；
}
返回res；
}


@ikegami建议的改进版本

char * strmul(const char * src, size_t times) {
    size_t s_len = strlen(src);
    char * res = (char*)malloc(s_len * times + 1);
    int i;
    for(i = 0; i < times; i++) {
       memcpy(res + s_len * i, src);
    }
    res[s_len * times + 1] = '\0';
    return res;
}

char*strmul（常量char*src，大小\u t次）{
尺寸=标准长度（src）；
char*res=（char*）malloc（s_len*倍+1）；
int i；
对于（i=0；i<次；i++）{
memcpy（res+s_len*i，src）；
}
res[s_len*倍+1]='\0'；
返回res；
}
不，C中没有标准库可以做到这一点，但您可以自己轻松实现。C中的一个简单实现：

char * strmul(const char * src, size_t times) {
    size_t s_len = strlen(src);
    char * res = (char*)malloc(s_len * times + 1);
    int i;
    for(i = 0; i < times; i++) {
       strcpy(res + s_len * i, src);
    }
    return res;
}

char*strmul（常量char*src，大小\u t次）{
尺寸=标准长度（src）；
char*res=（char*）malloc（s_len*倍+1）；
int i；
对于（i=0；i<次；i++）{
strcpy（res+s_len*i，src）；
}
返回res；
}


@ikegami建议的改进版本

char * strmul(const char * src, size_t times) {
    size_t s_len = strlen(src);
    char * res = (char*)malloc(s_len * times + 1);
    int i;
    for(i = 0; i < times; i++) {
       memcpy(res + s_len * i, src);
    }
    res[s_len * times + 1] = '\0';
    return res;
}

char*strmul（常量char*src，大小\u t次）{
尺寸=标准长度（src）；
char*res=（char*）malloc（s_len*倍+1）；
int i；
对于（i=0；i<次；i++）{
memcpy（res+s_len*i，src）；
}
res[s_len*倍+1]='\0'；
返回res；
}
不，C中没有标准库可以做到这一点，但您可以自己轻松实现。C中的一个简单实现：

char * strmul(const char * src, size_t times) {
    size_t s_len = strlen(src);
    char * res = (char*)malloc(s_len * times + 1);
    int i;
    for(i = 0; i < times; i++) {
       strcpy(res + s_len * i, src);
    }
    return res;
}

char*strmul（常量char*src，大小\u t次）{
尺寸=标准长度（src）；
char*res=（char*）malloc（s_len*倍+1）；
int i；
对于（i=0；i<次；i++）{
strcpy（res+s_len*i，src）；
}
返回res；
}


@ikegami建议的改进版本

char * strmul(const char * src, size_t times) {
    size_t s_len = strlen(src);
    char * res = (char*)malloc(s_len * times + 1);
    int i;
    for(i = 0; i < times; i++) {
       memcpy(res + s_len * i, src);
    }
    res[s_len * times + 1] = '\0';
    return res;
}

char*strmul（常量char*src，大小\u t次）{
尺寸=标准长度（src）；
char*res=（char*）malloc（s_len*倍+1）；
int i；
对于（i=0；i<次；i++）{
memcpy（res+s_len*i，src）；
}
res[s_len*倍+1]='\0'；
返回res；
}
您只想打印吗？Python做的远不止这些：它实际上创建了一个新字符串。这种比较是假的：在Python中，您将字符串与数字相乘，而不是将字符与数字相乘。在循环中（步数由输入值定义），我只想打印“x”在每一个步骤中增加2。你只想打印吗？Python做的远不止这些：它实际上创建了一个新字符串。这种比较是虚假的：在Python中，你将字符串与数字相乘，而不是将字符与数字相乘。在循环中（步骤的数量由输入值定义），我只想打印“x”在每一个步骤中增加2。你只想打印吗？Python做的远不止这些：它实际上创建了一个新字符串。这种比较是虚假的：在Python中，你将字符串与数字相乘，而不是将字符与数字相乘。在循环中（步骤的数量由输入值定义），我只想打印“x”在每一个步骤中增加2。你只想打印吗？Python做的远不止这些：它实际上创建了一个新字符串。这种比较是虚假的：在Python中，你将字符串与数字相乘，而不是将字符与数字相乘。在循环中（步骤的数量由输入值定义），我只想打印“x”在每一步增加2。这是真的吗？我只是开始