Hacker News Reader

Comment by bluetomcat | Hacker News Reader

Coding in plain C99 with some discipline can actually get you most of the benefits of C++, without any of its quirks.

The "object-orientedness" of C++ really boils down to implicitly passing the this pointer to member functions, inheritance + virtual functions, and namespaces. All of these can be emulated in what I would call "C with discipline". Just be consistent in your naming conventions, always use a common prefix for globally visible functions and types, and use structs of function pointers whenever you really need virtual functions.

View on HN

What about templates? For some reason, C programmers only seem to comment about the OO parts of C++ and never talk about templates. When you bring variadic templates into the mix, it's just more awesomeness.

And, before you mention it, use clang to avoid getting the page long templates related errors.

I haven't seen much template wizardry in the C++ codebases I've worked on. It can generally be seen in the standard headers.

Type-generic data containers can still be implemented with void pointers and very little runtime overhead, for example: http://lxr.nginx.org/source/src/core/ngx_array.h

You cannot implement cache efficient data structures using void pointers.

C99 is nice, but C still lacks generic. I am not talking about C++ template nonsense, but not having to write max element search for every primitive type.

I am working in DSP project which was started with typical C++ OO BS, finally with ended up with C compiled as C++ + some simple templates for cases as above.

Using statement expressions and the typeof extension, you are able to write function-like, type-generic, scope-insensitive macros like this one:

    #define MAX(a,b) ({ \
        typeof (a) _a = (a); \
        typeof (b) _b = (b); \
        _a > _b ? _a : _b; \
    })

The inability to write template functions can be compensated by designing your function so that it takes a function pointer where the type-specific action occurs.

Typeof is not standard and many DSP compilers do not implement that. Secondly I meant max search in array, not between to scalar values which is trivial. I really don't want to have for(...) inlined everywhere.

Your MAX has no respect for namespaces or scopes. A real world macro is probably going to be called MYLIBRARY_MAX to avoid this. Secondly the C++ lambda solution is just easier to read.

    auto max = [](auto a, auto b) { 
        return (a > b) ? a : b;
    };

    max (3.1415, 42); // returns double
    max (42ul, 78u); // returns unsigned long
    max (17, 16); // returns int

I am not talking about C++ template nonsense, but not having to write max element search for every primitive type

How is it template 'nonsense', when those templates do exactly that?

Template metaprograming is nonsense, not simple type substitution. C++ templates are just too much, especially when mixed with substandard developers.

C has a generic: "void *". It just doesn't have any type safety.

It also has bad performance if you need to pass function pointers around.

Is this noticeably worse than calling through the vtable?

In C++ generics don't involve calling through a vtable.

C11 has type generic macros. You can build your own with the _Generic statement.

    int maxi(int, int);
    double: maxd(double, double);
    ...
    #define max(x) _Generic((x), int: maxi, double: maxd, ...default: maxi)

Yeah, but you still need to write those maxi, maxd :-(

Reply on news.ycombinator.com