integer array to char pointer string - c

Question

I'm trying to convert int array to char pointer string (array values converted to hex).I'm using codeblocks editor.
so,
int arr[4] = {30, 40, 15, 205};
should be converted to
char *str = "1e280fcd";
I have written the following program to do so:
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main()
{
char *cur_str, *prev_str;
char *comp_str, *comp_str_copy;
int arr[] = {30,40,15,205}, i, j, arr_length;
arr_length = (sizeof(arr)/sizeof(arr[0]));
prev_str = malloc(sizeof(0));
cur_str = malloc(sizeof(0));
comp_str = malloc(sizeof(0));
for(i=0;i<arr_length;i++)
{
cur_str = malloc(2);
sprintf(cur_str,"%02x",arr[i]);
comp_str = malloc(sizeof(cur_str)+sizeof(prev_str));
sprintf(comp_str,"%s%s",prev_str,cur_str);
printf("%s\n",comp_str);
free(prev_str);
prev_str = malloc(sizeof(comp_str));
sprintf(prev_str,"%s",comp_str);
if(i==(arr_length-1)){
comp_str_copy = malloc(sizeof(comp_str));
sprintf(comp_str_copy,"%s",comp_str);
}
free(comp_str);
free(cur_str);
}
printf("%s %d\n",comp_str_copy,strlen(comp_str_copy));
return 0;
}
This program's output is either
segmentation fault or
A string with garbage value in the initial locations
I've run the same program on different online compilers. They all give the correct string as output.Is the editor i'm using an issue or my memory management methods?

Answer 1

In
cur_str = malloc(2);
sprintf(cur_str,"%02x",arr[i]);
the sprintf write 3 characters including the final null character, while you allocated only 2
In
comp_str = malloc(sizeof(cur_str)+sizeof(prev_str));
the allocate length is not the right one because the size_of do not return what you expect, must be
comp_str = malloc(strlen(cur_str)+strlen(prev_str)+1);
but of course that supposes prev_str is also a correct string at the beginning, and this is not the case
These two malloc will produce memory leaks because there are not free (nor used)
cur_str = malloc(sizeof(0));
comp_str = malloc(sizeof(0));
Why do you not use realloc to increase the size of prev_str ?
Note the final needed size is easy to know : sizeof(arr)/sizeof(arr[0]) * 2 + 1 if numbers a limited to 255 (2 digits in hexa)
A proposal (without supposing all numbers < 256) :
#include <string.h>
#include <stdlib.h>
int main()
{
int arr[] = {30,40,15,205};
size_t arr_length = sizeof(arr)/sizeof(arr[0]);
size_t i;
size_t sz = 0;
char * r = malloc(0);
for (i=0; i!= arr_length; ++i)
{
char s[20];
int l = sprintf(s, "%02x",arr[i]);
r = realloc(r, sz + l + 1);
strcpy(r + sz, s);
sz += l;
}
printf("%s %d\n", r, sz);
free(r);
return 0;
}
Compilation and xecution :
pi#raspberrypi:/tmp $ gcc -g -pedantic -Wextra a.c
pi#raspberrypi:/tmp $ ./a.out
1e280fcd 8
Execution under valgrind
pi#raspberrypi:/tmp $ valgrind ./a.out
==2985== Memcheck, a memory error detector
==2985== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==2985== Using Valgrind-3.13.0 and LibVEX; rerun with -h for copyright info
==2985== Command: ./a.out
==2985==
1e280fcd 8
==2985==
==2985== HEAP SUMMARY:
==2985== in use at exit: 0 bytes in 0 blocks
==2985== total heap usage: 6 allocs, 6 frees, 1,048 bytes allocated
==2985==
==2985== All heap blocks were freed -- no leaks are possible
==2985==
==2985== For counts of detected and suppressed errors, rerun with: -v
==2985== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 6 from 3)

Answer 2

That was a lot of dynamic memory allocation for a simple task. If the array and string will remain "small" then use the stack to your advantage:
#include <assert.h>
#include <stdio.h>
int main() {
int const arr[] = {30, 40, 15, 205};
int const arr_length = sizeof(arr) / sizeof(arr[0]);
char str[2 * arr_length + 1];
int len = 0;
for (int i = 0; i < arr_length; i++) {
len += sprintf(&str[len], "%02x", arr[i]);
}
assert(len == 2 * arr_length);
printf("%s %d\n", str, len);
return 0;
}
But if you truly need a dynamic string, i.e.,char *str just modified char str[2 * arr_length + 1]; to
char *str = malloc(2 * arr_length + 1);
and add free(str);
NB: All this assumes that you integer array values are less than 256.

Answer 3

the following proposed code:
eliminates the unneeded code logic
eliminates the unneeded variables
eliminates the unneeded use of dynamic memory
cleanly compiles
does NOT seg fault
performs the desired functionality
note that strlen() returns a size_t, not a int
note that sizeof() returns a size_t not a int
multiplies the length of the array arr[] by 2 to calculate the number of characters needed to display the converted array
adds 1 to the calculated length to allow for the trailing NUL byte
lists the variables in the necessary order so specific parameters are always available when needed
And now, the proposed code:
#include <stdio.h>
#include <string.h>
int main( void )
{
int arr[] = {30,40,15,205};
char comp_str[ sizeof( arr )*2 +1 ] = {'\0'};
size_t arr_length = (sizeof(arr)/sizeof(arr[0]));
for( size_t i=0; i<arr_length; i++ )
{
sprintf( comp_str,"%s%02x", comp_str, arr[i] );
printf("%s\n",comp_str);
}
}
A run of the proposed code results in:
1e
1e28
1e280f
1e280fcd