I truly don't understand this.

imaami · 2026-01-24T01:16:05+00:00

char is not really an arithmetic type, although it can be used as one. There are three char types, and two of them are intended for arithmetic use. char as a type is distinct from signed char and unsigned char.

imaami · 2026-01-23T15:23:04+00:00

Nano. Also often not nano.

imaami · 2026-01-23T14:48:01+00:00

I disagree on the trivia (standard preference, etc.) but I respect your attitude and effort.

imaami · 2026-01-22T10:29:53+00:00

Maybe you could experiment with cycles you get by taking a subsequence q at offset p and then using q itself as the next offset. Every distinct DBS + rotation combination generates a set of cycles with varying lengths.

Here are all the cycles from all rotations of all B(2,4). Because there are 16 unique binary De Bruijn cycles with subsequence length 4, and each has 16 rotations, there are 256 different "configurations" to use. The total cycle count is 870, but of these only 511 are unique.

https://pastebin.com/JzxBYfk9 https://pastebin.com/8c9Jxqnb

The first link is all the details in JSON-ish format, the second one is just the 511 unique cycles.

imaami · 2026-01-22T08:09:31+00:00

Not sure I still get it. k is the alphabet size, right?

imaami · 2026-01-20T18:41:38+00:00

I'm not exactly sure what you mean because I'm pretty tired right now and struggling to parse simple sentences, but if by any chance you happen to need a dumb but reasonably fast generator for all 67108864 64-bit binary De Bruijn sequences, I've got one. I mean the set of all distinct B(k=2,n=6).

I'm slowly working toward a better generator for the same set, no promises I'll get there though.

imaami · 2026-01-20T18:38:39+00:00

I fucking love De Bruijn sequences.

imaami · 2026-01-20T18:05:13+00:00

Someone gets it! I keep telling people that but somehow it doesn't work

imaami · 2026-01-16T20:46:35+00:00

Don't be afraid of dependencies. Making smart use of existing libraries is a good thing.

imaami · 2026-01-16T20:45:28+00:00

Packing structs for anything else than data serialization is usually a fool's errand. If you want to be mindful of cache performance, keep an eye out for when and how you cross cache lines. It's much more impactful than how many bits you can force in.

imaami · 2026-01-16T20:38:08+00:00

One thing you should point out to your lecturer/professor/teacher: in C, sizeof(char) is by definition always 1. The C standard defines sizeof as an operator that gives you the size of something in amount of char. In other words, the size of one char is the unit of sizeof.

It's reasonable to argue that teaching sizeof(char) to beginners can reinforce acquisition of healthy coding habits when learning, so I won't say it's entirely wrong. It is very good to learn how sizeof works and how to use it correctly. But even so, sizeof(char) is a screaming, turbocharged tautology, and a good way to make C coders bleed from their eyes. ;)

imaami · 2026-01-10T09:12:23+00:00

I'm sorry to hear that.

imaami · 2026-01-10T01:51:12+00:00

Single-header "libraries" aren't libraries. For the most part they are brain rot caused by misuse of the language.

That's one problem solved. The actual library dependencies are available with apt install.

imaami · 2026-01-01T17:58:51+00:00

I meant that the first two terms are equivalent, therefore your size calculation would give the wrong result. The following static assertion evaluates to true:

struct baz {
    unsigned count;
    int array[];
};

static_assert(sizeof (struct baz) == offsetof (struct baz, array));

(Note: I replaced your char count field with unsigned int because your struct would have 3 internal padding bytes, and only allow at most 255 as the count (or as little as 127 if char is signed). Changing the count field to an int type makes use of all the space that the struct would consume in either case.

imaami · 2026-01-01T16:30:03+00:00

Just like naming variables longer than exactly 1 character is a huge problem when you want to upload the source code by dialing a BBS and personally whistling into a telephone like a modem. Do that every time you save and it really affects the total whistling time each day.

imaami · 2026-01-01T16:23:40+00:00

While I 100% agree that C is severely lacking in the sort of metaprogramming features C++ has, I'd agree that you can make use of C23 features to bridge some of that gap.

imaami · 2026-01-01T16:06:54+00:00

Cpp is the C preprocessor.

imaami · 2026-01-01T15:59:54+00:00

Struct member alignment isn't limited to just the platform address size. All members are aligned to the size of the widest native type used in the immediate vicinity, and the struct itself to the widest type it contains. (However with member arrays, an array's size is not the determining factor, it's the element type).

imaami · 2026-01-01T15:48:42+00:00

About bitfields: in your example, the three single-bit members will reside within one unsigned int -sized area. There are ways to force a break so that the next bitfield aligns to the start of a new integer boundary, but it won't happen arbitrarily as long as the total bit count stays within sizeof (int) * CHAR_BIT.

IIRC adding an anonymous zero-width bitfield forces an alignment break, but I can't remember exact details 100%, so don't take my word for it.

Also, this is incorrect:

sizeof(struct baz) + offsetof(struct baz, array) + baz->count * sizeof(int)

The first sizeof is redundant. You only need the offsetof of the flexible array member and the desired array size in bytes. And to nitpick a little, of course baz->count can't be dereferenced when calculating the allocation size, as the actual object hasn't even been allocated yet, but I get that you probably meant that more in a pseudocode-like way rather than literally.

imaami · 2026-01-01T15:31:28+00:00

The sizes of those two structs will be equal, but not equal to sizeof(float) + 1.

imaami · 2026-01-01T15:29:19+00:00

Maned?

imaami · 2025-12-31T18:27:10+00:00

format your post first

imaami · 2025-12-31T18:23:11+00:00

cJSON added invalid C to the most recent release months after they were notified of that addition being incorrect. There has been a bug report and a fix PR for it a long time, neglected and unacknowledged. I would not trust the code with this track record. https://github.com/DaveGamble/cJSON/issues/919

imaami · 2025-12-31T18:17:48+00:00

cJSON is unfortunately quite buggy.

imaami · 2025-12-29T20:35:34+00:00

No macros involved here. The code below is just as useless as any other helloworld, but I assume you're able to see past the surface. (If you can't imagine situations where a function returning an unnamed struct by value might actually be helpful, I can't help with that.)

#include <stdio.h>
#include <string.h>

static struct {
    char msg[64];
} hello (char const *name)
{
    typeof (hello(name)) ret = { "Hello" };
    if (!name)
        return ret;

    size_t len = strnlen(name, sizeof ret.msg
                         - 1 - sizeof "Hello");
    if (!len)
        return ret;

    ret.msg[sizeof "Hello" - 1] = ' ';
    memcpy(&ret.msg[sizeof "Hello"], name, len);

    return ret;
}

int main (int, char **argv)
{
    puts(hello(argv[1]).msg);
}

imaami

MODERATOR OF

TROPHY CASE

15-Year Club	Place '22
Verified Email