C unsigned char array of strings

Question

I have an array of strings like

char *T[] = {"0000", "0001", "0010", "0011", "0100", "0101", "0110", "0111", "1000", "1001", "1010", "1011", "1100", "1101", "1110", "1111"}; 

When I do it like this, however, where each row is an array of unsigned chars

 unsigned char *T[] = {"0000", "0001", "0010", "0011", "0100", "0101", "0110", "0111", "1000", "1001", "1010", "1011", "1100", "1101", "1110", "1111"}; 

I get the error "Initialization" unsigned char * 'with an expression of type char [5]' converts between pointers to integer types with a different sign. "I suppose this means that some of the views" 0 "and" 1 "that are used are signed, but I'm not sure why and how to deal with it. I would like to have an array of strings, where each row is an array unsigned characters, not signed characters Can anyone help with this?

Note: this is an HW problem, but it is not a real problem, and this is just a minor step in one of the many possible solutions. However, it would be nice if you could help me figure this out without giving me an explicit answer. Thanks.

Answer 1

Lines

C, one of many ways to represent strings, consists of char arrays ending in a finite char , which is null . This is what you get by type when you have “0000” in your code.

What you want is to assign a "0000" array of unsigned char , terminated by the final unsigned char , which has a null value. Given where you start, you will have to quit or possibly present your source data in such a way as not to require casting.

 unsigned char T[][] = { { 0x30, 0x30, 0x30, 0x30, 0x00 }, { 0x30, 0x30, 0x30, 0x31, 0x00 }, { 0x30, 0x30, 0x31, 0x30, 0x00 }, { 0x30, 0x30, 0x31, 0x31, 0x00 }, { 0x30, 0x31, 0x30, 0x30, 0x00 }, { 0x30, 0x31, 0x30, 0x31, 0x00 }, { 0x30, 0x31, 0x31, 0x30, 0x00 }, { 0x30, 0x31, 0x31, 0x31, 0x00 }, { 0x31, 0x30, 0x30, 0x30, 0x00 }, { 0x31, 0x30, 0x30, 0x31, 0x00 }, { 0x31, 0x30, 0x31, 0x30, 0x00 }, { 0x31, 0x30, 0x31, 0x31, 0x00 }, { 0x31, 0x31, 0x30, 0x30, 0x00 }, { 0x31, 0x31, 0x30, 0x31, 0x00 }, { 0x31, 0x31, 0x31, 0x30, 0x00 }, { 0x31, 0x31, 0x31, 0x31, 0x00 } }; 

The main problem that I see in this approach is that it removes most of the benefits of having a C style string in the first place. With the unsigned char string, you don't have any of the standard string libraries at your disposal, so you will need to revert back to the signed char types if you want to use printf , or any other string oriented function.

Indeed, you use only two values ​​for each possible position of the character "0" and "1". If there is no good reason for doing this in a string, consider an array of booleans to reduce the likelihood that a string, such as "0hello", will work in the code, or even better if you were entered into bit fields, use the bits inside the unsigned char as bit fields (discarding any concept with which you deal with strings).

The advantages of the latter method include the use of less memory and the inability for the value to be other than 0 or 1; however, you will need to write a small collection of routines to translate the packed bits into something human readable.

 unsigned char[] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F }; void displayChar(unsigned char value) { switch (value) { case 0x00: printf("0000"); break; case 0x01: printf("0001"); break; case 0x02: printf("0010"); break; case 0x03: printf("0011"); break; ... and so on ...