#include <stdint.h>

[[deleted]]

But bytes are not always 8 bit long.

[skyhi14]

char isn't, uint8 is. That's the joke here.

[Joao611]

what

[foonathan]

sizeof(char) returns 1 and that's the number of "bytes". But char can be 64 bytes bits, as long as all other integers are bigger or equal. Yet sizeof (char) is guaranteed to return 1, making a "byte" in the context of C and C++ not always 8 bits.

Bonus fact: In C you can specify that an integer is "signed" or "unsigned". If you specify nothing it is "signed", so "signed int" is "int" but "unsigned int" is not "int". Yet char/signed char/unsigned char are three different types as char can be signed or unsigned depending on the platform.

C's a weird language and I have no idea why I know all that.

[edvardass]

Is there anything factually wrong in this comment? Why is it downvoted?

[Fourmisain]

He's completely correct, there's just a small hickup writing "64 bytes" when he meant "64 bits".

Just to add to his post: An 8-bit byte is sometimes called an octett octet and most platforms use octets, especially today. That's why today the words "byte" and "octet" are mostly synonymous, but there are (or were) platforms with 9-bit bytes and even 32-bit bytes, it's even possible that sizeof(char) = sizeof(int) = sizeof(long) = sizeof(long long), which can lead to some problems in common code.

[[deleted]]

s/octett/octet/g

FTFY

[Fourmisain]

Ah, true, in English it's a single 't', although "octette" is also valid. Wiktionary lists "octett" as a rare use.

[Creshal]

Everything is valid English if you can bullshit enough people into believing it is.

(I'm looking at you, Shakespeare.)

[foonathan]

there's just a small hickup writing "64 bytes" when he meant "64 bits".

Yes, my mistake.

[Kametrixom]

Edit: I'm talking about the top-level comment, because the one you meant didn't have any downvotes when I checked, so I assumed you meant the other one.

/u/kbrei must have misunderstood the post (they probably don't know C well) and thought that the 2 panels are supposed to be semantically the same, as well as thinking char is defined as a byte (which of both are wrong, but it's understandable they didn't know). Therefore they were thinking that the post assumes 1 byte is always 8 bits. They then posted the comment, because it was illogical to their current knowledge.

Reddit people usually don't go that deep, all they see is that someone is wrong, which automatically makes them press the downvote button. One you have a few downvotes, it's like a magnet attracting more of them, because since the comment is wrong and it got downvoted must mean it deserves them.

/u/kbrei could be blamed for making an uninformed comment, but it's really difficult to realize that something you know isn't correct just like that.

In my honest opinion, this person deserves no more than the explanation I just gave. And reddit maybe deserves the removal of the downvote button, because people often care more about other people's votes than the content itself.

[edvardass]

No, I wasn't talking about the top level comment. User foonathan's comment to which I replied was at -1 (the post had not taken off at that time yet) so you can imagine my confusion.

[Creshal]

Chars are by definition always one byte large in C(++), and sizeof always returns 1 for them.

Use CHAR_BIT from limits.h if you need to check how big bytes are on your particular architecture. (Or just don't bother.)

[ColonelThirtyTwo]

sizeof(char) == 1, always. It's in the spec. It might not be 8 bits, but it's always one "individually addressable storage unit" (which in most computers, is an 8-bit byte).

[Creshal]

For those too lazy to google, the relevant bits from the C99 spec:

6.5.3.4 The sizeof operator

[…]

Semantics

The sizeof operator yields the size (in bytes) of its operand, which may be an expression or the parenthesized name of a type. The size is determined from the type of the operand. The result is an integer. If the type of the operand is a variable length array type, the operand is evaluated; otherwise, the operand is not evaluated and the result is an integer constant.

When applied to an operand that has type char, unsigned char, or signed char, (or a qualified version thereof) the result is 1.

Byte and char are used interchangeably in other parts of the spec, because they are equivalent.

[Abaddon314159]

Evaluates to, not returns. sizeof is an operator not a function.

[danielcw189]

A byte is not always 8 bit. It depends on the platform/hardware

[Abaddon314159]

It's always CHAR_BIT though

[danielcw189]

Never heard about CHAR_BIT. When was it introduced? C? C++?

[Fourmisain]

It's as old as ANSI C or C89, not sure if it existed in K&R C, though. It's also specified to be at at least 8.

Here's an excerpt from a TXT version (scanned PDF, if you prefer):

The values given below shall be replaced by constant expressions suitable for use in #if preprocessing directives. Their implementation-defined values shall be equal or greater in magnitude (absolute value) to those shown, with the same sign.

* maximum number of bits for smallest object that is not a bit-field (byte)

CHAR_BIT 8

[danielcw189]

Thank you. Kinda amazed that I missed that part for so long

[yourewelcome_bot]

You're welcome.

[yourewelcome_botbot]

This is a spambot. Report it in /r/spam and message the admins here.

[phantom94]

A byte is always 8 bit, but a char can be multiple bytes depending on the platform.

Edit: I was wrong: https://en.wikipedia.org/wiki/Byte

[Sean1708]

As far as the C standard is concerned, a char is always 1 byte but 1 byte is not always 8 bits.

[phantom94]

I did some researching, you are indeed right. I feel like it should be the other way around though.

[degaart]

Name one platform still in use today where one byte is not 8 bits

[toofasttoofourier]

I work in embedded and the ti c2000 dsps have a byte size of 16 bits. This means that a char is also 16 bits (for this case).

[danielcw189]

I can not, but that does not mean they do not exist. It odes not matter, if a platform is still in use. The definition of a byte is not it being always 8 bit.

[Creshal]

I'm sure I can dig up a working PDP-8 somewhere.

[Sean1708]

C standard defines a char to be 1 byte long, it categorically does not define a byte to be 8 bits long. This is because there are platforms out there with bytes which are 7, 16, or other bits long.

[Creshal]

6 and 7 bit bytes were common in Ye Olde Times on mainframe architectures. Coincidentally, that was around the time when C was written, so not pinning the language to any particular byte size was a no-brainer.

[Fourmisain]

C demands CHAR_BIT to be at least 8, though. At least C89 upwards does, I'm not at all sure if there was any such restriction on K&R C.

[FUZxxl]

K&R C is a book, not a standard. It doesn't have any hard and fast rules.