Mixing C and C++

[Grey Alien]

I have an existing ANSI C library which makes extensive use of structs.
I use these structs in my C++ code, but would like to benefit from C++
features such as ctors/dtors etc. I have modified the C header, as shown
below, with inline functions, so that I can benefit from C++ features,
whilst keeping the rest of the C library intact.

One thing I had to be particularly careful of is the fact that in a lot
of the C API functions, struct assignments were made (i.e. shallow
copies). I have therefore implemented the (overloaded) assignment
operator to create 'shallow' copy by default (so this is consistent with
the C API so that a pointer to the struct could be passed to a C API
function with no adverse effect). The facility still exists for an
(explicit) deepcopy. This is is what I have come up with so far. The CPP
snippet at the end of the post shows how I intend to use it.
//Header File

#ifdef __cplusplus
extern "C"
{
#endif

struct MyStruct
{
public:
MyStruct(const size_t size)
:m_shallow_copied(false)
{
if (!fooAlloc(this, size))
throw new std::bad_alloc ;
}

MyStruct(const MyStruct& ms)
:m_shallow_copied(false)
{
//deep copy because only C++ API calls this ctor
copy(ms, true);
}

MyStruct& operator= (const MyStruct& rhs)
{
//Default shallow copy on assignments
if (this != &rhs)
copy(rhs);
return *this ;
}

//explicit deepcopy
void deepcopy(const struct MyStruct* rhs)
{
copy(rhs,true);
}

~MyStruct::MyStruct
{
if (!m_shallow_copied && m_ptr)
fooFree(this);
}

//Needs to be public - for C API (too many funcs to all be friends)
void * m_ptr ;
size_t m_size ;

private:
void copy(const MyStruct& rhs, const bool deepcopy=false)
{
if (deepcopy)
{
//do we own ptr? (if so, free first)
if (m_ptr && !m_shallow_copied)
fooFree(this);

if (fooAlloc(this, rhs.size ))
throw new std::bad_alloc ;

fooCopy(this, &rhs) ;
m_shallow_copied = false ;
}
else
{
//default
m_ptr = rhs.m_ptr ;
m_size = rhs.m_size ;
m_shallow_copied = true ;
}
}

bool m_shallow_copied ;
};
/* Pure C API */
long fooAlloc(struct MyStruct* ms, const unsigned int size);
void fooFree(struct MyStruct* ms);
void fooCopy(struct MyStruct* dest, const struct MyStruct* src);
long fooJustDoIt(const struct MyStruct* ms);

#ifdef __cplusplus
};
#endif

//Sample cpp file using MyStruct (should probably use auto_ptr instead
of raw pointers ...)

#include "MyStruct.h"

class MyClass
{
public:
MyClass(const size_t s)
{ ms = new MyStruct(s); }

MyClass(const MyClass&);

~MyClass()
{delete ms ;}

long DoSomething() const
{
//pass ptr to MyStruct to C function
return fooJustDoIt(ms);
}

private:
MyStruct * ms ;
};
I would appreciate some feedback as to whether there are any subtle (or
not so subtle) caveats/gotchas I must be aware of with this approach ...

[Wade Ward]

"Grey Alien" <gr**@andromeda.comwrote in message
news:ts******************************@bt.com...

>I have an existing ANSI C library which makes extensive use of structs. I
use these structs in my C++ code, but would like to benefit from C++
features such as ctors/dtors etc. I have modified the C header, as shown
below, with inline functions, so that I can benefit from C++ features,
whilst keeping the rest of the C library intact.

One thing I had to be particularly careful of is the fact that in a lot of
the C API functions, struct assignments were made (i.e. shallow copies). I
have therefore implemented the (overloaded) assignment operator to create
'shallow' copy by default (so this is consistent with the C API so that a
pointer to the struct could be passed to a C API function with no adverse
effect). The facility still exists for an (explicit) deepcopy. This is is
what I have come up with so far. The CPP snippet at the end of the post
shows how I intend to use it.
//Header File

#ifdef __cplusplus
extern "C"
{
#endif

struct MyStruct
{
public:
MyStruct(const size_t size)
:m_shallow_copied(false)
{
if (!fooAlloc(this, size))
throw new std::bad_alloc ;
}

MyStruct(const MyStruct& ms)
:m_shallow_copied(false)
{
//deep copy because only C++ API calls this ctor
copy(ms, true);
}

MyStruct& operator= (const MyStruct& rhs)
{
//Default shallow copy on assignments
if (this != &rhs)
copy(rhs);
return *this ;
}

//explicit deepcopy
void deepcopy(const struct MyStruct* rhs)
{
copy(rhs,true);
}

~MyStruct::MyStruct
{
if (!m_shallow_copied && m_ptr)
fooFree(this);
}

//Needs to be public - for C API (too many funcs to all be friends)
void * m_ptr ;
size_t m_size ;

private:
void copy(const MyStruct& rhs, const bool deepcopy=false)
{
if (deepcopy)
{
//do we own ptr? (if so, free first)
if (m_ptr && !m_shallow_copied)
fooFree(this);

if (fooAlloc(this, rhs.size ))
throw new std::bad_alloc ;

fooCopy(this, &rhs) ;
m_shallow_copied = false ;
}
else
{
//default
m_ptr = rhs.m_ptr ;
m_size = rhs.m_size ;
m_shallow_copied = true ;
}
}

bool m_shallow_copied ;
};
/* Pure C API */
long fooAlloc(struct MyStruct* ms, const unsigned int size);
void fooFree(struct MyStruct* ms);
void fooCopy(struct MyStruct* dest, const struct MyStruct* src);
long fooJustDoIt(const struct MyStruct* ms);

#ifdef __cplusplus
};
#endif

