How do I modify strcat so that it wouldn't edit str1

Question

Why does strcat gives me its version of str1? As far as I know there has to be & thing before paramatater in function prototype and implementation if you want to get it editted, but I don't see it here.

char *strcat( char *str1, const char *str2 );

How do I edit this function so that it would only return new string but leave out the ones I give it? My try

char *strApp(char *dest, const char *src)
{
    size_t i,j;
    size_t k = 0;
    for (i = 0; dest[i] != '\0'; i++);
    char rdest[100];
    do {
        rdest[k] = dest[k];
    } while(++k<=i);
    for (j = 0; src[j] != '\0'; j++)
        rdest[i+j] = src[j];

    rdest[i+j] = '\0';
    return rdest;
}

It damages second string. Could anyone give me safe and correct version? Thanks in advance.

Answer 1

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

char *strApp(const char *s1, const char *s2)
{
    char *pointer = malloc(strlen(s1) + strlen(s2) + 1);

    if (pointer == NULL)
    {
        perror("failed to allocate memory");
        exit(EXIT_FAILURE);
    } 

    return strcat(strcpy(pointer, s1), s2);
}

int main()
{

    char *s1 = "original";

    char *s2 = " modified";

    char *s3 = strApp(s1, s2);

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

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

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

    free(s3);

    return 0;
}

Just trying to point out you don't need to completely rewrite strcat() to get what you want.

Answer 2

strcat is, by definition, altering the target. If you don't want to, you should make a copy yourself in a target memory location you allocate yourself.

Answer 3

You've tagged your question with both C and C++. I'm providing a C solution. Adjustments may be needed for C++.

---

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

char* strdupcat(const char* s1, const char* s2) {
    size_t s1_len = strlen(s1);
    size_t s2_len = strlen(s2);
    char* s = malloc(s1_len + s2_len + 1);

    if (s == NULL)
        return NULL;

    {
        char* s_end = s;
        s_end = mempcpy(s_end, s1, s1_len);
        s_end = mempcpy(s_end, s2, s2_len);
        *s_end = '\0';
    }

    return s;
}

Example usage:

#include <stdio.h>

int main() {
    char* s = strdupcat("abc", "def");
    if (s == NULL) {
        perror("Can't concatenate");
        return EXIT_FAILURE;
    }

    puts(s);
    free(s);
    return EXIT_SUCCESS;
}

This function is used similarly to strdup.

DESCRIPTION

The strdupcat() function returns a pointer to a new string which is a duplicate of the string s1 with a duplicate of string s2 appended. Memory for the new string is obtained with malloc(3), and can be freed with free(3).

RETURN VALUE

The strdupcat() function returns a pointer to the duplicated string, or NULL if insufficient memory was available.

ERRORS

ENOMEM Insufficient memory available to allocate the new string.

You can use strerror or perror to obtain an error message when strdupcat() returns NULL.

---

Here's a version that accepts an arbitrary number of arguments:

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

char* strdupcatmany(int dummy, ...) {
#define strdupcatmany(...) strdupcatmany(0, __VA_ARGS__, NULL)
    size_t len = 0;
    char* s;
    char* s_dst;
    const char* s_src;
    va_list ap;

    va_start(ap, dummy);
    while (1) {
        s_src = va_arg(ap, const char*);
        if (s_src == NULL)
            break;

        len += strlen(s_src);
    }
    va_end(ap);

    s = malloc(len + 1);
    if (s == NULL)
        return NULL;

    s_dst = s;
    va_start(ap, dummy);
    while (1) {
        s_src = va_arg(ap, const char*);
        if (s_src == NULL)
            break;

        s_dst = stpcpy(s_dst, s_src);
    }
    va_end(ap);
    *s_dst = '\0';

    return s;
}

For example,

#include <stdio.h>

int main() {
    char* s = strdupcatmany("abc", "def", "ghi");
    if (s == NULL) {
        perror("Can't concatenate");
        return EXIT_FAILURE;
    }

    puts(s);
    free(s);
    return EXIT_SUCCESS;
}

Note: I don't know how portable __VA_ARGS__ args is.