简短的回答是否定的，您不能这样做。typedef声明了一个别名，而不是一个新类型，因此任何遵守该标准的编译器都不能拥有您现在想要的特性。
不过，您可以借由引入新型别、使用枚举或结构来达成。
如果您使用C语言，则可以轻松地从一个枚举转换到另一个枚举。
因为struct的第一个元素的地址也是struct的地址，所以你可以通过转换struct地址，然后用它的新类型取消引用指针，从而在int8或另一个struct之间转换它。（*((dest_type *)&value)）

我非常喜欢问题Strongly typed using and typedef的作者所在团队提出的解决方案，因为它非常简单：

#define STRONG_TYPEDEF(T, D)                                 \
    class D : public T {                                     \
    public:                                                  \
        template<class... A> explicit D(A... a) : T(a...) {} \
        const T& raw() const { return *this; }               \
    }

不幸的是，它不能处理原始类型，但它与BOOST_STRONG_TYPEDEF类似，可以。
下面是一个小例子和两者的退化“比较”：

#include <iostream>

#define USE_BOOST true

#if USE_BOOST

#include <boost/serialization/strong_typedef.hpp>
BOOST_STRONG_TYPEDEF(std::string, foo);
BOOST_STRONG_TYPEDEF(std::string, bar);

BOOST_STRONG_TYPEDEF(int, myInt); // Boost allows primitives

#else

#define STRONG_TYPEDEF(T, D)                                 \
    class D : public T {                                     \
    public:                                                  \
        template<class... A> explicit D(A... a) : T(a...) {} \
        const T& raw() const { return *this; }               \
    }

STRONG_TYPEDEF(std::string, foo);
STRONG_TYPEDEF(std::string, bar);

// STRONG_TYPEDEF(int, myInt); // this one just classes

#endif

int main()
{
    std::string a = "abc";
    foo b{"abc"};
    bar c = static_cast<bar>(a);
    std::string d = c; // we can assign back to base type

#if USE_BOOST // Boost
    myInt x{4};  // only allows this type of initialization
    switch (x) { // allows primitives, so `switch` works
        case 1:
            std::cout << 1 << std::endl;
            break;
        case 4:
            std::cout << 4 << std::endl;
            break;
    }
#else // Boost don't allow the following:
    if (b == c) {                    // comparing
        std::cout << c << std::endl; // printing
    }
#endif

    /* But we can't
       foo e = a; // assign base type to new type
       foo f = c; // assign one type to another
    */

    return 0;
}

如果大小不一定是一个字节，我们可以（ab）使用指针：

typedef struct foo *rolloverdetection;
typedef struct bar *rolloverdetected;

#define ROLLOVERDETECTION_OFF    ((rolloverdetection) 0)
#define ROLLOVERDETECTION_ON     ((rolloverdetection) 1)

#define ROLLOVERDETECTED_NO      ((rolloverdetected) 0)
#define ROLLOVERDETECTED_YES     ((rolloverdetected) 1)
#define ROLLOVERDETECTED_UNKNOWN ((rolloverdetected) 2)

预处理器符号不再是常量表达式，我们不能把它们用作开关标签之类的东西。
一个很好的解决方案是使用C类型安全的enums。这是用“干净的C”编写代码的优点之一：一种非正式的名称，指在一种语言方言中工作，它编译成某种版本的C，以及具有相同行为的某种版本的C。
简单地说：

typedef enum {
  ROLLOVERDETECTION_OFF,
  ROLLOVERDETECTION_ON
} rolloverdetection;

typedef enum {
  ROLLOVERDETECTED_NO,
  ROLLOVERDETECTED_YES,
  ROLLOVERDETECTED_UNKNOWN = 255
} rolloverdetected;

在C中，您仍然可以将ROLLOVERDETECTED_YES赋给rolloverdetection类型的变量，但在C中就不行了。
如果将代码编译为C，则可以使用C编译器检查这些冲突，即使代码的发布版本不使用C。
如果以8位存储值很重要，我记得GCC支持枚举类型的位域作为扩展（ISO C中没有）：

struct whatever {
  rolloverdetected roll_detect : 8;
};

C++枚举不是完全类型安全的;从enum成员到整数类型的隐式转换是可能的：

int roll = ROLLOVERDETECTION_ON;

而不是在相反方向上。
顺便说一句，如果你用C和C++编译，其他的技术也会出现，比如能够使用更细微的类型转换：

#ifdef __cplusplus
#define strip_qual(TYPE, EXPR) (const_cast<TYPE>(EXPR))
#define convert(TYPE, EXPR) (static_cast<TYPE>(EXPR))
#define coerce(TYPE, EXPR) (reinterpret_cast<TYPE>(EXPR))
#else
#define strip_qual(TYPE, EXPR) ((TYPE) (EXPR))
#define convert(TYPE, EXPR) ((TYPE) (EXPR))
#define coerce(TYPE, EXPR) ((TYPE) (EXPR))
#endif

所以现在，举例来说，我们可以

strip_qual(char *, str)

在C语言中，这只是一个不安全的(char *) str类型转换。在C中，上述宏会产生const_cast<char *>(str)。因此，如果str一开始是const char *，但后来有人将其更改为const wchar_t *，C编译器将诊断上述类型转换。然而，我们的项目并不 * 需要 * C编译器来构建。
与此同时，如果您使用GCC，其C前端具有-Wold-style-cast，它将查找代码中使用(type) value转换标记法的所有位置。