Assigment operator and container of base type

[Adrian]

Below is an example of the problem I am having. I don't understand how
I can get the compiler to see deriv &operator=(cons t T &rhs).

I am sure this is a common problem - any suggestions?
#include <iostream>
#include <vector>

struct base
{
virtual ~base()=0 {};
};

template<class T>
struct deriv : public base
{
deriv(): data_(0) {};
deriv(const T &data): data_(data) {};
deriv &operator=(cons t T &rhs) { data_=rhs; return (*this); }
deriv &operator=(cons t deriv &rhs)
{ data_=rhs.data_ ; return (*this); }
T data_;
};

struct container
{
base &operator[](int i) { return *(data_[i]); };
std::vector<bas e *data_;
};

void fill_cont(conta iner &data);

int main(int argc, char *argv[])
{
container data;
fill_cont(data) ;

std::cout << "data[0]=" << typeid(data[0]).name() << std::endl;
// output: data[0]=struct deriv<int>
data[0]=12445;

std::cout << "data[1]=" << typeid(data[1]).name() << std::endl;
// output: data[1]=struct deriv<double>
data[1]=4.5667;

std::cout << "data[2]=" << typeid(data[2]).name() << std::endl;
// output: data[2]=struct deriv<char *>
data[2]="test";

return 0;
}

void fill_cont(conta iner &data)
{
data.data_.push _back(new deriv<int>());
data.data_.push _back(new deriv<double>() );
data.data_.push _back(new deriv<char *>());
}

--

Adrian

Think you know a language? Post to comp.lang... and find out!

[Robert Bauck Hamar]

Adrian wrote:

Ondra Holub wrote:

>In container::oper ator[] you are returning reference to base. But there
is no assignment operator in class 'base', so compiler cannot see it.

Should be. The compiler should generate one by default.

Surely. base& base::operator= (const base&) is declared by default. Remarks:

1. It does not match the signature of deriv<T>& deriv<T>::opera tor=(const
T&)
2. It is not virtual.

1 Means that when the comiler searches base (static type of lhs in
assignment) for operator=, it cannot see any operator= taking a T, even
though the dynamic type of lhs has one.

2 Means that even if the signatures had matched, the compiler would
statically link to base::operator= . Example of latter:

#include <iostream>

using namespace std;

struct foo {
virtual foo& operator =(const foo&) {
cout << "foo\n";
return *this;
}
};

struct bar : foo {
bar& operator=(const foo&) {
cout << "bar\n";
return *this;
}
};

int main() {
foo f;
bar b;

foo & fb = b;

f = f;
b = b;
fb = b;
}

Delete the virtual kw in foo, and see how output changes.

--
Robert Bauck Hamar
Der er to regler for suksess:
1. Fortell aldri alt du vet.
- Roger H. Lincoln