Comments below.
"Alf P. Steinbach" <alfps@start.no> wrote in message
news:3f69d939.531088046@News.CIS.DFN.DE...[color=blue]
> On Thu, 18 Sep 2003 09:32:04 -0400, "Ron Natalie" <ron@sensor.com> wrote:
>[color=green]
> >
> >"Dario" <dario@despammed.com> wrote in message[/color][/color]
news:bk9893$agg$1@grillo.cs.interbusiness.it...[color=blue][color=green]
> >
> >I don't know why you feel comp.lang.c++ cares about Microsnot compiler[/color][/color]
bugs.[color=blue]
>
> "Microsoft", not a deragatory variant.
>
> Many here care because they're in the position of using actual compilers
> to produce actual code.
>
> The more you know about compiler errors like that, the easier it is to
> conclude whether some error is a language violation or a compiler error
> (in the old days that was obvious, 'cause a compiler was almost never
> wrong, but with modern C++ it's another story).
>
>
>[color=green][color=darkred]
> >> This program is illegal because in the main() function
> >> there is a call to A constructor but A cannot be constructed
> >> because it does not declare the onEvent function.[/color]
> >
> >Absolutely incorect. You can not call constructors.[/color]
>
> There's enough people on this group discussing basic _terminology_ if not
> old-timers too. But for the record:
>
> a constructor can be called.
>
> C++ merely couples that with object allocation, as does all other[/color]
languages[color=blue]
> I know (since that's the point of a constructor), so:
>
> a constructor for type T cannot be called on an existing type T object[/color]
....[color=blue]
>
> ... by using conventional syntax, and it cannot be so called at all in a[/color]
well-[color=blue]
> defined way (using placement new that way is, I think, undefined behavior,
> unless the existing object is destroyed first via explicit call of[/color]
destructor).[color=blue]
>[/color]
The example at the bottom allocates enough memory for 10 CMyObj's. It uses
the following statements to construct and destruct the objects as needed.
m_aData[i].CBankT::CBankT();
m_aData[i].CBankT::~CBankT();
Is this a compiler loophole, or valid code?
-Kanon
// Creates a static block of memory
// that can hold several T objects.
template <class T>
class CBank_t
{
class CBankT : public T {};
CBankT * m_aData;
bool * m_aInUse;
int m_iCapacity;
int m_iSize;
public:
CBank_t(int iCapacity)
{
// allocate memory for future use
m_aData = (CBankT*)malloc(iCapacity*sizeof(CBankT));
m_aInUse = new bool[iCapacity];
memset(m_aInUse, 0, sizeof(bool)*iCapacity);
m_iSize = 0;
m_iCapacity = iCapacity;
}
T * Create()
{
int i = 0;
// Find an object not in use
while (i < m_iCapacity && m_aInUse[i])
i++;
if (i >= m_iCapacity)
return NULL;
m_aData[i].CBankT::CBankT();
m_aInUse[i] = true;
m_iSize++;
return &(m_aData[i]);
}
void Release(T * pObj)
{
int i = pObj - m_aData;
if (i < m_iCapacity)
{
m_aData[i].CBankT::~CBankT();
m_aInUse = false;
m_iSize--;
}
}
int GetSize()
{return m_iSize;}
int GetCapacity()
{return m_iCapacity;}
};
// Simple do nothing class
class CMyObj
{
int m_iX;
public:
CMyObj()
{m_iX = 0;}
~CMyObj()
{m_iX = -1;}
void SetX(int x)
{m_iX = x;}
int GetX()
{return m_iX;}
};
int main()
{
CBank_t <CMyObj> theBank(10);
CMyObj * pObj1, *pObj2;
pObj1 = theBank.Create();
pObj2 = theBank.Create();
pObj1->SetX(3);
pObj1->GetX();
pObj2->SetX(5);
pObj2->GetX();
theBank.Release(pObj1);
theBank.Release(pObj2);
return 0;
}
Microsoft runtime error R6025 Pure Virtual Function Call: a technicalreport 
