Thread: Join two chars from array into a variable

Compile with increased warning levels. Your compiler should be giving you a hint. What is it, and what do you understand by it?

Originally Posted by mrapoc

It tells me the stack around str is corrupt or something.

That sounds like a runtime error. I'm talking about a warning at compile time.

This is certainly wrong:

Code:

strcat ("0x", str);

The first argument to strcat must be a pointer to a character in an array of char that can be modified. Modifying a string literal results in undefined behaviour.

Rather:

Code:

strcpy(str, "0x");
strcat(str, &testData1[y]);
strcat(str, &testData1[s]);

Note that you will be overwriting str on each iteration of the for loop.

Furthermore, I suspect that you don't want to use strcat in this way, since you print testData1[y] and testData1[s] as chars, and y and s are consecutive. If so, you probaby want to write:

Code:

strcpy(str, "0x");
strncat(str, testData + i, 2);
str[4] = '\0';

Thus you do away with y and s.

Next, what are you trying to do in these two lines?

Code:

*(hex + t) = "0x" + *str;
int t = t+1;

Sorry I should be clearer.

Code:

int testData(void){
    unsigned char *hex;
    int t = 0;
    char *str;
    




    hex = (unsigned char *)malloc(65553);
    if (hex == NULL)
    {
        printf("Cannot allocate memory \n\r");
        exit(1);
    }


    /*store data*/
    char testData1[65] = "BDB653CC0800FD1018FD101AFD101CFD101EBDB665CC0002DD007F00067F0010";
        
    int x = sizeof(testData1) / sizeof(char);
    int p = x-2;


    for (int i = 0; i <= p; i=i+2)
    {
        int y = i;
        int s = i+1;


        printf("\nTest data is: %c %c\n", testData1[y], testData1[s]);


        strcpy (str, &testData1[y]);
        strcat (str, &testData1[s]);
        strcat ("0x", str);


        *(hex + t) = "0x" + *str; 
//I know this is wrong, I'm trying to store the hex values now stored in str, and store them as hex in the hex+1, hex +2 locations
        int t = t+1;    
                                
    }


}

So Y and S is my way of getting the separate pairs from the char array. Probably not the best way but I understand it.

Each time the loop...loops i want to store STR into the hex pointer location. t increments each time so each pair is stored in an incremental location.

I will be processing each pair later on in my program, hence why i need them in hex pairs.

Thanks for the help

Originally Posted by mrapoc

i want to store STR into the hex pointer location

This is vague, but it sounds like you want to interpret a string like "0x10" as the number 16 (i.e, 0x10), then store that number into the current unsigned char. If so, then you should be writing in the loop body something like:

Code:

int t = 0;
for (int i = 0; i <= p; i += 2)
{
    char str[3];
    strncpy(str, testData + i, 2);
    str[2] = '\0';
    hex[t++] = (unsigned char)strtoul(str, NULL, 16);
}

There are several problems with your code mrapoc (apart from the fact it doesn't come close to doing what you intend). Any of the problems individually yield undefined behaviour. All of them together .... well you have multiple instances of undefined behaviour, and sensible practice is to have none.

1) str is an uninitialised pointer, not an array. The call of strcpy() and the first call of strcat() are therefore copying data to a random area of memory. You need to initialise str, for example, by using a malloc() call or make it an array of sufficient length.

2) strcpy() and first strcat() expect to receive a C-style string (an array terminated with a char of value zero) as the second argument. Giving the address of an array element does not achieve that.

3) As laserlight has said, strcat() assumes it can write to its first argument (write data past the end). A string literal, such as "0x", cannot be written to. The result of the writing to something that cannot be written to is undefined behaviour. Some compilers will warn about this.

4) The addition operator does not append strings. The line "*(hex + t) = "0x" + *str" is setting hex[t] to some random value.

5) The line "int t = t + 1" creates a new variable named t as something distinct from the previous variable named t, since it is a different scope. Technically, the code gives undefined behaviour, since it is initialised in terms of itself. In practice, it probably has no effect. It certainly does not increment the t defined near the top of your function.


In C, it should not be necessary to typecast the result of a malloc() call. If you can't get your code to compile without the typecast, it either means you have forgotten to #include <stdlib.h> or that your C compiler is really a C++ compiler. A C++ compiler would refuse to compile code that passes "0x" as the first argument of strcat() though.

Using Visual Studio is fine as long as you have it configured to compile as C.

By the way, notice that I declared str in the loop. You don't have to do that, but you should declare it as an array, not a pointer, unless you want to dynamically allocate memory for it (which doesn't make sense).