C 如何附加两个指针？

有人能帮我处理这个代码吗。我需要将这两个指针附加在一起，但它对我不起作用。代码不会将指针添加到一起。我认为mystrcat函数是错误的

// stringAdds.cpp : Defines the entry point for the console application.
//

char *mystrcat(char *s, char *p);

int _tmain(int argc, _TCHAR* argv[])
{
    char myChar = 0;
    int i = 0;

    char *s = (char*) malloc (1);
    char *p = (char*) malloc (1);

    printf("Input s: ");
    while ((myChar=getchar()) != '\n')
    s[i++]=myChar;
    s[i]='\0';
    //scanf("%s", &s);
    printf_s("%s", s);

    printf("\nInput p: ");
    i = 0;
    while ((myChar=getchar()) != '\n')
    p[i++]=myChar;
    p[i]='\0';
    printf_s("%s\n", p);

    printf_s("return string: %s", mystrcat(s,p));   
}

char *mystrcat(char *s, char *p)
{
    int sizeOfs = 0;
    int sizeOfp = 0;
    int sizeZero = 0;

    while(*s!='\0')
    {
        sizeOfs++;
    }
    while(*p!='\0')
    {
        sizeOfp++;
    }
    for( int i=0; i<sizeOfp; i++) 
        {
            s[sizeOfs++]=p[sizeZero++];
        }
    s[sizeOfs]='\0';

    return s;
}

//stringAdds.cpp：定义控制台应用程序的入口点。
//
char*mystrcat（char*s，char*p）；
int _tmain（int argc，_TCHAR*argv[]
{
char myChar=0；
int i=0；
char*s=（char*）malloc（1）；
char*p=（char*）malloc（1）；
printf（“输入s:”）；
而（（myChar=getchar（））！='\n'）
s[i++]=myChar；
s[i]='\0'；
//scanf（“%s”、&s）；
printf_s（“%s”，s）；
printf（“\n输入p:”）；
i=0；
而（（myChar=getchar（））！='\n'）
p[i++]=myChar；
p[i]='\0'；
printf_s（“%s\n”，p）；
printf_s（“返回字符串：%s”，mystrcat（s，p））；
}
char*mystrcat（char*s，char*p）
{
int-sizeOfs=0；
int-sizeOfp=0；
int-sizeZero=0；
而（*s！='\0'）
{
sizeOfs++；
}
而（*p！='\0'）
{
sizeOfp++；
}
对于（inti=0；i您的意思就是这个吗？我认为您的示例中缺少一些反引用

char *strcat (char *dest, const char *src)
{
char *dp;
char *sp = (char *)src;

if ((dest != NULL) && (src != NULL))
{
    dp = &dest[strlen(dest)];

    while (*sp != '\0')
    {
        *dp++ = *sp++;
    }
    *dp = '\0';
}
return dest;
}

你是说这个吗？我认为你的例子中缺少了一些反引用

char *strcat (char *dest, const char *src)
{
char *dp;
char *sp = (char *)src;

if ((dest != NULL) && (src != NULL))
{
    dp = &dest[strlen(dest)];

    while (*sp != '\0')
    {
        *dp++ = *sp++;
    }
    *dp = '\0';
}
return dest;
}

由于这可能是一个家庭作业，以下是一些提示：

内部
mystrcat


while（*s！='\0'）
是一个无限循环，因为
s
在循环体内部不会改变
您不需要知道
p
存储
s
，以便返回其值
使用循环将
s
移动到字符串的末尾
将
p
的字符复制到新的
s
指针指向的位置，直到您点击
'\0'
你完了

外部
mystrcat


您的
mystrcat
函数假定
s
有足够的空间来存储
s
的所有字符、
p
的所有字符和空终止符。您的代码
malloc
有足够的空间来容纳空终止符。您需要更改逻辑以提供更多空间
所有你
malloc
的东西都必须是免费的
由于这可能是一个家庭作业，以下是一些提示：

内部
mystrcat


while（*s！='\0'）
是一个无限循环，因为
s
在循环体内部不会改变
您不需要知道
p
存储
s
，以便返回其值
使用循环将
s
移动到字符串的末尾
将
p
的字符复制到新的
s
指针指向的位置，直到您点击
'\0'
你完了

外部
mystrcat


您的
mystrcat
函数假定
s
有足够的空间来存储
s
的所有字符、
p
的所有字符和空终止符。您的代码
malloc
有足够的空间来容纳空终止符。您需要更改逻辑以提供更多空间
所有你
malloc
的东西都必须是免费的
正确的代码：

char *ss=s;
while(*ss!='\0')
{
    sizeOfs++; ss++;
}
char *pp=p;
while(*pp!='\0')
{
    sizeOfp++; pp++;
}

基本上，您有一个无限循环。为了不造成任何内存溢出，我也会使用更大的malloc大小。
正确的代码：

char *ss=s;
while(*ss!='\0')
{
    sizeOfs++; ss++;
}
char *pp=p;
while(*pp!='\0')
{
    sizeOfp++; pp++;
}

基本上，您有一个无限循环。为了不造成任何内存溢出，我还希望malloc的大小更大。
您的malloc只有1个字节，但您可能会在*s和*p中放置许多字符。在将每个字符放入数组之前，您至少需要为它们存储空间。
您的malloc只有1个字节，但您的放置空间有限在*s和*p中可能会有许多字符。在将每个字符放入数组之前，您至少需要为它们提供存储空间。
Jenifer，我必须承认，这看起来非常相似

但你缺少了一些关键要素

首先，当我做初始的
malloc（）
时：

我这样做是为了有足够的空间放在字符串中（“在那个例子中是“hello”）。您正在尝试动态获取字符串，直到看到一个
'\n'
。因此，如果您想使用这种方法，您必须分配一些“足够大”的内容

这不能“足够大”，因为字符串必须至少有空间容纳一个字符和一个
'\0'
，否则它不是一个字符串，只是一个字符。：）

您确实无法确定“足够大”是什么，因此，如果字符串大小没有上限，那么只需抓取一些内存，如果接近溢出，则可以获得更多内存：

char *s = (char*) malloc (50); //That's better, room for some char's


您错过的第二点，在
mystrcat（）
函数中，请参阅我放在那里的一行：

// We need more memory for s, it was only made to hold its own string so :
s = realloc(s, length of s + length of p + 1);  // +1 for NULL terminator

你可以，但基本上它可以给你更多的内存。当你连接字符串时，你可能需要更多的内存。这就是计算
a
和
p
大小的要点


第三点，我给你的伪代码是：

while(s's character is not '\0')

您正在执行的操作无效。您需要对照
'\0'
检查字符串中的字符，如：

while(s[counter] != '\0')

随着时间的推移，计数器不断递增。
詹尼弗，我必须承认，这看起来非常相似

但你缺少了一些关键要素

首先，当我做初始的
malloc（）
时：

我这样做是为了有足够的空间放在字符串中（“在那个例子中是“hello”）。您正在尝试动态获取字符串，直到看到一个
'\n'
。因此，如果您想使用这种方法，您必须分配一些“足够大”的内容

这不能“足够大”，因为字符串必须至少有空间容纳一个字符和一个
'\0'
，否则它不是一个字符串，只是一个字符。：）

您确实无法确定“足够大”是什么，因此如果字符串大小没有上限，那么只需抓取一些内存并获取