Цели числа със знак срещу цели числа без знак за дължини/брой

C++ използва неподписани стойности, защото се нуждаят от пълния диапазон. На 32-битова система езикът трябва да позволява да има вектор от 4 GB, а не само 2 GB. (ОС може да не ви позволи да използвате всичките 4 GB, но самият език не иска да ви пречи)

В .NET целите числа без знак не са съвместими с CLS. Можете да ги използвате (в някои .NET езици), но това ограничава преносимостта и съвместимостта. Така че за библиотеката на базовия клас те използват само цели числа със знак.

И двата случая обаче са крайни. За повечето цели подписаното int е достатъчно голямо. Така че, докато и двете предлагат диапазона, от който се нуждаете, можете да използвате и двете.

Едно предимство, което целите числа със знак понякога имат е, че те улесняват откриването на недостатъчен поток. Да предположим, че изчислявате индекс на масив и поради някакъв лош вход или може би логическа грешка във вашата програма, в крайна сметка се опитвате да получите достъп до индекс -1.

С цяло число със знак това е лесно за откриване. С unsigned ще се увие и ще стане UINT_MAX. Това прави много по-трудно откриването на грешката, защото сте очаквали положително число и сте получили положително число.

Така че наистина зависи. C++ използва unsigned, защото се нуждае от диапазона. .NET използва signed, защото трябва да работи с езици, които не имат unsigned.

В повечето случаи и двете ще работят, а понякога signed може да позволи на кода ви да открива грешки по-стабилно.

Естествено е да използваме неподписани типове за преброяване и размери, освен ако не сме в някакъв контекст, където те могат да бъдат отрицателни и въпреки това да имат смисъл. Предполагам, че C++ следва същата логика на своя по-голям брат C, в който strlen() връща size_t, а malloc() взема size_t.

Проблемът в C++ (и C) с целите числа със знак и без знак е, че трябва да знаете как се преобразуват едно в друго, когато използвате смес от двата вида. Някои препоръчват използването на int със знак за всичко цяло число, за да се избегне този проблем с невежеството и невниманието на програмистите. Но мисля, че програмистите трябва да знаят как да използват своите търговски инструменти (програмни езици, компилатори и т.н.). Рано или късно ще бъдат захапани от преобразуването, ако не в това, което са написали, то в това, което някой друг има. Това е неизбежно.

Така че познавайте инструментите си, изберете какво има смисъл във вашата ситуация.

Тук има няколко аспекта:

1) Максимални стойности: обикновено максималната стойност на число със знак е 1/2 от съответната максимална стойност без знак. Например в C максималната кратка стойност със знак е 32767, докато максималната къса стойност без знак е 65535 (защото 1/2 от диапазона не е необходим за числата -ve). Така че, ако очаквате дължини или брои, които ще бъдат големи, представянето без знак има повече смисъл.

2) Сигурност: Можете да сърфирате в мрежата за грешки при препълване на цели числа, но си представете код като:

if (length <= 100)
{
  // do something with file
}

... тогава, ако 'length' е стойност със знак, вие рискувате 'length' да е -ve число (макар и злонамерено намерение, някакво предаване и т.н.) и кодът да не изпълни очакваното от вас. Виждал съм това в предишен проект, където последователност беше увеличена за всяка транзакция, но когато използваното от нас цяло число със знак достигна максимална стойност със знак (2147483647), то внезапно стана -ve след следващото увеличение и кодът ни не можа да се справи то.

Само някои неща, за които да помислите, независимо от съображенията за основния език/API.

Ако не проектирате библиотека за многократна употреба (в термините на .NET, например VB.NET проект консумира вашата C# библиотека от класове), тогава изберете това, което работи за вас. Разбира се, ако създавате някакъв вид DLL и е възможно вашата библиотека да се използва в проект с различен език (отново, VB.NET идва на ум), тогава трябва да имате предвид несъответстващите типове (неподписани ).