Path: ...!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: Tim Rentsch <tr.17687@z991.linuxsc.com>
Newsgroups: comp.lang.c
Subject: Re: size_t best practice
Date: Sun, 18 Aug 2024 04:32:40 -0700
Organization: A noiseless patient Spider
Lines: 36
Message-ID: <86plq6dq1z.fsf@linuxsc.com>
References: <VdCcne2MOeshN1z7nZ2dnZfqnPWdnZ2d@brightview.co.uk>
MIME-Version: 1.0
Content-Type: text/plain; charset=us-ascii
Injection-Date: Sun, 18 Aug 2024 13:32:44 +0200 (CEST)
Injection-Info: dont-email.me; posting-host="c515e38b156ea485062cf8517e8b6236";
	logging-data="2502119"; mail-complaints-to="abuse@eternal-september.org";	posting-account="U2FsdGVkX199i0m8OcrDYhU+02Zcif762fjbgeFb7yM="
User-Agent: Gnus/5.11 (Gnus v5.11) Emacs/22.4 (gnu/linux)
Cancel-Lock: sha1:Yne7FFMPJh9KqWPrUGnNycQ13qM=
	sha1:m6DQfub3DzElmHMiaaf8effV5Co=
Bytes: 2540

Mark Summerfield <mark@qtrac.eu> writes:

[what type to use for array indexing?]

> I've also noticed that quite a few array-related algorithms
> _assume_ that indexes are signed, so again I have to put in
> guards to avoid subtracting below zero when I use size_t when
> implementing them.
>
> So is it considered best practice to use int, long, long long,
> or size_t, in situations like these?

There is no single "best practice".  Some people are firmly of
the opinion that signed types should be used everywhere.  Other
people are firmly of the opinion that unsigned types should be
used for variables whose domain can never be negative, such as
counts and array indices.  There is no single answer that will
get agreement from everyone.

Having said that, I have two recommendations.

One, for the particular case of array indices, use a typedef
to define a type name to be used exclusively for the purpose
of indexing arrays.  My own practice is to use 'Index' for
this type, but what name is used is less important than that
there be one (following local naming conventions, etc).

Two, write code so that any use of such types will work whether
the underlying types are signed or unsigned.  In other words
don't rely on either signed semantics or on unsigned semantics
for uses of those variables.  Following this precept may need
more mental effort than using a type of known signedness, but
it provides a collateral benefit in that it's easier, in many
cases, to verify the correctness of the code written.  That
benefit makes it worth the effort.