K
ksukhonosenko
This message was originally posted to comp.lang.c++.moderated
----------------------------------------------------------------------------------------------
Hi!
I face a problem in my production code. I could deduce this problem to
program shown below. It seems, that try-block in constructor doesnt
work as it should (compared to case where no try block exists at all).
I tested this small program on my MSVC .NET Pro 2003 (and separately on
PC with MSVC2003 SP1 installed). In both cases I experienced the same
behaviour - access violation. Please see comment inside the program
body. To get this sample work - just comment out try block in ctor.
Have anyone faced such behaviour before? Is there known workarounds?
Thanks.
----
// ref_count.cpp : ctor try block invalid behaviour test
// if ctor uses try block (X::X), program crashes, trying to
dereferencing danglig pointer
// If try block is disabled, everything goes fine.
// I experienced this problem in my production code which used
boost::intrusive_ptr class.
// I wrote similar class (CountingPtr) for simplicty's sake (and to
kill dependencies) and results are the same - program crashes
// tested on compilers: MS VS.NET 2003 (both original & SP1)
#include <iostream>
#include <cassert>
using namespace std;
struct IRefCounted
{
virtual void addRef() = 0;
virtual void release() = 0;
virtual ~IRefCounted() {};
};
struct ILogger : public IRefCounted
{
void virtual write(const char * text) = 0;
};
class Logger : public ILogger
{
int m_ref;
~Logger(){}
public:
Logger() : m_ref(0)
{
}
void addRef()
{
m_ref++;
}
void release()
{
if(--m_ref == 0)
delete this;
}
void write(const char * text)
{
cout << text << endl;
}
};
template<typename T>
class CountingPtr
{
T * m_t;
public:
CountingPtr(T * t, bool addRef = true) : m_t(t)
{
assert(t!=0);
if(addRef)
t->addRef();
}
~CountingPtr()
{
if(m_t)
m_t->release();
}
CountingPtr&operator=(const CountingPtr & rhs)
{
if(this == &rhs)
assert(false);
else
{
m_t = rhs.m_t;
m_t->addRef();
}
return *this;
}
T * operator->()
{
return m_t;
}
CountingPtr(const CountingPtr & rhs)
{
*this = rhs;
}
};
typedef CountingPtr<ILogger> CLoggerPtr;
void use(CLoggerPtr logger)
{
logger->write("use");
}
class Loggable
{
public:
Loggable(CLoggerPtr logger) : m_logger(logger)
{}
private:
CLoggerPtr m_logger;
};
class X : public Loggable
{
public:
X(CLoggerPtr logger)
try : Loggable(logger) // comment try block out to
get working code!
{}
catch(std::runtime_error & )
{
throw;
};
};
int main(int argc, char* argv[])
{
try
{
CLoggerPtr logger(new Logger());
use(logger);
{
X y1(logger); // THIS line decrements ref counter by 2 in case try
block is active
}
{
X y2(logger); // OOPS IS HERE! If try block is in act, program tries
to reference dangling pointer
}
return 0;
}
catch(exception & ex)
{
cout << "Exception: " << ex.what() << endl;
return EXIT_FAILURE;
}
catch(...)
{
cout << "(...) exception" << endl;
return EXIT_FAILURE;
}
}
----------------------------------------------------------------------------------------------
Hi!
I face a problem in my production code. I could deduce this problem to
program shown below. It seems, that try-block in constructor doesnt
work as it should (compared to case where no try block exists at all).
I tested this small program on my MSVC .NET Pro 2003 (and separately on
PC with MSVC2003 SP1 installed). In both cases I experienced the same
behaviour - access violation. Please see comment inside the program
body. To get this sample work - just comment out try block in ctor.
Have anyone faced such behaviour before? Is there known workarounds?
Thanks.
----
// ref_count.cpp : ctor try block invalid behaviour test
// if ctor uses try block (X::X), program crashes, trying to
dereferencing danglig pointer
// If try block is disabled, everything goes fine.
// I experienced this problem in my production code which used
boost::intrusive_ptr class.
// I wrote similar class (CountingPtr) for simplicty's sake (and to
kill dependencies) and results are the same - program crashes
// tested on compilers: MS VS.NET 2003 (both original & SP1)
#include <iostream>
#include <cassert>
using namespace std;
struct IRefCounted
{
virtual void addRef() = 0;
virtual void release() = 0;
virtual ~IRefCounted() {};
};
struct ILogger : public IRefCounted
{
void virtual write(const char * text) = 0;
};
class Logger : public ILogger
{
int m_ref;
~Logger(){}
public:
Logger() : m_ref(0)
{
}
void addRef()
{
m_ref++;
}
void release()
{
if(--m_ref == 0)
delete this;
}
void write(const char * text)
{
cout << text << endl;
}
};
template<typename T>
class CountingPtr
{
T * m_t;
public:
CountingPtr(T * t, bool addRef = true) : m_t(t)
{
assert(t!=0);
if(addRef)
t->addRef();
}
~CountingPtr()
{
if(m_t)
m_t->release();
}
CountingPtr&operator=(const CountingPtr & rhs)
{
if(this == &rhs)
assert(false);
else
{
m_t = rhs.m_t;
m_t->addRef();
}
return *this;
}
T * operator->()
{
return m_t;
}
CountingPtr(const CountingPtr & rhs)
{
*this = rhs;
}
};
typedef CountingPtr<ILogger> CLoggerPtr;
void use(CLoggerPtr logger)
{
logger->write("use");
}
class Loggable
{
public:
Loggable(CLoggerPtr logger) : m_logger(logger)
{}
private:
CLoggerPtr m_logger;
};
class X : public Loggable
{
public:
X(CLoggerPtr logger)
try : Loggable(logger) // comment try block out to
get working code!
{}
catch(std::runtime_error & )
{
throw;
};
};
int main(int argc, char* argv[])
{
try
{
CLoggerPtr logger(new Logger());
use(logger);
{
X y1(logger); // THIS line decrements ref counter by 2 in case try
block is active
}
{
X y2(logger); // OOPS IS HERE! If try block is in act, program tries
to reference dangling pointer
}
return 0;
}
catch(exception & ex)
{
cout << "Exception: " << ex.what() << endl;
return EXIT_FAILURE;
}
catch(...)
{
cout << "(...) exception" << endl;
return EXIT_FAILURE;
}
}