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

_NN>Статический анализатор MSVC ругается на две последние функции но не ругается на предыдущие.
_NN>Очевидно правила типов работают немного по другому во времени компиляции.

Я так подозреваю, что компиляторы вычисляют константы на этапе компиляции и видят, что результат не выходит за пределы предствавления unsigned short, поэтому предупреждать не нужно.
Попробуйте объявить вместо int l[5], скажем int l[70000].

_NN>Это правильно по стандарту ?
ЕМНИП warning'и стандартом не описываются.

Статический анализатор MSVC ругается на две последние функции но не ругается на предыдущие.
Очевидно правила типов работают немного по другому во времени компиляции.
Это правильно по стандарту ?

#include <algorithm>
#include <type_traits>

static_assert(std::is_same_v< decltype(sizeof(1)), size_t >);
static_assert(std::is_same_v< decltype(static_cast<unsigned short>(1) + sizeof(1)), size_t >);

int f_countof(unsigned short i)
{
    int l[5] = { 1,2,3,4,5 };
    unsigned short j = i + sizeof(l) / sizeof(l[0]); //

    return j;
}

int f_countof_with_cast(unsigned short i)
{
    int l[5] = { 1,2,3,4,5 };
    unsigned short j = i + static_cast<size_t>(sizeof(l) / sizeof(l[0]));

    return j;
}


int f_countof_with_constexpr(unsigned short i)
{
    int l[5] = { 1,2,3,4,5 };
    constexpr size_t q = static_cast<size_t>(sizeof(l) / sizeof(l[0]));
    unsigned short j = i + q;

    return j;
}

int f_countof_with_const(unsigned short i)
{
    int l[5] = { 1,2,3,4,5 };
    const size_t q = static_cast<size_t>(sizeof(l) / sizeof(l[0]));
    unsigned short j = i + q;

    return j;
}

int f_countof_with_var(unsigned short i)
{
    int l[5] = { 1,2,3,4,5 };
    size_t q = static_cast<size_t>(sizeof(l) / sizeof(l[0]));
    unsigned short j = i + q; // warning C4267: 'initializing': conversion from 'size_t' to 'unsigned short', possible loss of data

    return j;
}

int f_std_size(unsigned short i)
{
    int l[5] = { 1,2,3,4,5 };
    unsigned short j = i + std::size(l); // warning C4267: 'initializing': conversion from 'size_t' to 'unsigned short', possible loss of data

    return j;
}

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

Опытным путём выяснилось , что переменная const/constexpr так же как и sizeof не вызывает проблем у статического анализатора:

template <typename T>
const size_t S = 0;

template <typename T, size_t N>
const auto S<T[N]> = N;

// Или
// template <typename T, size_t N>
// constexpr size_t S<T[N]> = N;

void f()
{
    int q[] = { 1 };
    [[maybe_unused]] unsigned short a = S<decltype(q)>; // OK
}

Однако в случае с функцией фокус не проходит:

constexpr size_t w() { return 1; }
constexpr size_t e = 1;

void g()
{
    [[maybe_unused]] unsigned short a = e; // OK
    [[maybe_unused]] unsigned short b = w(); // conversion from 'size_t' to 'unsigned short', possible loss of data
}

Такой вариант не работает потому как std::size возвращает size_t и всё выражение снова получает тип size_t.

#define MY_SIZE(c) \
    (std::is_array_v<decltype(c)> ? S<decltype(c)> : ::std::size(c))

Есть идеи как для массивов использовать переменную, а в остальных случаях функцию ?

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

_NN>Есть идеи как для массивов использовать переменную, а в остальных случаях функцию ?

Я не совсем понимаю, что вы пытаестесь сделать и зачем. Если у вас функция возвращает size_t, то без знания возможных пределов возвращаемого значения в unsigned short результат её выполнения присваивать нельзя. А если пределы известны, то почему просто не сделать static_cast<unsigned short>(::std::size(c))? И вообще, зачем unsigned short ? Это попытка сэкономит пару байтов на стеке?

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

_NN>>Есть идеи как для массивов использовать переменную, а в остальных случаях функцию ?

BFE>Я не совсем понимаю, что вы пытаестесь сделать и зачем. Если у вас функция возвращает size_t, то без знания возможных пределов возвращаемого значения в unsigned short результат её выполнения присваивать нельзя. А если пределы известны, то почему просто не сделать static_cast<unsigned short>(::std::size(c))? И вообще, зачем unsigned short ? Это попытка сэкономит пару байтов на стеке?

Это попытка усмирить статический анализатор.
Есть C API принимает unsigned short.
Если писать f(sizeof(a)) то нет проблем, а вот f(std::size(a)) ругается.

Пока решил через функцию выбирающую минимальный тип через if constexpr.

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

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


_NN>Есть идеи как для массивов использовать переменную, а в остальных случаях функцию ?

Перегрузки с разными возвращаемыми типами:

template<std::size_t N>
struct constant_size { enum { value = N }; };

struct variable_size { std::size_t value; };

template<class T>
constexpr constant_size<sizeof(T)> size(T v) { return {}; }

template<class T, std::size_t N>
variable_size  size(T (&v) [N]) 
{
    return { std::end(v) - std::begin(v) };
}

int main() {
    short a;
    a = size(a).value;
    std::cout << a << '\n';
    short b[3];
    a = size(b).value;
    std::cout << a << '\n';
    return 0;
}

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

AG>Перегрузки с разными возвращаемыми типами:
В общем выяснилось, что анализатор не умеет делать подстановки constexpr функций и всегда жалуется, а с переменными умеет.
Похоже фичу в язык добавили, а обвязку вокруг забыли.

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


_NN>В общем выяснилось, что анализатор не умеет делать подстановки constexpr функций


Ну тогда через Integer Type Selection вотктнуть нужный тип:

template<std::size_t N>
struct constant_size { static const typename boost::uint_value_t<N>::least value = N; };

struct variable_size { std::size_t value; };

template<class T, std::size_t N>
constant_size<T> size(T (&v) [N]) { return {}; }

template<class T>
variable_size  size(T (&v)) 
{
    return { std::end(v) - std::begin(v) };
}

...

size(a).value;

boost::uint_value_t может быть реализован без constexrp функций на std::conditional

template<std::size_t N>
struct uint_value_t
{
   typedef typename std::conditional<
        (N < 256), 
            std::uint8_t, 
            std::conditional<(N < 65536), 
                std::uint16_t, 
                ... > >::type least;
}

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

AG>Ну тогда через Integer Type Selection вотктнуть нужный тип:

Я так и сделал, но без буста, потому что его не хотят видеть в коде