Hyrum K. Wright <hyrum_wright_at_mail.utexas.edu
> For the C++ folks out there, I've got a question about an approach to
> take on the object-model branch. At issue is how to wrap the various
> C structures returned to callers, particularly in a backward
> compatible manner. Currently, I'm looking at svn_wc_notify_t *. As I
> see it, there are a few options:
> 1) Just wrap the pointer to the C struct as a member of the wrapper
> Pros: Easy to implement; lightweight constructor.
> Cons: Getters would need to translate to C++ types; would need to
> implement a copy constructor which deep copies the C struct; would
> also introduce pools, since creating and duplicating C structs
> requires them.
> 2) Wrap each C struct member individually
> Pros: C->C++ complexity is constrained to the constructor,
> everything else is C++ types
> Cons: Hard to extend for future compatibility
> 3) Just pass the C-struct pointer around; don't even bother with a class
> Pros: Dead simple.
> Cons: Requires more memory management thought by consumers; not
> C++-y enough; may introduce wrapping difficulties.
> I'd like to come up with something consistent, which would be used
> throughout the C++ bindings. I'm also interested in a solution which
> ensures the C++ bindings can be used as the basis for other
> object-oriented bindings models (Python, Perl, etc.)
One issue that has not been talked about in this thread
is strong typing. If you remember the problems with
Johan's diff / blame optimizations, the reason behind
it was a confusion of type semantics. Some ints were
line numbers, others were file offsets. But there was / is
no formal way to tell them apart.
Since you decided to use templates in your code, I
thought I would give it a try and design a simple template
class that allows you to define any number of int-like
types that are mutually distinct and require explicit
It would be nice to have the C++ wrappers use these
types instead of plain ints etc. in their signatures.
Received on 2010-09-26 18:14:32 CEST