Diff between signed char and char.

[dissectcode]

I would think they are the same. However, when I try both in functions like strcpy() I can only use char. Otherwise the warning is "pointer targets in passing arg 1 of 'strcpy' differ in signedness, when trying with signed char. Please help I don't get it - aren't they the same?

[vmpstr]

The default signedness of char is not in any standard, AFAIK. I believe that's compiler dependent.

The general rule is that if you care about the signedness, then declare it explicitly. That is, if you will be assigning values to it above 127, use unsigned char. If you must have negative values, use signed char.

For dealing with regular, english language strings, you can safely leave out the signed/unsigned qualifier.

Edit:

But to answer your question in a straight forward fashion,

char is either unsigned char or signed char. It's not any other type. Whether it is signed or unsigned is decided by the compiler

[donbock]

@dissectcode
There are three flavors of the 'char' type. The third flavor shown below is referred to as 'plain char'.

signed char v1;
unsigned char v2;
char v3;

Plain char is used to hold character constants (such as 'A'). Whether plain char is a signed or unsigned type is implementation dependent (that is, it can vary from compiler to compiler). However, if you only use plain char to hold character constants then you don't care if it is signed or unsigned.

I recommend a simple rule of thumb: use 'signed char' or 'unsigned char' to hold numbers, and use plain char to hold character constants. You'll find this expressed more eloquently in MISRA-C v2.

Your difficulty with strcpy comes from the function prototype, not from any inherent limitation on the various flavors of char. The function prototype for strcpy specifies pointer-to-plain-char so calling it with any other argument type provokes compiler errors.

[mithuncm]

@dissectcode
as said above they depend on the compiler,
but if char is used the first bit is set 1 or 0 . it will some times be a problen when its first address is refferd to some where, eg
print it character wise , signed or char will print as
FFFFFF8c (read in hes because unreadable format)
else for unsigned char
it will show the proper 8c only (in Hex)
signed char wont be any proplem when you are not doing any functions such as memcpy , or realloc with this char*. fi you do compiler should be compatible else safe to use unsigned char
and try in hex for proper checking
run this eg
you will understand the first bit set as 1 is a great problem
*************
#include <stdio.h>
#include <stdlib.h>

int main()
{
unsigned char *unsigbuff;
char *sigbuff;
unsigbuff="76031\r\nŒ„˜RMfg3QouGQQAAAXFAAAALwAAHSU AAAAE";
sigbuff="76031\r\nŒ„˜RMfg3QouGQQAAAXFAAAALwAAHSUAA AAE";
int i=0;
while(i < 40)
{
if(unsigbuff[i] == '\r' )
{
i++;
if(unsigbuff[i] == '\n')
{
i++;
printf("_u: %2X,%2X",unsigbuff[i],sigbuff[i]);
}

}
else{
i++;}
}
return 0;
}

[donbock]

If the purpose of the code provided by mithuncm is to determine whether plain char is signed or unsigned, then a much simpler way is to interrogate <limits.h>. According to the C89 standard, that header provides the following information:

SCHAR_MIN is the minimum value for an object of type 'signed char' (-127).
SCHAR_MAX is the maximum value for an object of type 'signed char' (+127).
UCHAR_MAX is the maximum value for an object of type 'unsigned char' (+255).
CHAR_MIN is the minimum value for an object of type 'char' (see note).
CHAR_MAX is the maximum value for an object of type 'char' (see note).

If the value of an object of type 'char' is treated as a signed integer when used in an expression, the value of CHAR_MIN shall be the same as that of SCHAR_MIN and the value of CHAR_MAX shall be the same as that of SCHAR_MAX. Otherwise, the value of CHAR_MIN shall be 0 and the value of CHAR_MAX shall be the same as that of UCHAR_MAX.

That is,

#include <limits.h>
#include <stdio.h>
 
/* Run-time determination */
if (CHAR_MIN != 0)
    printf("Plain char is signed\n");
else
    printf("Plain char is unsigned\n");
 
/* Compile-time determination */
#if CHAR_MIN
    printf("Plain char is signed\n");
#else
    printf("Plain char is unsigned\n");
#endif