Question

你如何编写（在C / C ++中）一个宏来测试整数类型（作为参数给出）是签名还是未签名？


      #define is_this_type_signed (my_type) ...

Answer 1

在C ++中，使用std::numeric_limits<type>::is_signed。

#include <limits>
std::numeric_limits<int>::is_signed  - returns true
std::numeric_limits<unsigned int>::is_signed  - returns false

请参阅http://msdn.microsoft.com/en-us/library/85084kd6(VS.80).aspx。

Answer 2

如果您想要的是一个简单的宏，这应该可以解决问题：

#define is_type_signed(my_type) (((my_type)-1) < 0)

Answer 3

如果你想要一个宏，那么这应该可以解决问题：

#define IS_SIGNED( T ) (((T)-1)<0)

基本上，将-1转换为您的类型并查看它是否仍为-1。在C ++中，您不需要宏。只需#include <limits>和：

bool my_type_is_signed = std::numeric_limits<my_type>::is_signed;

Answer 4

您的要求并不是最好的，但是如果您想要将定义合并在一起，则可以选择一个选项：

#define is_numeric_type_signed(typ) ( (((typ)0 - (typ)1)<(typ)0) && (((typ)0 - (typ)1) < (typ)1) )

然而，这不被视为 nice 或以任何方式移植。

Answer 5

我其实早就想知道同样的事情。以下似乎有效：

#define is_signed(t)    ( ((t)-1) < 0 )

我测试过：

#include <stdio.h>

#define is_signed(t)    ( ((t)-1) < 0 )
#define psigned(t) printf( #t " is %s\n", is_signed(t) ? "signed" : "unsigned" );

int
main(void)
{
    psigned( int );
    psigned( unsigned int );
}

打印：

int is signed
unsigned int is unsigned

Answer 6

在C ++中你可以这样做：


bool is_signed = std::numeric_limits<typeof(some_integer_variable)>::is_signed;

numeric_limits在＆lt; limits＆gt;中定义。报头中。

Answer 7

Althout typeof目前不是合法的C ++，您可以使用模板推理。请参阅以下示例代码：

#include <iostream>
#include <limits>

template <typename T>
bool is_signed(const T& t)
{
  return std::numeric_limits<T>::is_signed;
}

int main()
{
  std::cout << 
    is_signed(1) << " " << 
    is_signed((unsigned char) 0) << " " << 
    is_signed((signed char) 0) << std::endl;
}

此代码将打印

  1 0 1

Answer 8

对于c ++，有boost :: is_unsigned＆lt; T＆gt;。我很好奇你为什么需要它，恕我直言的原因很少。

Answer 9

更多＆＃34;现代＆＃34;方法是使用type_traits：

#include <type_traits>
#include <iostream>
int main()
{
    std::cout << ( std::is_signed<int>::value ? "Signed" : "Unsigned") <<std::endl;
}

Answer 10

在C ++中，它就像函数重载一样（反正谁需要type_traits？）：

#include <iostream>

bool is_signed(char _) {return true;}
bool is_signed(short int _) {return true;}
bool is_signed(int _) {return true;}
bool is_signed(long long int _) {return true;}

bool is_signed(unsigned char _) {return false;}
bool is_signed(unsigned short int _) {return false;}
bool is_signed(unsigned int _) {return false;}
bool is_signed(unsigned long long int _) {return false;}

int main()
{
    unsigned int x = 5;
    long long int y = 73;
    std::cout << is_signed(x) << std::endl;
    std::cout << is_signed(y) << std::endl;
    return 0;
}

Answer 11

你可以通过模板功能更好地做到这一点，减少宏观讨厌的业务。

    template <typename T>
        bool IsSignedType()
        {
           // A lot of assumptions on T here
           T instanceAsOne = 1;

           if (-instanceAsOne > 0)
           {
               return true;
           }
           else
           {
               return false;
           }
}

原谅格式......

我会尝试一下，看看它是否有效......

Answer 12

在C中，你不能编写一个可以处理基本整数类型的未知typedef的宏。

在C ++中，只要您的类型是基本整数类型或基本整数类型的typedef，就可以。这是你在C ++中所做的：

template <typename T>
struct is_signed_integer
{
    static const bool value = false;
};

template <>
struct is_signed_integer<int>
{
    static const bool value = true;
};

template <>
struct is_signed_integer<short>
{
    static const bool value = true;
};

template <>
struct is_signed_integer<signed char>
{
    static const bool value = true;
};

template <>
struct is_signed_integer<long>
{
    static const bool value = true;
};

// assuming your C++ compiler supports 'long long'...
template <>
struct is_signed_integer<long long>
{
    static const bool value = true;
};

#define is_this_type_signed(my_type) is_signed_integer<my_type>::value

用于测试整数类型是有符号还是无符号的宏

12 个答案: