Добрый день!

Пишу кроссплатформенное приложение.
Есть некая функция, с перегрузкой для разных типов, int, unsigned int, size_t, ptrdiff_t, std::string и т.д.

void SomeFunc(int value)
{ ...
}
void SomeFunc(unsigned int value)
{ ...
}
void SomeFunc(size_t value)
{ ...
}
void SomeFunc(std::string value)
{ ...
}

Для Windows x64 (VS2012) все собирается и работает.
А вот для Linux (CentOS 6 x32) — не собирается. Потому что здесь size_t является всего-лишь псевдонимом для unsigned int.
Естесственно, пишет ошибку что SomeFunc() уже определена для unsigned int.

Какое подскажите решение?

Здравствуйте, GhostCoders, Вы писали:

GC>Пишу кроссплатформенное приложение.
GC>Есть некая функция, с перегрузкой для разных типов, int, unsigned int, size_t, ptrdiff_t, std::string и т.д.
GC>

GC>void SomeFunc(int value)
GC>{ ...
GC>}
GC>void SomeFunc(unsigned int value)
GC>{ ...
GC>}
#if defined (_MSC_VER)
GC>void SomeFunc(size_t value)
GC>{ ...
GC>}
#endif
GC>void SomeFunc(std::string value)
GC>{ ...
GC>}
GC>

GC>Для Windows x64 (VS2012) все собирается и работает.
GC>А вот для Linux (CentOS 6 x32) — не собирается. Потому что здесь size_t является всего-лишь псевдонимом для unsigned int.
GC>Естесственно, пишет ошибку что SomeFunc() уже определена для unsigned int.

GC>Какое подскажите решение?

Сейчас проверил на Windows x32 (таже VS2012).
Поведение такое же как на CentOS 6 x32 — size_t — всего-лишь псевдоним к unsigned int.
Так что надо ставить #if для разрядности (32-bit\64-bit) а не для Windows\Linux.

Здравствуйте, McQwerty, Вы писали:

MQ>Здравствуйте, GhostCoders, Вы писали:

GC>>Пишу кроссплатформенное приложение.
GC>>Есть некая функция, с перегрузкой для разных типов, int, unsigned int, size_t, ptrdiff_t, std::string и т.д.
GC>>

GC>>void SomeFunc(int value)
GC>>{ ...
GC>>}
GC>>void SomeFunc(unsigned int value)
GC>>{ ...
GC>>}
MQ>#if defined (_MSC_VER)
GC>>void SomeFunc(size_t value)
GC>>{ ...
GC>>}
MQ>#endif
GC>>void SomeFunc(std::string value)
GC>>{ ...
GC>>}
GC>>

GC>>Для Windows x64 (VS2012) все собирается и работает.
GC>>А вот для Linux (CentOS 6 x32) — не собирается. Потому что здесь size_t является всего-лишь псевдонимом для unsigned int.
GC>>Естесственно, пишет ошибку что SomeFunc() уже определена для unsigned int.

GC>>Какое подскажите решение?

Здравствуйте, GhostCoders, Вы писали:

GC>Какое подскажите решение?

откажитесь от поддержки size_t, но поддержите типы, которыми он может быть, а именно unsigned + uint64_t

Здравствуйте, GhostCoders, Вы писали:

GC>Какое подскажите решение?

[Александреску mode on]

struct generic_some
{
    static void func(std::string);
    static void func(int);
    static void func(unsigned int);
    ....
    // NB! func(size_t)  не определена
};

template <typename T>
struct some_;

template <>
struct some_<std::true_type>: generic_some
{};

template <>
struct some_<std::false_type>: generic_some
{
    using generic_some::func;

    static void func(size_t);
};

struct some: some_<std::is_same<unsigned int, size_t>::type>
{};

[Александреску mode off]


Используйте этот бред на свой страх и риск

Здравствуйте, GhostCoders, Вы писали:

GC>Добрый день!

GC>Пишу кроссплатформенное приложение.
GC>Есть некая функция, с перегрузкой для разных типов, int, unsigned int, size_t, ptrdiff_t, std::string и т.д.

typename disable_if<is_same<size_t,unsigned int>>::type
SomeFunc(size_t value)
{ ...
}

GC>А вот для Linux (CentOS 6 x32) — не собирается. Потому что здесь size_t является всего-лишь псевдонимом для unsigned int.

GC>Какое подскажите решение?
см. выше

А почему бы не сделать функцию шаблоном, чтоб не размножать код для похожих типов (int/unsigned/size_t/...)?

You will always get what you always got
  If you always do  what you always did

Здравствуйте, GhostCoders, Вы писали:

GC>Добрый день!

GC>Пишу кроссплатформенное приложение.

Давайте подумаем.
* Зачем Вам в самом деле несколько синонимов равноразмерных типов для перегрузки функции? Действительно ли должно меняться поведение?
* int тоже может иметь разные размеры на разных платформах (можно огрести конфликт с short, например)

Поэтому, для кроссплатформенного кода куда безопасней ориентироваться на стандартизованные типы с явным указанием размера (что сводит к минимуму проблемы при портировании): int32_t, uint32_t, int64_t, uint64_t и т.д. Платформо-зависимые псевдонимы вроде size_t для этого не самый лучший выход — их длина прыгает.

Здравствуйте, Mr.Delphist, Вы писали:

MD> int тоже может иметь разные размеры на разных платформах (можно огрести конфликт с short, например)

Не-а. Это все равно будут разные типы, даже если у них будут равные размеры. Например, char, unsigned char, signed char — три разных типа, и перегрузка по ним вполне допустима, хотя они будут иметь один и тот же размер, и два из них будут иметь одну и ту же знаковость

Здравствуйте, uzhas, Вы писали:

U>откажитесь от поддержки size_t, но поддержите типы, которыми он может быть, а именно unsigned + uint64_t

Иногда вместо типов с фиксированной размерностью бывает лучше иметь полное покрытие интегральных типов, т.е. signed/unsigned char, int, short, long, long long.
Например если хочется в модуль убрать шаблонную функцию.

//.h:
template<typename T>
void SomeFuncForIntegral(T);

template <typename T>
inline typename std::enable_if<std::is_integral<T>::value>::type
SomeFunc(T v) {
    SomeFuncForIntegral(v);
}

template <typename T>
inline typename std::enable_if<std::is_enum<T>::value>::type
SomeFunc(T v) {
    SomeFuncForIntegral(static_cast<typename std::underlying_type<T>::type>(v));
}

// .cpp:
template<typename T>
void SomeFuncForIntegral(T) {
    // implementation
}

// specializations
template void SomeFuncForIntegral(long long);
template void SomeFuncForIntegral(long);
template void SomeFuncForIntegral(int);
template void SomeFuncForIntegral(short);
template void SomeFuncForIntegral(signed char);
template void SomeFuncForIntegral(unsigned long long);
template void SomeFuncForIntegral(unsigned long);
template void SomeFuncForIntegral(unsigned int);
template void SomeFuncForIntegral(unsigned short);
template void SomeFuncForIntegral(unsigned signed char);

Здравствуйте, slava_phirsov, Вы писали:

_>Не-а. Это все равно будут разные типы, даже если у них будут равные размеры. Например, char, unsigned char, signed char — три разных типа, и перегрузка по ним вполне допустима, хотя они будут иметь один и тот же размер, и два из них будут иметь одну и ту же знаковость

В теории, всё так и есть, безусловно согласен
Но посмотрите на тот же Linux и допущения, сделанные в нём. Иначе вся кроссплатформенность сведётся к фразе "оно компилится на GCC".

Здравствуйте, GhostCoders, Вы писали:

GC>Добрый день!

GC>Пишу кроссплатформенное приложение.
GC>Есть некая функция, с перегрузкой для разных типов, int, unsigned int, size_t, ptrdiff_t, std::string и т.д.
GC>

GC>void SomeFunc(int value)
GC>{ ...
GC>}
GC>void SomeFunc(unsigned int value)
GC>{ ...
GC>}
GC>void SomeFunc(size_t value)
GC>{ ...
GC>}
GC>void SomeFunc(std::string value)
GC>{ ...
GC>}
GC>

GC>Для Windows x64 (VS2012) все собирается и работает.
GC>А вот для Linux (CentOS 6 x32) — не собирается. Потому что здесь size_t является всего-лишь псевдонимом для unsigned int.
GC>Естесственно, пишет ошибку что SomeFunc() уже определена для unsigned int.

GC>Какое подскажите решение?
Используйте std::is_same (как уже предлагали).

Здравствуйте, GhostCoders, Вы писали:

GC> Потому что здесь size_t является всего-лишь псевдонимом для unsigned int.


както unsigned не то что совсем не нужен, но както его слишком много, и гимора с ним

как например

>как правильно сравнить unsigned и signed ?

>Делаю так,

>size_t u = 2;
>int s = -6;
>bool b = s < 0 ? true : static_cast<unsigned int>(s) < u;

вот интересно можно применить к нему унарный минус, а результат всеравно unsigned, с одной стороны есть знак, а с другой нету

Здравствуйте, GhostCoders, Вы писали:

GC>Для Windows x64 (VS2012) все собирается и работает.

GC>А вот для Linux (CentOS 6 x32) — не собирается. Потому что здесь size_t является всего-лишь псевдонимом для unsigned int.

А для Windows x86 тоже будет ругаться.
Потому что size_t и ptrdiff_t — они по стандарту являются не отдельными типами (как wchar_t), а синонимами.

Кроссплатформенное решение состоит в том, чтобы сделать перегрузки SomeFunc к int и long (для покрытия ptrdiff_t) и unsigned и unsigned long (для покрытия size_t).

Здравствуйте, Кодт, Вы писали:

К>Кроссплатформенное решение состоит в том, чтобы сделать перегрузки SomeFunc к int и long (для покрытия ptrdiff_t) и unsigned и unsigned long (для покрытия size_t).
вот 10 лет пишу на С++, боролся с size_t на x64 и никогда в голову не приходило что есть тип unsigned long

и побежал "правильно" кроссплатфирмовать свою библиотеку