can cause problems with many compilers due to the way it
interprets the C++ standard. I removed the const
operators from my class and it seems to be working fine
now.
-----Original Message-----
I have C++ code that has been running just fine in VS6 fora couple of years. I brought it into VS.NET with managed
extensions turned off and it compiles/links just fine,
however I get access violations at runtime. The code in
question is basically a smart pointer which has the type
cast operators overloaded. There is both a non-const and
const operator defined. The non-const type cast works,
the const type cast does not. I am including a simple
example that exhibits the same behavior. Thanks in
advance for looking at this. I'm stumped.
#include "stdafx.h"
#include <string>
#include <iostream>
using namespace std;
//////////////////////////////////////////
//////////////////////////////////////////
class Foo
{
public:
Foo();
Foo(const Foo& foo);
string Name() const;
void Name(string name);
private:
string name_m;
};
Foo::Foo()
{
name_m = "";
}
Foo::Foo(const Foo& foo)
{
name_m = foo.Name();
}
string Foo::Name() const
{
return name_m;
}
void Foo::Name(string name)
{
name_m = name;
}
//////////////////////////////////////////
//////////////////////////////////////////
class Bar
{
public:
Bar();
Bar(const Bar& bar);
string Name() const;
void Name(string name);
private:
string name_m;
};
Bar::Bar()
{
name_m = "";
}
Bar::Bar(const Bar& bar)
{
name_m = bar.Name();
}
string Bar::Name() const
{
return name_m;
}
void Bar::Name(string name)
{
name_m = name;
}
//////////////////////////////////////////
//////////////////////////////////////////
class FooBar
{
public:
FooBar();
void SetFoo(Foo& foo);
void SetBar(Bar& bar);
operator Foo& () const;
operator const Foo& () const;
operator Bar& () const;
operator const Bar& () const;
private:
Foo* foo_m;
Bar* bar_m;
};
FooBar::FooBar()
{
foo_m = NULL;
bar_m = NULL;
}
void FooBar::SetFoo(Foo& foo)
{
foo_m = new Foo(foo);
}
void FooBar::SetBar(Bar& bar)
{
bar_m = new Bar(bar);
}
FooBar::operator Foo& () const
{
return *foo_m;
}
FooBar::operator const Foo& () const
{
return *foo_m;
}
FooBar::operator Bar& () const
{
return *bar_m;
}
FooBar::operator const Bar& () const
{
return *bar_m;
}
//////////////////////////////////////////
//////////////////////////////////////////
int _tmain(int argc, _TCHAR* argv[])
{
Foo foo;
Bar bar;
foo.Name("foo");
bar.Name("bar");
cout << "foo.Name() = " << foo.Name() << endl;
cout << "bar.Name() = " << bar.Name() << endl;
FooBar fooBar;
fooBar.SetFoo(foo);
fooBar.SetBar(bar);
cout << "((Foo&)fooBar).Name() = " << ((Foo&)
fooBar).Name() << endl;
cout << "((Bar&)fooBar).Name() = " << ((Bar&)
fooBar).Name() << endl;
cout << "((const Foo&)fooBar).Name() = " << ((const
Foo&)fooBar).Name() << endl;
cout << "((const Bar&)fooBar).Name() = " << ((const
Bar&)fooBar).Name() << endl;
return 0;
}
.