dfoster@jarthur.Claremont.EDU (Derek R. Foster) (09/19/90)
A question from a very frustrated semi-novice C++ programmer:
Is there any way to change the variable referenced by a reference variable
after the reference variable has been initialized?
In particular, I have a class which is passed a reference to a target
variable which it is to modify. I would like to be able to simply
declare a class member variable which would be a reference to the
target variable, thus allowing my class member operations to access
the target variable as if it was simply a member variable. In other words,
I would like to be able to 'forget' that the target variable is actually
external to the particular class object which has been told to modify it,
except for in the routines which change to a new target. This seems like
a perfectly legitimate use of a reference variable, and would work quite
nicely if I was able to specify the target variable at the time a class
object was constructed. Unfortunately, I can't. For example,
class targetclass;
class targetmodifyer
{
targetclass& targ; // a reference variable
targetclass default; // a default 'internal' target
targetmodifyer() : targ(default) {}; // initialize the variable to
// point to the default
// target
modify() {targ.dosomething();}; // modify the target variable
// in some way
newtarget(targetclass& T) { ??????????? }; // but what do I do here?
// I want to re-initialize
// targ to now reference T,
// but how?
};
void main(void)
{
targetclass targ1; // a target
targetmodifyer mod1(); // set up a target modifyer to use
// an internal target
mod1.modify(); // modify the internal target
mod1.newtarget(targ1); // use the second target now
mod1.modify(); // modify the second target
}
My question is this: what do I put in place of ???????? ?
What I would _LIKE_ to be able to do is something like:
((targetclass &) targ) = newtarget; // set targ to point to a new target
but this doesn't work due to C++'s semantic rules. (It is interpreted as
'(targetclass) targ = newtarget' apparently, and results in a call to
targetclass::operator = () which is not what I want.) I've tried all sorts of
bizarre type casts to try to make the compiler understand that I want to
change _what_ targ references instead of changing the value of the thing that
targ references, but C++ steadfastly refuses to understand me. It also
refuses to let me initialize targ a second time (i.e. 'targ(newtarget)')
except in the context of a base class initializer (see kludge #2, below).
I have tried all sorts of ways to do this and have come up with a few kludges
but no really good way. I have scanned the Turbo C++ manual nearly from
cover to cover and have found no reference of doing this, either "it can
be done like so...", or "it can't be done."
Incidentally, my specific application is that 'targetclass' is a string
object (dynamically allocated, supports str1 = str2 + str3, etc.) and
'targetmodifyer' is a set of routines and variables which allow the user to
edit a string on the screen, in color, performing validity checks, etc.
Just for reference, the kludges I have found are:
1) Declare targ as a pointer to targetclass, then every time I reference
what it points to, use indirection operators (ie. targ->dosomething()).
There are two reasons I don't want to do this: (1) My class 'targetclass'
has a bunch of overloaded operators, and it really looks ugly to have
to call '(*targ)[something]' or '(*targ) += x', etc. when I know that
I ought to be able to just say 'targ[something] and targ += x. (2)
besides looking ugly, this makes my code almost unreadable. I went to
a great deal of trouble to make my targetclass's operations simple and
self-documenting so that they could be used in complex expressions and
still be clear. If in my targetmodifyer I have to explicitly dereference
them every time they are used, add extra parentheses, etc., I will
turn relatively straightforward expressions into nightmarish tangles
that I'm not sure even _I_ understand.
2) Declare a private dummy constructor which takes an argument of type
(targetclass *) and which uses its base-class initialization list to
set targ to reference the thing pointed to by the argument. Then call
this constructor from newtarget(). This works, but seems quite kludgy
since (1) I am calling a constructor from within a member function,
(2) It isn't really a constructor. It is just phrased that way to make
C++ happy, (3) Why do I need to make an extra function call anyway?
(4) what if I need several variables like this? (5) What if I already have
a constructor which takes a (targetclass *)? etc. Nonetheless, this is
the method I am currently using, for want of a better one.
Can anybody help? Is there a "nice" way to reroute a reference variable?
Any and all help would be appreciated.
Thanks!
Derek Riippa FosterJeanYves.Cras@cediag.bull.fr (Jean-Yves Cras) (09/19/90)
I currently have the same problem as you. However, not for the same purpose.
The point is that I want to define a class - say CLASS - and quite a lot
of functions that will receive arrays of references to CLASS as argument.
So I wish I could write:
class CLASS { ... };
void foo(CLASS&* p) { ... } // illegal; wonder why
main()
{
CLASS tab[10];
CLASS& tref[3];
for ( int i = 0; i < 3; i++)
tref[i] ??????? tab[i*2]; // re_referencing operator
f(tref);
}
This doesnot work because
1) Cannot declare pointers/references to references; and
2) lack a re_referencing operator.
Of course, using pointers fixes the problem but...
Anyway, I will certainly not refrain from using your #2 kludge until something cleaner is exhibited !