指向char指针字符串的整数数组

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, ie, 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:

1. eliminates the unneeded code logic
2. eliminates the unneeded variables
3. eliminates the unneeded use of dynamic memory
4. cleanly compiles
5. does NOT seg fault
6. performs the desired functionality
7. note that strlen() returns a size_t , not a int
8. note that sizeof() returns a size_t not a int
9. multiplies the length of the array arr[] by 2 to calculate the number of characters needed to display the converted array
10. adds 1 to the calculated length to allow for the trailing NUL byte
11. 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