Макрос, чтобы протестировать, подписывается ли целый тип или не подписан

Если Вы хотите макрос затем, это должно добиться цели:

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

В основном, бросок-1 к Вашему типу и видят, все еще ли это-1. В C++ Вам не нужен макрос. Всего #include <limits> и:

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

В 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 (По сравнению с 80) .aspx.

В C++ можно сделать:

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

numeric_limits определяется в < пределы> заголовок.

Я на самом деле просто задавался вопросом то же самое ранее сегодня. Следующее, кажется, работает:

#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

Для C++ существует повышение:: is_unsigned< T>. Мне любопытно, почему Вам нужен он хотя, по моему скромному мнению, существует немного серьезных оснований.

Вы могли сделать это лучше с шаблонной функцией, меньшим макро-противным бизнесом.

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

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

Прощают форматирование...

я испытал бы это и видел бы, работает ли это...

Ваше требование не является точно лучшим, но если требуется взломать вместе определение, одна опция могла бы быть:

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

Однако это не считают хорошим или портативное каким-либо образом.

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

В C Вы не можете записать макрос, который продолжает работать пока еще неизвестное определение типа фундаментальных целых типов.

В C++, Вы можете, пока Ваш тип является фундаментальным целым типом или определением типа фундаментального целого типа. Вот то, что Вы сделали бы в 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