Re: C++ user-defined 'new' (expert question)

Here's a question for the C++ experts.

Consider the following situation, reduced here to its simplest form (the real form is far
more complex, and proprietary).

I have a collection of C structures for which there are a number of functions already
defined and for which I need to write a set of C++ wrappers. In particular, there are
already functions that create objects of the C type. These functions and their behavior
are all defined by a set of C functions. So be patient with the examples, because this is
a truly-cut-down example that is fully sanitized. For example, the structure I am dealing
with is more complex than the trivial "point"-style structure shown here, the members are
not simple int values, and so on. The setter/getter functions are much more complex than
the trivial ones shown here. The 'free' function, for example, has to free a number of
internal structures. The original C code was written by a C++ programmer who was forced
to write in C, so philosophically tried to emulate C++ style.

This was done as a C++ console app for purposes of illustration

#include "stdafx.h"

typedef struct {
    int x;
    int y;
} MYPOINT;

MYPOINT * MYPOINT_new(int xv, int yv)
   {
    MYPOINT * pt = (MYPOINT *)malloc(sizeof(MYPOINT));
    pt->x = xv;
    pt->y = yv;
    return pt;
   }
void MYPOINT_free(MYPOINT * p) { free(p); }

void MYPOINT_setx(MYPOINT * pt, int x) { pt->x = x; }
void MYPOINT_sety(MYPOINT * pt, int y) { pt->y = y; }
int MYPOINT_getx(MYPOINT * pt) { return pt->x; }
int MYPOINT_gety(MYPOINT * pt) { return pt->y; }

typedef struct {
    MYPOINT pt;
} MYTYPE;

MYTYPE * MYTYPE_new(MYPOINT pt)
{
    MYTYPE * mt = (MYTYPE*)malloc(sizeof(MYTYPE));
    MYPOINT_setx(&mt->pt, 0);
    MYPOINT_sety(&mt->pt, 0);
}

void MYTYPE_setpoint(MYTYPE * obj, const MYPOINT p) { obj->pt = p; }

// Now, my problem is to move this mess back into C++ so MFC programmers
// who are using it can have something convenient.
// So I wrote a set of C++ wrappers. This has taken me into obscure
// corners of C++ where I have not worked before (such as writing
// my own very complex new/delete operators), and that's where
// the problems arise.

// Consider the following wrapper examples:

class CMyPoint : public MYPOINT {
   public:
      void SetX(int x) { MYPOINT_setx(this, x); }
      void SetY(int y) { MYPOINT_sety(this, y); }
      int GetX() const { return MYPOINT_getx(this); }
      int GetY() const { return MYPOINT_gety(this); }
};

class CMyType : public MYTYPE {
public:
    void SetPoint(const CMyPoint pt) { MYTYPE_setpoint(this, pt); }
    void * operator new(size_t) { MYPOINT pt;
                                  MYPOINT_setx(&pt, 0);
                                  MYPOINT_sety(&pt, 0);
                                  return MYTYPE_new(pt);
                                }
    void * operator new(size_t, char *, int) { MYPOINT pt;
                                               MYPOINT_setx(&pt, 0);
                                               MYPOINT_sety(&pt, 0);
                                               return MYTYPE_new(pt);
                                             }
    // Note that this second form is required because of the presence
    // of DEBUG_NEW

    void * operator new(size_t, MYPOINT * pt)
         { return MYTYPE_new(*pt);}
    void * operator new(size_t, char *, int, MYPOINT * pt)
         { return MYTYPE_new(*pt);}

    // Now, because the original C "constructors" take arguments,
    // I had to add the above two methods, or so I thought.
    // Stroustrup is remarkably over-succinct about parameterized
    // 'new' operators. Note that because the C functions
    // require up to six parameters and do complex initialization,
    // it is completely inappropriate to attempt to replicate
    // the code in the bodies of the C '_new' functions
    // so I could not replicate the trivial code that is
    // shown in these examples. Some of these C functions
    // are up to 50 lines long

    // Note also that most of these objects must be pointer types
    // to objects on the heap, so nominally I should *not*
    // be able to write
    // CMyType t;
};

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

int _tmain(int argc, _TCHAR* argv[])
{
    CMyType * t = new CMyType;
    CMyPoint pt;
    pt.x = 1;
    pt.y = 2;
    t->SetPoint(pt);

    CMyType * mt = new CMyType(&pt);

    // Note that this does not use the 'new' operator
    // I have defined, but issues the error message
    // error C2664: 'CMyType::CMyType(const CMyType &)' : cannot convert parameter 1 from
'CMyPoint *' to 'const CMyType &'
    // which suggests it is trying to use the implicit placement constructor form
    // So how DO I create user-defined 'new' operators with several parameters?
    delete mt;
    delete t;
    return 0;
}

// Another problem is that I would like the C++ classes to actually
// be 'protected', e.g.,
// class CMyPoint : protected MYPOINT
//
// typedef struct {
// ... stuff
// } random_class;
//
// void random_class_do_something(MYPOINT * pt) { ...stuff... }
//
// But this leads to a problem where I have constructs such as
// class CMyRandomClass : protected random_class
// {
// public:
// void DoSomething(CMyPoint * x) { random_class_do_something(x); }
// }
//
// where I get something like
//
// error C2243: 'type cast' : conversion from 'CMyPoint *' to 'MYPOINT *' exists, but is
inaccessible
//
// I need an error-free way to convert a CMyPoint to the C structure from which it is
// derived while still retaining the ability to hide all the members of the C struct I'm
// using as the superclass, and make them inaccessible
//
// The information about C2243 I've been able to find simply says
// "make the derivation public"
// which is not at all what I want to do. But no other workaround seems obvious; I've
// exhaused my experimentation.
//
// Note that the C++ class are intended as pure "interfaces"; they have no data, and if
// there were a way to make them "final" classes, that's what I'd want to do.

        thanks
            joe
Joseph M. Newcomer [MVP]
email: newcomer@flounder.com
Web: http://www.flounder.com
MVP Tips: http://www.flounder.com/mvp_tips.htm