joining two strings with Malloc - c

Question

I have been working through a beginner C problem to try and learn the basics of C. I noticed the problem below will start at the index of where the last string takes off and will finish that string, but what I'm trying to do is join the two strings together.
Can anyone point me in the right direction? I'm trying to do this without realloc for learning xp.
char *string_dup(char *src)
{
int len = strlen(src);
char *src2 = malloc(len + 1);
int i;
for(i = 0; i < len; i++){
*(src2 + i) = *(src + i);
}
*(src2 + len )='\0';
return src2;
}
void *resize_memory(void *ptr, int old_size, int new_size)
{
char *d = (char*)ptr;
d = malloc(new_size);
}
char *url = string_dup("http://");
char *path = string_dup("website.com/");
int url_length = string_length(url);
int path_length = string_length(path);
int new_length = url_length - 1 + path_length;
char *new_url = resize_memory(url, url_length, new_length);
char *p = new_url + url_length;
while (*path != '\0') {
*p = *path;
p++;
path++;
}
printf("Full path string: %s\n", new_url);

Answer 1

Trouble with OP's code:
Wrong size
Assuming string_length() is like strlen().
// int new_length = url_length - 1 + path_length;
int new_length = url_length + 1 + path_length;
Ineffective resize
void *resize_memory(void *ptr, int old_size, int new_size) {
char *d = (char*)ptr; // assign `d`
d = malloc(new_size); // Why re-assigned `d`???
// No use of old_size, new_size
// No copying of existing data
// No freeing of old allocation
}
I'd expect something like
// return failure status
bool resize_memory(void **ptr_addr, size_t old_size, size_t new_size) {
void *new_ptr = NULL;
if (new_size > 0) {
new_ptr = malloc(new_size);
if (new_ptr) { // Out of memory, leave *ptr_addr alone
return true;
}
size_t min_size = old_size < new_size ? old_size : new_size;
memcpy(new_ptr, *ptr_addr, min_size);
}
free(*ptr_addr);
*ptr_addr = new_ptr;
return false;
}
Ways to join strings with realloc() with allocation.
Find lengths.
Allocate memory.
If successful, copy the first and then the second string. Append a \0.
Sample code:
// s1, s2 may be NULL. A NULL is treated as if ""
char *JoinStrings(const char *s1, const char *s2) {
size_t len1 = s1 ? strlen(s1) : 0;
size_t len2 = s2 ? strlen(s2) : 0;
char *joined = malloc(len1 + len2 + 1);
if (joined) {
memcpy(joined, s1, len1);
memcpy(joined + len1, s2, len2);
joined[len1 + len2] = '\0';
}
return joined;
}
Or via snprintf()
char *JoinStrings(const char *s1, const char *s2) {
size_t sz = (s1 ? strlen(s1) : 0) + (s2 ? strlen(s2) : 0) + 1;
char *joined = malloc(sz);
if (joined) {
int len = snprintf(joined, sz, "%s%s", s1, s2);
assert(len >= 0 && (unsigned) len < sz); // Failure is very unexpected here.
}
return joined;
}
To concatenate like (*s1) += s2
// *s1 is a prior allocated string, or NULL
void ConcatenateString(char **s1, const char *s2) {
char *joined = JoinStrings(*s1, s2);
free(*s1);
*s1 = joined;
}

Answer 2

Try something like
char *url = string_dup("http://");
char *path = string_dup("website.com/");
size_t sTotal = strlen(url) + strlen(path) + 1u;
char *pStr = malloc(sTotal);
snprintf(pStr, sTotal, "%s%s", url, path);
free(url);
free(path);

Answer 3

I played about with your code for a bit then came up with this solution. This allows you to get rid of that string_dup() function and create a single function that can allocate/assign a new string and append an existing string with more data.
int
append_string(char **append_to, char *append_this) {
char *tmp;
// You might want to check that append_this is not
// NULL...
if (*append_to == NULL) {
*append_to = malloc(strlen(append_this) + 1);
strcpy(*append_to, append_this);
}
else {
// Some data already exists on the append_to buffer...
//
// If you want to only use malloc() then make a temporary
// storage area and copy the append_to string there
//
if ((tmp = malloc(strlen(*append_to) + 1)) == NULL)
return -1;
strcpy(tmp, *append_to);
// Free up and re-allocate append_to.
//
free(*append_to);
*append_to = malloc(strlen(tmp) + strlen(append_this) + 1);
if (! append_to) {
fprintf(stderr, "Malloc error...");
exit(EXIT_FAILURE);
}
// Do it with realloc
//
// No temporary buffer required:
//
// *append_to = realloc(
// *append_to,
// (strlen(append_to) + strlen(*append_this) + 1)
// );
// if (! eppend_to) ...realloc error
// Copy the data to the buffer and clean up.
//
sprintf(*append_to, "%s%s", tmp, append_this);
free(tmp);
}
}
/* In your main() or whatever... */
char *url = NULL;
char *path = NULL;
// Since url and path are both NULL the
// append string function will act like
// your string_dup() function...
append_string(&url, "http://");
append_string(&path, "website.com/");
// And not that url is not null it will be
// resized and the path appended.
append_string(&url, path);
fprintf(stdout, "URL: %s\n", url);
// Some housekeeping....
if (url) free(url);
if (path) free(path);
}
Hope it's useful, I know it's kinda way off from what you originally had but thought I'd play along!