Program: String concatenation using concept of variable arugment functions

Question

Hi I am at beginner level and I am using concept of variable argument functions to concatenate strings. Same function is called for different number of strings.

I am not able to calculate the length of the concatenated string which in turn means i am not allocating memory properly. My dear peers, please help!

/* Program to do string concatenation using the concept of variable arguments */

/********************************************************************************
*                               REQUIRED HEADER FILES
*********************************************************************************/

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

/********************************************************************************
*                               REQUIRED MACROS DEFINED
*********************************************************************************/

#define ERROR_CHECKER(result)\
    if(result == FAILURE)\
    {\
        printf("\n CONCATENATION FAILED");\
    }
typedef enum {SUCCESS = 0, FAILURE = 1} return_type;

/********************************************************************************
*                               REQUIRED FUNCTION PROTOTYPES
*********************************************************************************/
return_type string_concat(char* string_pointer, ...);

/********************************************************************************
*
*    FUNCTION_NAME  :  STRING_CONCAT
*
*    DESCRIPTION    :  concatenates incoming strings and displays the result
*
*    RETURNS        :  SUCCESS OR FAILURE 
*
*********************************************************************************/
return_type string_concat(
    char* string_pointer, 
    ...)
{

/********************************************************************************
*                               REQUIRED DECLARATIONS
*********************************************************************************/
// 1. arg_list that will point to variable number of arguments 
va_list arg_list;

// 2. pointer to concatenated string 
char* concatenated_string;

// 3. character pointer to point to an individual element in the argument list
char* individual_string_pointer;

// 4. amount of memory required to be allocated 
int length;
/*********************************************************************************
*                               REQUIRED INITIALIZATIONS
*********************************************************************************/
va_start(arg_list, string_pointer);
concatenated_string = NULL;
individual_string_pointer = string_pointer;
length = 0;
/*********************************************************************************
*                               PERFORMING REQUIRED TASKS
**********************************************************************************/

// 1. calculate length till you reach quit
while(strcmp(individual_string_pointer,"quit") == 0)
{
    individual_string_pointer = va_arg(arg_list, char*);
    length = length + strlen(individual_string_pointer);
}

// individual_string_pointer reinitialized to be used for concatenation
individual_string_pointer = string_pointer;

printf("\nlength of concatenated string : %d", length);

// 2. allocate memory for the concatenated string
concatenated_string = (char*) malloc(sizeof(char) * length + 1);

// 3. use strncpy to copy first string and then use strncat to concatenate others

strncpy(concatenated_string, string_pointer, sizeof(*(string_pointer)));

while(strcmp(individual_string_pointer, "quit") == 0)
{
    individual_string_pointer = va_arg(arg_list, char*);
    strncat(concatenated_string, individual_string_pointer, sizeof(*(individual_string_pointer)));
}

printf("\n concatenated string : %s",concatenated_string);

va_end(arg_list);
return SUCCESS;
}

/********************************************************************************
*
*   FUNCTION_NAME   :   MAIN
*
*   DESCRIPTION     :   CALLS STRING_CONCAT FUNCTION
*
*   RETURNS         : SUCCESS 
*********************************************************************************/
int main(void)
{

/********************************************************************************
*                               REQUIRED DECLARATIONS
*********************************************************************************/
// 1. character array as the first argument
char string_one[5] = "hello" ;

// 2. variable to store result from the string_concat function.
int result;

/*********************************************************************************
*                               REQUIRED INITIALIZATIONS
**********************************************************************************/

result = 0;

/*********************************************************************************
*                               PERFORMING REQUIRED TASKS
**********************************************************************************/
// 1. call string_concat function with 2 arguments
   result = string_concat(string_one, "my", "name","is","amninder","quit");
    // handle error from string_concat
    ERROR_CHECKER(result);

// 2. call string_concat function with 3 arguments
   result = string_concat(string_one, "I", "Like","fruits","quit");
    // handle error from string_concat
    ERROR_CHECKER(result);  

// 3. call string_concat function with 4 arguments 
   result = string_concat(string_one, "awesome","quit");
    // handle error from string_concat
    ERROR_CHECKER(result);
/* doubt: do I need to send my first argument as same always " */
return SUCCESS;
}

Answer 1

Besides other issues: This sizeof(*(individual_string_pointer))); returns the size of what individual_string_pointer points to, namely a char, so it returns 1.

Either use strlen(ndividual_string_pointer) instead, or just switch to using strcat(), like this:

strcat(concatenated_string, individual_string_pointer)

Answer 2

Your first problem is that you are not doing anything with the data. Your second is an annonying rule preventing iteration over argument lists twice.

Return the concatenated string as malloced memory, or 0 on fail

