But that is exactly what the flag button is there for?! - but this discussion has been had numerous times, and the two sides will never agree.
Safest to flag (or not) as you see fit, because you are a good person rather than an evil one. Then rely on the admins to rescue needlessly ultraflagged articles as appropriate. They are pretty good at doing the right thing.
But the value Y could also be put towards hiring somebody else to do an additional job, giving somebody else a pay rise, or giving money to the shareholders.
In market dynamics, a worker becoming cheaper means that some employers will fight to hire/keep an employee on that surplus, thus driving the employment cost up for everybody else.
Yes, it probably would depend on positions and available talent, but overall and over a longer period, if applied universally to a market (say state like CA), it will be reasonable to expect salary increases (but not increase of how much is that worth because of increasing purchasing power, and increase in prices due to higher willingness to pay).
If you really insist on not having a distinction between "u8"/"i8" and "unsigned char"/"signed char", and you've gone to the trouble of refusing to accept CHAR_BIT!=8, I'm pretty sure it'd be safer to typedef unsigned char u8 and typedef signed char i8. uint8_t/int8_t are not necessarily character types (see 6.2.5.20 and 7.22.1.1) and there are ramifications (see, e.g., 6.2.6.1, 6.3.2.3, 6.5.1).
> and you've gone to the trouble of refusing to accept CHAR_BIT!=8
This one was a head-scratcher for me. Yeah, there's no cost to check for it, but architectures where CHAR_BIT != 8 are rarer even than 24-bit architectures.
I got the impression the author was implying because CHAR_BIT is enforced to be 8 that uint8_t and char are therefore equivalent, but they are different types with very different rules.
E.g. `char p = (char )&astruct` may violate strict aliasing but `uint8_t p = (uint8_t )&astruct` is guaranteed legal. Then modulo, traps, padding, overflow, promotion, etc.
With the disclaimer that I let my language lawyer qualification lapse a while ago, it's broadly to do with the character types being the only approved way to examine the bytes of an object. An object of a type can be accessed only as if it were an object of that type or some compatible type, but: it can also be accessed as a sequence of characters. (You'd do this if implementing memcpy, memset or memcmp, for example.)
6.2.6.1 - only character types can be used to inspect the sequence of bytes making up an objuect, and (interestingly) only an array of unsigned char is suitable for memcpy'ing an object into for inspection. It's possible for sequences of bytes to exist that don't represent a valid value of the original object; it's undefined behaviour to read those sequences of bytes other than via a character type (i.e., I think, via a pointer to something compatible with the object's actual type - there being no other valid ways to even attempt to read it)
6.3.2.3 - when casting a pointer to an object type to a pointer to a character type, the new character pointer points to the bytes of the object. If converting between object types, on the other hand, the original pointer will (with care) round trip, and that seems to be all you can do, and actual access is not permitted
6.5.1 - as well as all the expected ways of accessing an object, objects can be accessed via a character pointer
The article states it was a remake of The Sands of Time, so the early 2000s game. As the basis for the project it will count as the original in this case.
Safest to flag (or not) as you see fit, because you are a good person rather than an evil one. Then rely on the admins to rescue needlessly ultraflagged articles as appropriate. They are pretty good at doing the right thing.
reply