News for hackers. Stuff that matters.
Re:Type Safe Generic Data Structures in C by uecker on Monday October 05, 2026 @11:37AM (#49966269)
Having used C++ a lot in the past, I think the mess in C++ is way worse. I also contribute to projects that introduce C++ into a C code base, and I really wish they hadn't done this.

Although there are C features I like that I would need to remove before introducing C++ to a codebase, so this may not always be so simple.

Re:Type Safe Generic Data Structures in C by Panzerschrek on Monday October 05, 2026 @12:50PM (#49967313)
> the mess in C++ is way worse

What is mess in C++? Yes, it has some shady parts and is more complex than C, but this complexity provides expressiveness and type safety. And you can always use only features from C++ you find useful.

> also contribute to projects that introduce C++ into a C code base, and I really wish they hadn't done this.

What is problematic in these projects other than unfamiliarity of C++ for developers previously used only C?

Re:Type Safe Generic Data Structures in C by _gabe_ on Monday October 05, 2026 @01:15PM (#49967616)
> What is mess in C++?

Just a couple examples:

How do you make a shallow copy of an object in C++, how do you do the same thing in C? Knowing I can just memcpy _any_ struct in C and have a valid shallow copy is pretty huge.

How do you create a stable ABI in C++? How do you make one in C? In C, knowing that all my exported functions will mostly just work and be stable as long as I don’t change the interface is also huge and allows you to create cross language bindings pretty trivially.

Re:Type Safe Generic Data Structures in C by Panzerschrek on Monday October 05, 2026 @01:54PM (#49968116)
> How do you make a shallow copy of an object in C++

Shallow copies aren't generally possible for classes storing something indirectly, since it violates ownership semantics. That's not how things are done in C++.. Operator = is usually used for making copies, which is optimized to memcpy for POD structures, but for something more complex may perform extra work for doing an actual deep copy.

> How do you create a stable ABI in C++

It's a complex topic. Basic ABI for calling functions is identical to C. But one need to keep in mind, that type layouts and internal implementations of library types (like containers) may differ from implementation to implementation and from version to version.

> knowing that all my exported functions will mostly just work and be stable as long as I don’t change the interface

Nothing prevents you doing this in C++. You can have C-style external interface and use all goods of C++ internally.

Re:Type Safe Generic Data Structures in C by mpweiher on Monday October 05, 2026 @05:00PM (#49970668)
QED.
Re:Type Safe Generic Data Structures in C by 1718627440 on Monday October 05, 2026 @05:02PM (#49970689)
Yeah, and that's the reason why people prefer to write in C.

"That's not how things are done in C++" I like C, because I can just decide for myself how things are done here.

Re:Type Safe Generic Data Structures in C by _gabe_ on Tuesday October 06, 2026 @12:01AM (#49974004)
> Nothing prevents you doing this in C++.

You left out the part of my comment where I said “pretty trivially” lol. C++ is mostly a superset of C, which is why I’m not arguing that it’s impossible to do these things in C++. I like C++ too, and think some of the things in there are great. But the simplicity of C is nice. I would often get overwhelmed thinking about all the different constructors in C++ and what I needed to do to ensure that I didn’t accidentally tank performance by copying objects around everywhere (and potentially calling some invisible constructor that did extra work in the copy function). In C, I know when I memcpy it’s just gonna move some bytes around.

Overall, I really don’t care all that much one way or the other. But I can see how people could prefer C to C++. I could also see how people prefer C++. I really really miss function overloading and <string.h> when I use C

Re:Type Safe Generic Data Structures in C by kunley on Tuesday October 06, 2026 @04:30AM (#49975778)
You seem to be asking question "why people use hacks in C instead of coding in other languages which are more C++ like". Then you describe what is to be C++ like. Well, maybe the issue is that certain people precisely want to avoid the features you just described. Have you considered that?
Re:Type Safe Generic Data Structures in C by variadix on Monday October 05, 2026 @02:23PM (#49968508)
You can’t necessarily do that in C either, it depends on if your object is in a container that relies on pointer stability. Intrusive linked lists are common in C and they get broken by this, for example.
Re:Type Safe Generic Data Structures in C by kccqzy on Monday October 05, 2026 @05:04PM (#49970705)
Calling memcpy on any random old struct in C is how you get bugs. If the struct contains other pointers: who is in charge of freeing them? What if the struct has internal pointers (a pointer pointing to a subobject of the struct)? You are playing with fire and you know it.
Re:Type Safe Generic Data Structures in C by lelanthran on Monday October 05, 2026 @01:24PM (#49967736)
> And you can always use only features from C++ you find useful.

Ah, the old "programmers just need to be more disciplined when using C++".

Yeah, C programmers have never seen that argument before...

Re:Type Safe Generic Data Structures in C by kccqzy on Monday October 05, 2026 @05:06PM (#49970738)
As if C programmers don’t have to be disciplined. Look if you are a C programmer you need to pick good parts of the language to write in as well. A beginner picked gets()? Oh the foes of the young and inexperienced. You picked VLA? Linus would breathe fire unto you.

A difference between C++ programmers and C programmers is that C++ programmers have the awareness to know their language has bad parts to avoid, but C programmers are oblivious to the bad parts until someone uses it, but otherwise sing paeans for the language.

Re:Type Safe Generic Data Structures in C by Someone on Tuesday October 06, 2026 @01:14PM (#49981363)
> A beginner picked gets()?

Nitpick: that isn’t possible anymore. gets was removed from C in C11 (https://en.cppreference.com/c/io/gets)

Re:Type Safe Generic Data Structures in C by uecker on Monday October 05, 2026 @01:46PM (#49968006)
My macro-vector types are type safe. In fact this is the point.

I do not think C++ is more expressive or type safe.

Re:Type Safe Generic Data Structures in C by ranger_danger on Monday October 05, 2026 @03:41PM (#49969580)
In C, assigning the return value from malloc() to a specific type merely produces a warning:

  $ echo -ne "#include <stdlib.h>\nint foo() { return malloc(42); }" | gcc -xc -fsyntax-only -c -
  <stdin>: In function ‘foo’:
  <stdin>:2:20: warning: returning ‘void *’ from a function with return type ‘int’ makes integer from pointer without a cast [-Wint-conversion]
Whereas in C++ it's a hard error:

  $ echo -ne "#include <stdlib.h>\nint foo() { return malloc(42); }" | gcc -xc++ -fsyntax-only -c -
  <stdin>: In function ‘int foo()’:
  <stdin>:2:26: error: invalid conversion from ‘void*’ to ‘int’ [-fpermissive]
Does this not count as "more type safe" to you?
Re:Type Safe Generic Data Structures in C by 1718627440 on Monday October 05, 2026 @05:06PM (#49970741)
No, this counts as C++ is stupid to me. The memory returned by malloc is UNTYPED. The sole reason why void as a type exists is to convey the notion of no type, so that it needs to be assigned to a type by a programmer. If you mean "byte region, please cast before use" that's 'char *'. Since C++ now forces me to write a cast, it effectively forces me to hide and silence errors.

I do want an error when I violate types, I do not want it for void, because that's the whole meaning of void. C++ manages to make it the worst of both worlds.

Re:Type Safe Generic Data Structures in C by josephg on Monday October 05, 2026 @06:28PM (#49971695)
Nah. Malloc’s return type is a pointer. The memory pointed to by a malloc call is untyped. But the return type isn’t void. It’s void*, aka a pointer to unknown.

I’m mostly happy with implicit casts from void* to int* or something. But in this code example, we see an implicit cast from void* to int, casting the pointer itself into a number that might not even fit the pointer. This is rarely what you want. I’d much rather explicit casts in this case.

Re:Type Safe Generic Data Structures in C by 1718627440 on Tuesday October 06, 2026 @06:44AM (#49976639)
You're right, I failed at reading comprehension.

My understanding is that C has a different understanding of the word warning than other languages. Such as in "stern warning" or "warning: the building will collapse if you take that brick out".

This is a philosophical problem. C has false positives to the question: "Is that a program", and some people find that to be idiotic (I don't, this is why I like C). But this becomes really logical, when you have in mind, that the point is that you do not want to have false negatives.

Re:Type Safe Generic Data Structures in C by wahern on Monday October 05, 2026 @07:36PM (#49972222)
What version is your compiler? As of GCC 14 and clang 15 an implicit pointer conversion to int is an error, not merely a warning; and this is without specifying any special conformance or warning modes. I think implicit int conversions have been a constraint violation since at least C99, requiring a diagnostic, though I'm not sure if the switch to an error instead of a warning was prompted by a change in wording in C23 or just a general change in attitude and less concern with failing on pre-existing (but wrong) code.
Re:Type Safe Generic Data Structures in C by ranger_danger on Monday October 05, 2026 @07:50PM (#49972337)
This was GCC 11. I did try clang 15 and got an error (whereas 14 did not), but my point was that the language spec itself allows this, regardless of any specific compiler, and the original argument (as I understood it) was about the type safety of C and C++ (the language specs) themselves.
Re:Type Safe Generic Data Structures in C by wahern on Monday October 05, 2026 @09:38PM (#49973106)
I'm not very familiar with the C++ standard, but I don't think the C++ standard requires compilation to fail, either. It has similar language to the C standard. Per C++23 4.1.1p2.3,

> Otherwise, if a program contains a violation of any diagnosable rule or an occurrence of a construct described in this document as “conditionally-supported” when the implementation does not support that construct, a conforming implementation shall issue at least one diagnostic message.

The C++ standard does seem to explicitly require the compiler to reject translation units with a failed static_assert. (The requirements for #error are a little confusing; not sure if a failed #error in a conditional block requires failure.) But I couldn't find a rule that mandates failure for invalid implicit int conversions. Implicit pointer to int conversions are invalid for the same reasons in both C and C++. Basically, AFAICT C++'s type safety in this regard is a matter of historical compiler behavior, and now the major C compilers are adopting that behavior, which they previously had allowed (with a mandatory diagnostic message) for backward compatibility reasons.

Re:Type Safe Generic Data Structures in C by uecker on Tuesday October 06, 2026 @02:22AM (#49974920)
In both languages this is a constraint violation, and it is fully at the discretion of the compiler on whether it emits a warning or error (often controllable by compiler flags). For my C compiler (GCC) this is an error.
Re:Type Safe Generic Data Structures in C by uhuaua on Monday October 05, 2026 @07:25PM (#49972126)
If C++ adds pattern matching, and it works in practical usage across projects, will the C ecosystem consider adding some kind of pattern matching, perhaps inspired by what comes into C++, perhaps not?

Also, a question for a C expert like you, uecker: In your opinion, does the compound literals feature have complex lifetimes rules or complex semantic rules otherwise?

Re:Type Safe Generic Data Structures in C by uecker on Tuesday October 06, 2026 @12:13PM (#49980608)
Personally, I would like to have pattern matching, but I think we need some other features first. I am usually a bit scared about what C++ comes up with.

I am not sure I understand the second question. I do not think compound literals have complex lifetime rules. The lifetime end with the corresponding block, as do other objects in C (one needs to know what a block is, some people confuse this with scope). There is some potential issue which may be surprising when passing them to macros that make use of the statement expression extension, as the lifetime is then limited to the macro body.

Re:Type Safe Generic Data Structures in C by uhuaua on Tuesday October 06, 2026 @09:28PM (#49986775)
Thank you very much, that helps a lot.

I have read up on it, and I do not remember why I arrived at the conclusion that compound literals have complex rules. Their rules are different from C++ and Rust temporaries, but the rules of compound literals are not complex, though their block lifetimes do have to be understood. I have seen at least two C developers being confused about their lifetimes (mostly about when used inside if-statement's condition or in a loop), but most C developers seem to grasp compound literals and their lifetime quickly, and the cppreference.com page is relatively short, which reflects the simplicity of compound literals. It helps that one can understand them as a local variable, local to the specific block that they are used in.

In contrast, C++ and Rust temporary lifetimes can vary, and those lifetime rules can confuse developers, like in https://fasterthanli.me/articles/a-rust-match-made-in-hell .

Mojo seems to avoid many of C++'s and Rust's issues on the topic about lifetimes.

Edit: The trade-off of C compound literals is as far as I can tell that their lifetime is longer than sometimes necessary.