在编码过程中，我们肯定会遇到一些类型相互转化的问题。这一节当中，我们就来讨论类型的相互转化。

1. 判断数据类型的小技巧

在开始之前，先介绍一个小技巧，用于判断某一个数据对象的类型。

#include <stdio.h>
int main()
{
    //  一个整型指针变量p
    int* p; 
    //  各式各样的类型
    char c;
    short s;
    int n;
    long l;
    float f;
    double d;
    //  将整型赋值给指针类型
    p = c;
    p = s;
    p = n;
    p = l;
    p = f;
    p = d;
    return 0;
}

首先，我们定义一个整型指针变量p。注意，这里的int后面加了一个*，说明它是一个整型指针变量。我们先不管什么是指针变量，大家只要知道，指针变量和整型、浮点这些数据类型是不能相互赋值的。

由于它们无法相互赋值，所以编译器会提示报错信息。

从上到下，依次是赋值运算符无法将char、short、int、long、float、double转化为整型指针变量int *。

错误提示与我们定义的变量类型一致，说明这个提示是准确的。好的，那下面我们就可以通过这个小技巧来研究一下，类型与类型之间进行运算，到底会发生什么样的变化呢？

2. 同类型之间进行运算

我们将一步一步探究运算会怎样改变数据对象的类型。首先，我们先了解同类型之间的数据对象进行运算，将会产生怎样的结果。

2.1 有符号整型同类型

#include <stdio.h>
int main()
{
    //  一个整型指针变量p
    int* p; 
    //  各式各样的类型
    char c;
    short s;
    int n;
    long l; 
    p = c + c;  // char + char = int
    p = s + s;  // short + short = int
    p = n + n;  // int + int = int
    p = l + l;  // long + long = long
    return 0;
}

c + c，char同类型运算，结果是一个int类型。
s + s，short同类型运算，结果是一个int类型。
n + n，int同类型运算，结果是一个int类型。
l + l，long同类型运算，结果是一个long类型。

在C语言中，高级别的数据类型能表示的数据范围大于或等于低级的数据类型。

类型级别：
char < short < int < long

有符号整型类型同类型运算中：
比int低级的类型，都会转换成int，比int高级的类型不变。

2.2 无符号整型同类型

#include <stdio.h>
int main()
{
    //  一个整型指针变量p
    int* p; 
    //  各式各样的类型
    unsigned char uc;
    unsigned short us;
    unsigned int un;
    unsigned long ul;   
    p = uc + uc;    // unsigned char + unsigned char = int
    p = us + us;    // unsigned short + unsigned short = int
    p = un + un;    // unsigned int + unsigned int = unsigned int
    p = ul + ul;    // unsigned long + unsigned long = unsigned long
    return 0;
}

uc + uc，unsigned char同类型运算，结果是一个int类型。
us + us，unsigned short同类型运算，结果是一个int类型。
un + un，unsigned int同类型运算，结果是一个unsigned int类型。
ul + ul，unsigned long同类型运算，结果是一个unsigned long类型。

类型级别：
int < unsigned int < unsigned long

无符号整型类型同类型运算中：
比int低级的类型，都会转换成int，比int高级的类型不变。

2.3 浮点同类型

#include <stdio.h>
int main()
{
    //  一个整型指针变量p
    int* p; 
    //  各式各样的类型
    float f;
    double df;  
    p = f + f;      // float + float = float
    p = df + df;    // double + double = double
    return 0;
}

f + f，float同类型运算，结果是一个float类型。
df + df，double同类型运算，结果是一个double类型。

类型级别：
float < double

浮点类型同类型运算中：
类型不变

2.4 同类型运算的结果

上面探究了同类型之间运算结果的类型。

对于整型，级别低于int的类型会转换成int。而比int高级的类型则不发生变化。

对于浮点，不发生变化。