char *concat(const char *first, ...)
{
    char *answer;
    int lenght;
    va_list va;
    char *nest;
    int nextlen;

    length = strlen(first);
    answer = malloc(length + 1);
    if(!answer)
       goto out_of_memory;
    strcpy(first, answer);

    va_start(va, &first);
    do
    {
        next = va_arg(va, char *);
        if(!strcpy(nest, "quit))
          break;
        nextlen = strlen(next);
        temp = realloc(answer, length + nextlen+1);
        if(!temp)
           goto out_of_memory;
        answer = temp;
        strcpy(answer, next);
        length += nextlen;
    } while(1);
    va_end(va);

    return answer;
    out_of_memory:
      free(answer);
      return 0;
}

Answer 3

Rather than iterate the va_list twice, consider realloc() and append each sub-string. Additional ideas in comments.

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

#define return_type int
#define FAILURE -1
#define SUCCESS 0

//                        use const 
return_type string_concat(const char* string_pointer, ...) {
  va_list arg_list;
  va_start(arg_list, string_pointer);

  char* concatenated_string = NULL;
  size_t length = 0;  // Use type size_t, not int
  const char* individual_string_pointer = string_pointer;

  while (strcmp(individual_string_pointer, "quit")) {
    // Find sub-string length _once_
    size_t individual_length = strlen(individual_string_pointer);
    size_t new_length = length + individual_length;
    char *new_ptr = realloc(concatenated_string, new_length + 1);
    if (new_ptr == NULL) {
      free(concatenated_string);  // do not forget to free old string
      printf("\n MALLOC FALIED");
      return FAILURE;
    }

    concatenated_string = new_ptr;

    // or use memcpy(concatenated_string + length, 
    //            individual_string_pointer, individual_length+1)
    strcpy(concatenated_string + length, individual_string_pointer);

    length = new_length;

    individual_string_pointer = va_arg(arg_list, const char*);
  }
  va_end(arg_list);

  // Add <> to detect leading/trailing white-space
  printf("Concatenated string : <%s>\n", concatenated_string);
  free(concatenated_string);
  return SUCCESS;
}

int main(void) {
  //        not [5], let compiler size it to include the null character
  char string_one[] = "hello";
  string_concat(string_one, "my", "name", "is", "amninder", "quit");
  string_concat(string_one, "I", "Like", "fruits", "quit");
  return 0;
}

Ouput

Concatenated string : <hellomynameisamninder>
Concatenated string : <helloILikefruits>

Answer 4

Your approach is not bad, but could be improved, "quit" is not very safe to mark the end of va_list, NULL is a better choice. Because the user can make a mistake in "quit" like "qui", "qit" or whatever. And how concat "quit"? if you use string_concat without knowing what is inside the function could stop early when one of the strings is "quit":

char *string1 = "foo";
char *string2 = "quit";
char *string3 = "bar";
string_concat(string1, string2, string3, "quit");

Only "foo" will be used.

You don't return the string generate so your function is not really useful.

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

#define END_STRING_CONCAT ((char const *)NULL)

char *string_concat(char const *first, ...);

char *string_concat(char const *first, ...) {
  va_list ap;
  va_start(ap, first);

  va_list cp_ap;
  va_copy(cp_ap, ap); // copy for future use

  size_t size = 1; // need the size of the future string
  for (char const *ptr = first; ptr != NULL; ptr = va_arg(ap, char const *)) {
    size += strlen(ptr);
  }
  va_end(ap);

  char *result = malloc(size);
  if (result == NULL) {
    va_end(cp_ap);
    return NULL;
  }

  size_t used = 0;
  for (char const *ptr = first; ptr != NULL; ptr = va_arg(cp_ap, char const *)) {
    size_t len = strlen(ptr);
    if (size < used || size - used < len) {
      free(result);
      va_end(cp_ap);
      return NULL;
    }
    memcpy(result + used, ptr, len); // use memcpy because it's faster in this case
    used += len;
  }
  va_end(cp_ap);
  if (size < used || size - used != 1) {
    free(result);
    return NULL;
  }
  result[used] = '\0'; // don't forget

  return result;
}

int main(void) {
  char hello[] = "hello, ";

  char *result1 = string_concat(hello, "my ", "name ", "is ", "amninder",
                                END_STRING_CONCAT);
  if (result1 != NULL) {
    printf("%s\n", result1);
    free(result1);
  }

  char *result2 = string_concat(hello, "I ", "Like ", "fruits", END_STRING_CONCAT);
  if (result2 != NULL) {
    printf("%s\n", result2);
    free(result2);
  }

  char *result3 = string_concat(hello, "awesome", END_STRING_CONCAT);
  if (result3 != NULL) {
    printf("%s\n", result3);
    free(result3);
  }

  return 0;
}