VC++: Cast operator not used?

[A. W. Dunstan]

I'm porting some code to Visual C++ and have run into a problem - the
compiler won't use a user-written cast operator.

The code uses an envelope-letter approach to passing (potentially)
large pieces of data around, and requires that certain methods return
an Envelope with a specific kind of Letter as it's content. I have a
cast operator that converts from what I've got to what should be
returned, but it seems that the compiler only looks at constructors
for the return type.

The code works fine with the SGI MIPSPRO and Linux GCC compilers.
With MS Visual C++ .NET (v. 7.1.3008) it says:

CDP3x3LinearTra nsform.c++(196) : error C2668: 'DataPacket::Da taPacket' :
ambiguous call to overloaded function
DataPacket.h(53 ): could be 'DataPacket::Da taPacket(Letter &)'
DataPacket.h(52 ): or 'DataPacket::Da taPacket(const DataPacket &)'
DataPacket.h(51 ): or 'DataPacket::Da taPacket(const Envelope<T> &)'
where the offending line in CDP3x3LinearTra nsform.c++ looks like this:

DataPacket
CDP3x3LinearTra nsform::Output( ) const {
ChannelDataPack et result;
//... compute result here...
return result; // line 196
}

In this case I've got a ChannelDataPack et and need to return a
DataPacket. ChannelDataPack et is NOT derived from DataPacket (even
tho' you'd expect that, given their names), but they ARE related.
ChannelDataPack et DOES have a conversion operator to convert itself to
a DataPacket, however (see below). I've found two work-arounds:

#1: Call the cast operator explicitly:

return result.operator omiDataPacket() ;

#2: Explicitly cause the cast operator to be called by adding code:

DataPacket dp;
dp = result;
return dp;

I have two objections to both of these workarounds: a) If it won't
work as written, what's the point in having a cast operator? and b)
This is done in about 150 different places in 70 different classes.
That's just way too much typing for someone as lazy as I am.
Questions:

- Is this a known problem with VC++? I've looked in the MS knowledge
base and found nothing, but I might be looking for the wrong thing.

- Is there some way of getting the VC++ compiler to notice (and use)
the cast operator without having to inflict a MS-specific kludge all
over the code?
Thanks!
Code:

//---------------------------------------------
// The Envelope to be wrapped around a Letter.
//---------------------------------------------
class EnvelopeBase
{
public:
virtual ~EnvelopeBase() ;
EnvelopeBase();
EnvelopeBase(Le tter::WriteAndC opyModeType wcm);
EnvelopeBase(co nst EnvelopeBase& from);
EnvelopeBase& operator=(const EnvelopeBase& rhs);
};
template < class T >
class Envelope : public EnvelopeBase
{
public:
virtual ~Envelope();
Envelope();
Envelope( const Envelope& );
Envelope( Letter& letter );

Envelope& operator=( const Envelope& );
T* operator->();
const T* operator->() const;
};

//---------------------------------------------
// Letter - What gets put inside an Envelope.
//---------------------------------------------
class Letter
{
public:
enum WriteAndCopyMod eType { ValueImmediate, ValueDelayed,
Pointer };
enum ExemplarType { exemplar };
virtual ~Letter();
Letter();
Letter( const String& );
Letter( const Letter& );

protected:
friend class Envelope< Letter >;
};
//---------------------------------------------
// DataPacketLette r - the data we're interested in.
//---------------------------------------------
class DataPacketLette r : public Letter
{
public:
virtual ~DataPacketLett er();
DataPacketLette r();
DataPacketLette r( const DataPacketLette r& );
DataPacketLette r( ExemplarType );
DataPacketLette r( const String& );

protected:
DataPacketLette r( const String&, ExemplarType );
};
//---------------------------------------------
// DataPacket - the data we're interested in, wrapped in an Envelope.
//---------------------------------------------
class DataPacket : public Envelope< DataPacketLette r >
{
public:
virtual ~DataPacket();
DataPacket();
DataPacket( const Envelope< DataPacketLette r >& from );
DataPacket( const DataPacket& from );
DataPacket( Letter& letter );
DataPacket& operator=( const DataPacket& rhs );
operator DataPacketLette r&() const;
};


//---------------------------------------------
// ChannelDataPack et(Letter) - the data we're interested in, wrapped &
unwrapped.
//---------------------------------------------
class ChannelDataPack etLetter : public DataPacketLette r
{
public:
virtual ~ChannelDataPac ketLetter();
ChannelDataPack etLetter();
ChannelDataPack etLetter( int theInitialSize );
ChannelDataPack etLetter( const ChannelDataPack etLetter& );
ChannelDataPack etLetter( ExemplarType );
ChannelDataPack etLetter( const String& );
};
class ChannelDataPack et : public Envelope< ChannelDataPack etLetter >
{
public:
virtual ~ChannelDataPac ket();
ChannelDataPack et();
ChannelDataPack et( float theValue );
ChannelDataPack et( const ChannelDataPack et& theOriginal );
ChannelDataPack et( Letter& letter );
ChannelDataPack et& operator=( const ChannelDataPack et& theRhs );
ChannelDataPack et& operator=( const float& theRhs );
operator ChannelDataPack etLetter&() const;
operator DataPacket() const;
operator float() const;
};