Почему размер QByteArray равен int, а не unsigned int

Некоторые считают, что введение типов unsigned в C много лет назад было плохой идеей. Такие типы оказались введены в C++, где они глубоко встроены в стандартную библиотеку C++ и типы, возвращаемые операторами.

Да, по стандарту sizeof должен возвращать тип unsigned.

Разработчики Qt придерживаются современного мнения о том, что типы unsigned были плохой идеей, и предпочитают вместо этого сделать возвращаемый тип size типом signed. Лично я считаю это своеобразным.

Чтобы решить эту проблему, вы можете (i) жить с предупреждением, (ii) выключить его на время работы функции или (iii) написать что-то вроде

(std::size_t)idx0.size() >= sizeof(ushortIdx0)

за счет ясности.

Why size() of QByteArray is returned as int rather than unsigned int?

Я буквально не понимаю, почему Qt выбрала подписанный возврат для size(). Однако есть веские причины использовать знаковый вместо беззнакового.

Один печально известный пример того, как unsigned size() терпит неудачу, - это довольно невинно выглядящий цикл:

for (int i = 0; i < some_container.size() - 1; ++i) {
     do_somehting(some_container[i] , some_container[i+1] );
}

Не так уж редко тело цикла работает с двумя элементами, и в этом случае кажется правильным выбором итерации только до some_container.size() - 1.

Однако, если контейнер пуст, some_container.size() - 1 незаметно (беззнаковое переполнение четко определено) превратится в самое большое значение для беззнакового типа. Следовательно, вместо того, чтобы избегать доступа за пределы, он приводит к максимальному выходу за пределы, который вы можете получить.

Обратите внимание, что есть простые решения для этой проблемы, но если size() действительно возвращает значение со знаком, тогда нет проблемы, которую нужно было бы исправить в первую очередь.

Потому что в контейнерах Qt (например, QByteArray, QVector, ...) есть функции, которые могут возвращать отрицательное число, например: indexOf, lastIndexOf, contains, ... а некоторые могут принимать отрицательные числа, например: mid, ... ; Таким образом, чтобы быть совместимыми с классами или даже совместимостью с фреймворком, разработчики используют подписанный тип (int).

Вы можете использовать стандартное приведение C++:

if ( static_cast<size_t>(idx0.size()) >= sizeof(ushortIdx0) )

Причина - это повторяющаяся часть вопроса, но решение несоответствия типов - это допустимая проблема. Для сравнений того типа, который вы делаете, вероятно, было бы полезно выделить их, поскольку они имеют определенное многоразовое значение:

template <typename T> bool fitsIn(const QByteArray &a) {
  return static_cast<int>(sizeof(T)) <= a.size();
}

template <typename T> bool fitsIn(T, const QByteArray &a) {
  return fitsIn<T>(a);
}

if (fitsIn(ushortIdx0, idx0)) ...

Надеюсь, у вас будет всего несколько видов таких сравнений, и было бы лучше всего использовать DRY (не повторяйтесь) и вместо копипасты приведений используйте функции, предназначенные для задачи - функции, которые также выражают намерение исходное сравнение. Тогда становится легко централизовать обработку любых угловых случаев, с которыми вы, возможно, захотите справиться, например, когда sizeof(T) > INT_MAX.

Другой подход - определить новый тип для обертывания size_t и адаптировать его к типам, с которыми вам нужно его использовать:

class size_of {
  size_t val;
  template <typename T> static typename std::enable_if<std::is_signed<T>::value, size_t>::type fromSigned(T sVal) {
    return (sVal > 0) ? static_cast<size_t>(sVal) : 0;
  }
public:
  template <typename T, typename U = std::enable_if<std::is_scalar<T>::value>::type> 
  size_of(const T&) : val(sizeof(T)) {}
  size_of(const QByteArray &a) : val(fromSigned(a.size())) {}
  ...
  bool operator>=(size_of o) const { return value >= o.value; }
};

if (size_of(idx0) >= size_of(ushortIdx0)) ...

Это концептуально расширило бы sizeof и специализировало бы его для сравнения (-ов) и ничего другого.