//Sample cpp file using MyStruct (should probably use auto_ptr instead of
raw pointers ...)

#include "MyStruct.h"

class MyClass
{
public:
MyClass(const size_t s)
{ ms = new MyStruct(s); }

MyClass(const MyClass&);

~MyClass()
{delete ms ;}

long DoSomething() const
{
//pass ptr to MyStruct to C function
return fooJustDoIt(ms);
}

private:
MyStruct * ms ;
};
I would appreciate some feedback as to whether there are any subtle (or
not so subtle) caveats/gotchas I must be aware of with this approach ...

How does it compile and link?
--
WW

[Grey Alien]

Wade Ward wrote:

"Grey Alien" <gr**@andromeda.comwrote in message
news:ts******************************@bt.com...

<snip></snip>

>>
I would appreciate some feedback as to whether there are any subtle (or
not so subtle) caveats/gotchas I must be aware of with this approach ...

How does it compile and link?
--
WW

It compiles/links fine ... but I suspect that it is at run time that
I'll find signs that say "here be monsters" ... Since any problems are
likely to be caused by one (or more of the ff):

1). "dangling" pointers
2). Attempt to dealloc memory more than once
3). Attempt to free memory alloc'd with 'new' (or vice-versa)
4). memory leaks

I can't find that out yet for sure, because I'm still developing the
application.

[CBFalconer]

Grey Alien wrote:

>
I have an existing ANSI C library which makes extensive use of
structs. I use these structs in my C++ code, but would like to
benefit from C++ features such as ctors/dtors etc. I have modified
the C header, as shown below, with inline functions, so that I can
benefit from C++ features, whilst keeping the rest of the C
library intact.

One thing I had to be particularly careful of is the fact that in
a lot of the C API functions, struct assignments were made (i.e.
shallow copies). I have therefore implemented the (overloaded)
assignment operator to create 'shallow' copy by default (so this
is consistent with the C API so that a pointer to the struct could
be passed to a C API function with no adverse effect). The
facility still exists for an (explicit) deepcopy. This is is what
I have come up with so far. The CPP snippet at the end of the post
shows how I intend to use it.

//Header File

#ifdef __cplusplus
extern "C"
{
#endif

struct MyStruct
{
public:

Here you are using C++ code, illegal in C. Thus off-topic here.

--
<http://www.cs.auckland.ac.nz/~pgut001/pubs/vista_cost.txt>
<http://www.securityfocus.com/columnists/423>
<http://www.aaxnet.com/editor/edit043.html>
cbfalconer at maineline dot net

--
Posted via a free Usenet account from http://www.teranews.com

[Default User]

Grey Alien wrote:

I have an existing ANSI C library which makes extensive use of
structs. I use these structs in my C++ code, but would like to
benefit from C++ features such as ctors/dtors etc.

That would make it a proper topic for comp.lang.c++.

Brian

[Richard Tobin]

In article <46***************@yahoo.com>,
CBFalconer <cb********@maineline.netwrote:

>#ifdef __cplusplus
extern "C"

....

>Here you are using C++ code, illegal in C. Thus off-topic here.

Since __cplusplus is not defined when using standard C, it's perfectly
legal C.

-- Richard
--
"Consideration shall be given to the need for as many as 32 characters
in some alphabets" - X3.4, 1963.

[Kevin Bagust]

Richard Tobin wrote:

In article <46***************@yahoo.com>,
CBFalconer <cb********@maineline.netwrote:

>>#ifdef __cplusplus
extern "C"

Restored sniped context

>>{
#endif

struct MyStruct
{
public:

>Here you are using C++ code, illegal in C. Thus off-topic here.

Since __cplusplus is not defined when using standard C, it's perfectly
legal C.

But the

struct MyStruct
{
public:

is illegal and not protected by an #ifdef.

Kevin.

[Richard Tobin]

In article <l3******************@newsfe7-gui.ntli.net>,
Kevin Bagust <ke**********@ntlworld.comwrote:

>But the

struct MyStruct
{
public:

is illegal and not protected by an #ifdef.

Yes, I didn't notice that.

-- Richard
--
"Consideration shall be given to the need for as many as 32 characters
in some alphabets" - X3.4, 1963.

[Jorgen Grahn]

On Sun, 01 Jul 2007 00:56:34 +0100, Grey Alien <gr**@andromeda.comwrote:

I have an existing ANSI C library which makes extensive use of structs.
I use these structs in my C++ code, but would like to benefit from C++
features such as ctors/dtors etc. I have modified the C header, as shown
below, with inline functions, so that I can benefit from C++ features,
whilst keeping the rest of the C library intact.

I think it makes more sense to leave the C library alone (presumably
it works well as a C library) and create a separate C++ wrapper.
C++ is good at that kind of thing; it can be done with minimal
run-time performance penalty.

Mixing the two interfaces together just makes them harder to
understand, IMHO.

/Jorgen

--
// Jorgen Grahn <grahn@ Ph'nglui mglw'nafh Cthulhu
\X/ snipabacken.dyndns.org R'lyeh wgah'nagl fhtagn!