C语言类型转换

当各种数据类型参与运算时，其转换规则是什么，分为自动类型转换和强制类型转换

自动类型转换时编译系统按照一定的规则自动完成的

而强制类型转换是由程序员通过编程强制转换数据的类型

• C在以下四种情况下会进行隐式自动转换

1. 算术运算中，低类型能够转换为高类型
2. 赋值表达式中，右边表达式的值自动转换为左边变量的类型，并赋值给它
3. 函数调用中参数传递时，系统隐式的将实参转换为形参的类型后，赋值给形参。
4. 函数有返回值时，系统将隐式的将返回表达式类型转换为返回值类型，赋值给调用函数

• 运算表达式中有如下类型转换规则

1. 字符必须先转换为整数（C语言规定字符类型数据和整型数据之间可以通用）
2. short型转换为整型
3. float型数据在运算时一律转换为双精度（double型），以提高运算精度

• 当不同类型的数据进行操作时，应当首先将其转换成相同的数据类型，然后进行操作，转换规则是由低级向高级转换。转换规则如下图所示:
  

  如上图所示，再根据上述的算数表达式的转换规则，我们可以得知：

• 字符型数据和short型数据在算术表达式中，一律转换为int型数据后，再参与运算。
• float型数据在运算时一律转换为双精度(double)型，以提高运算精度(同属于实型)。
• 注意有符号数与无符号数之间的运算中出现的转换。
•  有符号数与无符号数之间的运算中出现的转换

  当表达式中存在有符号类型和无符号类型时所有的操作数都自动转换为无符号类型。因此，从这个意义上讲，无符号数的运算优先级要高于有符号数，这一点对于应当频繁用到无符号数据类型的嵌入式系统来说是丰常重要的。

  举个栗子：
  代码如下：
  
  运行结果如下：
  
  结果分析如下：

  在c语言操作中，如果遇到无符号数与有符号数之间的操作，编译器会自动转化为无符号数来进行处理，因此a＝20，b＝4294967166，这样比较下去当然b>a了。

  再举个栗子：

• // Example program
  #include <iostream>
  #include <string>
  
  int main()
  {
    std::string name;
    unsigned int a = 3;
    std::cout << "What is your name? ";
    std::cout<< a * -1;
    getline (std::cin, name);
  }

  输出是：What is your name? 4294967293 

• int a = -19;
  unsigned int b = 19;
  int c = (a + b) ? a : b;
  unsigned int d = (a + b) ? a : b;
  printf("c:%d\n",c);
  printf("d:%u\n",d);
  printf("a + b:%d\n",a + b);
  printf("a + b:%u\n",a + b);
  printf("ua:%u\n",a);
  return 0;
  
  c:19
  d:19
  a + b:0
  a + b:0
  ua:4294967277

   

  int a = -20;
  unsigned int b = 19;
  int c = (a + b) ? a : b;
  unsigned int d = (a + b) ? a : b;
  printf("c:%d\n",c);
  printf("d:%u\n",d);
  printf("a + b:%d\n",a + b);
  printf("a + b:%u\n",a + b);
  printf("ua:%u\n",a);
  return 0;
  
  c:-20
  d:4294967276
  a + b:-1
  a + b:4294967295
  ua:4294967276

  int a = -19;
  unsigned int b = 20;
  int c = (a + b) ? a : b;
  unsigned int d = (a + b) ? a : b;
  printf("c:%d\n",c);
  printf("d:%u\n",d);
  printf("a + b:%d\n",a + b);
  printf("a + b:%u\n",a + b);
  printf("ua:%u\n",a);
  return 0;
  
  c:-19
  d:4294967277
  a + b:1
  a + b:1
  ua:4294967277

  int a = 20;
  unsigned int b = -19;
  int c = (a + b) ? a : b;
  unsigned int d = (a + b) ? a : b;
  printf("c:%d\n",c);
  printf("d:%u\n",d);
  printf("a + b:%d\n",a + b);
  printf("a + b:%u\n",a + b);
  printf("ua:%u\n",a);
  printf("ub:%u\n",b);
  
  c:20
  d:20
  a + b:1
  a + b:1
  ua:20
  ub:4294967277

  int a = 20;
  unsigned short int b = -19;
  int c = (a + b) ? a : b;
  unsigned int d = (a + b) ? a : b;
  printf("c:%d\n",c);
  printf("d:%u\n",d);
  printf("a + b:%d\n",a + b);
  printf("a + b:%u\n",a + b);
  printf("ua:%u\n",a);
  printf("ub:%u\n",b);
  return 0;
  }
  
  c:20
  d:20
  a + b:65537
  a + b:65537
  ua:20
  ub:65517

   

• // Example program
  #include <iostream>
  #include <string>
  
  int main()
  {
        int a = 255;
       char ch;
       short sh;
       unsigned char uc;
       unsigned short us;
       
       ch = (char)a;
       sh = (short)a;
       uc = (unsigned char)a;
       us = (unsigned short)a;
       printf("ch = %d, sh = %d, uc = %d, us = %d\n", ch, sh, uc, us);
       
       printf("size: \nchar[%d], short[%d], unsigned char[%d], unsigned short[%d]\n",\
               sizeof(char), sizeof(short), sizeof(unsigned char), sizeof(unsigned short));
       
       return 0;
  }
  

  ch = -1, sh = 255, uc = 255, us = 255 size: char[1], short[2], unsigned char[1], unsigned short[2]

• 由于char型变量占1个字节，但最高位是作为符号位的，因此值范围是 -128 ~ 127, unsigned char型变量也占1个字节，但没有符号位，因此值范围是 0 ~ 255， short型和unsigned short型都占2个字节，因此出现上述结果不足为奇