Hacker News Board Hacker News, browsed like a classic message board
Live data from Hacker News

Implementing a class with void*

web.eecs.utk.edu

Post reply on HN
Print view View original

1–10 of 78 posts

Re: Implementing a class with void*

#2

Post by sillycross »

This is a well-known way to achieve separation of definition and implementation.

The disadvantage of the method proposed in the article is that, now everything needs a pointer indirection.

A solution that fixes the drawback is used by lz4's library implementation: instead of storing a void star, store a char[] array of same size as the real struct. (of course, now you have to manually make sure the struct size are in sync. It's more error prone, but still not that bad).

Re: Implementing a class with void*

#3

Post by guerrilla »

sillycross wrote: post #2

This is a well-known way to achieve separation of definition and implementation. The disadvantage of the method proposed in the article is that, now everything needs a pointer indirection. A solution that fixes the drawback is used by lz4's library implementation: instead of storing a void star, store a char[] array of same size as the real struct. (of course, now you have to manually make sure the struct size are in…

Why not `typedef struct state state_t` in the header file, then have a `state_t state` in the header file with the `struct state { ... }` definition in the source file? This is similar to what I do in C, I don't see why it wouldn't work in C++.

Re: Implementing a class with void*

#4

Post by prewett »

I'm surprised he doesn't refer to it by name (Pimpl). In C++ it has the advantage that you can change your implementation and retain binary compatibility because the size of your class doesn't change as you add/remove member variables (and maybe more surprisingly, add/removing virtual functions). If you're going to use C++, seems like it would be better to avoid the void* by

  class C {
  protected:
    struct Impl;
    std::unique_ptr mImpl;
  };
And then define C::Impl in the .cpp file.

Re: Implementing a class with void*

#5

Post by kyralis »

guerrilla wrote: post #3
sillycross wrote: post #2

This is a well-known way to achieve separation of definition and implementation. The disadvantage of the method proposed in the article is that, now everything needs a pointer indirection. A solution that fixes the drawback is used by lz4's library implementation: instead of storing a void star, store a char[] array of same size as the real struct. (of course, now you have to manually make sure the struct size are in…

Why not `typedef struct state state_t` in the header file, then have a `state_t state` in the header file with the `struct state { ... }` definition in the source file? This is similar to what I do in C, I don't see why it wouldn't work in C++.

The module that's importing the header needs to know the state size. To do that, it either needs to see the struct declaration or be given the explicit size with the array approach.

Re: Implementing a class with void*

#6

Post by anthony_r »

prewett wrote: post #4

I'm surprised he doesn't refer to it by name (Pimpl). In C++ it has the advantage that you can change your implementation and retain binary compatibility because the size of your class doesn't change as you add/remove member variables (and maybe more surprisingly, add/removing virtual functions). If you're going to use C++, seems like it would be better to avoid the void* by class C { protected: struct Impl; std::uni…

Came here to say exactly that. You can also do this, thought it looks a little worse it allows for even more flexibility, such as complete decoupling of Impl from A across different files:

  // Forward declaration of Impl. What does Impl do?
  // You're not allowed to know.
  class Impl;

  class A {
  protected:
    Impl* mImpl;
  };
I've been using this trick but for a different reason - to reduce the number of #include statements in header files that are included a lot themselves.

Re: Implementing a class with void*

#7

Post by [deleted] »

sillycross wrote: post #2

This is a well-known way to achieve separation of definition and implementation. The disadvantage of the method proposed in the article is that, now everything needs a pointer indirection. A solution that fixes the drawback is used by lz4's library implementation: instead of storing a void star, store a char[] array of same size as the real struct. (of course, now you have to manually make sure the struct size are in…

[deleted]

Re: Implementing a class with void*

#9

Post by ttul »

Back in the 1990s, the video game company I worked at would hang a couple of extra void pointers in every class just to, you know, store extra things that are needed as time goes on…

Re: Implementing a class with void*

#10

Post by kazinator »

> This is not an "industry-standard" way to program in C++.

It absolutely is a de facto industry standard way to program C++, and has a name: PIMPL (Pointer to IMPLementation). It has that name, because it's famous.

It's probably less fashionable in newer code bases; probably someone whose head is up in C++20 will probably scoff at this, and certainly at any version where the secret is hidden by void *.

It provides a good way to wrap C API's in C++.

And, speaking of that, the technique is basically the spiritual equivalent of what happens in many a FFI module in languages other than C++ too, where some C handle is represented as an opaque foreign pointer, which is wrapped in some object native to the language.

Post reply on HN