«

I've got a pile of code that won't compile for me, and can't figure out
why. I'm either making a template / friend / operator overloading
mistake (most likely - & why I'm asking here), or I'm using something
not supported by g++ 2.96 (less likely).

The big picture: I'm writing a wrapper class template that is supposed
to wrap around a primitive data type so that I can send myself
notifications whenever some code changes that data type (i.e. read from
or write to). My idea was a wrapper that overloads the operator=()
function. Works great, except for assigning with operator=(int,
wrapper) which doesn't compile. Demonstration code attached (somewhat
long, but all the relevant functions are there). Demonstration code
runs as is right now... there are three commented-out sections dealing
with the one friend function that I need to get compiling.

Can anyone tell me what I'm doing wrong? The g++ error message is:
operator=(base_t&, const notify_wrapper<base_t>)&) must be a
nonstatic member function
and I don't feel that it has to be - this is an external helper function
for when I want to do: (base_t) = wrapper<base_t>. And since base_t is
a primitive type, I can't add this as a member function.

(code follows as attachment)

-Kevin


#include <iostream>

class wrapper_listener
{
public:
virtual void written_to(void) {cout << "written" << endl;}
virtual void read_from(void) {cout << "read" << endl;}
};

template <typename base_t>
class notify_wrapper
{
public:
notify_wrapper() {}
~notify_wrapper() {}

public:
operator base_t ();

notify_wrapper<base_t>& operator=
(const notify_wrapper<base_t>& rhs);

notify_wrapper<base_t>& operator=
(const base_t& rhs);

/*
friend
void operator=<base_t>
(base_t& lhs, const notify_wrapper<base_t>& rhs);
*/

private:
base_t base;

public:
static wrapper_listener* listener;
};

/*
template <typename base_t>
void operator=
(base_t& lhs, const notify_wrapper<base_t>& rhs);
*/

template <typename base_t>
notify_wrapper<base_t>:perator base_t
()
{
return this->base;
}

template <typename base_t>
notify_wrapper<base_t>&
notify_wrapper<base_t>:perator=
(const notify_wrapper<base_t>& rhs)
{
base = (base_t) rhs.base;
if(rhs.listener) rhs.listener->read_from();
if(listener) listener->written_to();
}

template <typename base_t>
notify_wrapper<base_t>&
notify_wrapper<base_t>:perator=
(const base_t& rhs)
{
base = rhs;
if(listener) listener->written_to();
return *this;
}
/*
template <typename base_t>
void //disallow future assignments!
:perator=
(base_t& lhs, const notify_wrapper<base_t>& rhs)
{
lhs = (base_t) rhs.base;
if(listener) listener->read_from();
}
*/

wrapper_listener* notify_wrapper<int>::listener;

int main()
{
int i;
wrapper_listener wrapper;
notify_wrapper<int> tester;
notify_wrapper<int>::listener = &wrapper;
tester = 5;
i = tester;

return 0;
}

Victor Bazarov wrote:
> Please do not post attachments in this newsgroup. If you need
> to post code, copy and paste it into the message. However,
> before you do that, please, read the FAQ 5.8.
Ironically enough, I managed to read the FAQ and distill out a sample
file without seeing the no-attachments part. Foolish of me.

Alas, here is the file, copy-and-pasted. I have beeen attempting to
compile it with g++ 2.96, simply with "g++ test.cc"

-Kevin
=================================================
#include <iostream>

class wrapper_listener
{
public:
virtual void written_to(void) {cout << "written" << endl;}
virtual void read_from(void) {cout << "read" << endl;}
};

template <typename base_t>
class notify_wrapper
{
public:
notify_wrapper() {}
~notify_wrapper() {}

public:
operator base_t ();

notify_wrapper<base_t>& operator=
(const notify_wrapper<base_t>& rhs);

notify_wrapper<base_t>& operator=
(const base_t& rhs);

/*
friend
void operator=<base_t>
(base_t& lhs, const notify_wrapper<base_t>& rhs);
*/

private:
base_t base;

public:
static wrapper_listener* listener;
};

/*
template <typename base_t>
void operator=
(base_t& lhs, const notify_wrapper<base_t>& rhs);
*/

template <typename base_t>
notify_wrapper<base_t>:perator base_t
()
{
return this->base;
}

template <typename base_t>
notify_wrapper<base_t>&
notify_wrapper<base_t>:perator=
(const notify_wrapper<base_t>& rhs)
{
base = (base_t) rhs.base;
if(rhs.listener) rhs.listener->read_from();
if(listener) listener->written_to();
}

template <typename base_t>
notify_wrapper<base_t>&
notify_wrapper<base_t>:perator=
(const base_t& rhs)
{
base = rhs;
if(listener) listener->written_to();
return *this;
}
/*
template <typename base_t>
void //disallow future assignments!
:perator=
(base_t& lhs, const notify_wrapper<base_t>& rhs)
{
lhs = (base_t) rhs.base;
if(listener) listener->read_from();
}
*/

wrapper_listener* notify_wrapper<int>::listener;

int main()
{
int i;
wrapper_listener wrapper;
notify_wrapper<int> tester;
notify_wrapper<int>::listener = &wrapper;
tester = 5;
i = tester;

return 0;
}

"Kevin Christopher" <> wrote...
> Victor Bazarov wrote:
> > Please do not post attachments in this newsgroup. If you need
> > to post code, copy and paste it into the message. However,
> > before you do that, please, read the FAQ 5.8.
> Ironically enough, I managed to read the FAQ and distill out a sample
> file without seeing the no-attachments part. Foolish of me.
>
> Alas, here is the file, copy-and-pasted. I have beeen attempting to
> compile it with g++ 2.96, simply with "g++ test.cc"

(a) Having read the FAQ you still managed to follow the first
6 key guidelines but for some reason decided to ignore #7,
which IMHO is the most important. If you receive compiler
diagnostic, what is it? I don't have your compiler, nor do
I have your OS or anything else the compilation may depend
on. So, I cannot answer your inquiry. Neither can many of
other regulars here. Well, of course, I exaggerate a bit,
but still...

(b) Why are you using such an ancient compiler? Is there any
legitimate reason for you not to upgrade to something at
least a bit more Standard-compliant?

(c) In your code, add "using namespace std;" after the first line
(it may not help with g++ v2.96, but it will make your code
closer to legal C++).

(d) Add
template<class T> wrapper_listener* notify_wrapper<T>::listener;
before line 84.

(e) Line 85 (former 84) should look like this:
template wrapper_listener* notify_wrapper<int>::listener;

That should do it.

Victor

On Tue, 01 Jul 2003 15:29:24 -0700, Kevin Christopher
<> wrote:

> /*
> friend
> void operator=<base_t>
> (base_t& lhs, const notify_wrapper<base_t>& rhs);
> */

operator= has to be a member function according to the C++ standard.
You need:

friend base_t& base_t:perator=(const notify_wrapper<base_t>& rhs);

Obviously, this won't work for built in types - you can't override the
meaning of assignment for built ins, which is a reasonable
restriction. You'll have to rethink your design.

Tom