Is this ANSI C++?

Hurkyl

Staff Emeritus
Gold Member
Allow me to present a simplified version of what I'm doing: (yes, I have a reason to do this. :tongue2:)

Code:
class wrapper
{
private:
int &v;
public:
wrapper(int &value):v(value) {}
wrapper& operator=(int value) {
v = value;
return *this;
}

// This is the questionable bit:
operator wrapper&() { return *this; }
};

wrapper make_wrapper(int &value)
{
return wrapper(value);
}

template <typename T>
void foo(T &t)
{
t = 1;
}

int main()
{
int x;
foo(make_wrapper(x));
}
To summarize:

I wish to create a class that acts as a reference type.
I would like to be able to pass my custom reference type into any template function that expects an actual reference.

But here's the problem: C++ doesn't let you make a non-constant reference to a temporary object.

Since it would be rather painful for me to overload every function I might ever want to call to take any combination of the reference types I'm writing, and for every function I develop to have multiple versions, I would like a more automatic approach.

Thus, I provided a conversion into (wrapper&). g++, at least, is happy with it.

Is this valid C++?

ComputerGeek

hmmm... well, if gcc has no issues with it then it must work ok. I know gcc is not yet perfect with respect to the ANSI standard, but oh well.

dmail

Code:
class wrapper
{
private:
int &v;
public:
wrapper(int &value):v(value) {}
wrapper& operator=(int value) {
v = value;
return *this;
}
// This is the questionable bit:
operator wrapper&() { return *this; }
};
wrapper make_wrapper(int &value)
{
return wrapper(value);
}
template <typename T>
void foo(T &t)
{
t = 1;
}
int main()
{
int x;
foo(make_wrapper(x));
}
To summarize:
[/QUOTE]

operator wrapper&() { return *this; }
i dont understand this, can you return an operator?(not that i know of) if you can the this pointer is a pointer to a class and not an operator.
maybe you mean
wrapper operator&(){ return *this; }

Last edited:

Hurkyl

Staff Emeritus
Gold Member
operator wrapper& is a conversion operator, like operator int, or operator char. It allows you to convert an object of type wrapper into an object of type wrapper&

Hurkyl

Staff Emeritus
Gold Member
hmmm... well, if gcc has no issues with it then it must work ok. I know gcc is not yet perfect with respect to the ANSI standard, but oh well.
I'm mainly worried if the behavior is undefined, so that I can't expect it to work in general. =(

dmail

hmmm i havnt seen this before an cant seem to find anything in stroustrup's book have to got a link to an example or something please thanks.

dmail

hmmm i havnt seen this before an cant seem to find anything in stroustrup's book have to got a link to an example or something please thanks.

edit.
hmmm now i see, sorry about that

neurocomp2003

dmail try looking under type casting...cuz thats what your basically doing

you can overload int and double's i believe...i use the typdef double REAL

and you can basically do (REAL*)vector...to get teh ntuple outta class vector.
so if you store an array in teh class
you can do operator REAL*() { return _a; } where _a is teh array. and thus you leave out the remainder of the class.

why do you need ansi standards hurkyl...can't you test it out on your compiler?

Hurkyl

Staff Emeritus
Gold Member
Because it's nice to have code that relies only on defined behavior. :tongue2: This isn't solely for personal use -- I expect others to be able to use this as well.

Last edited:

dduardo

Technology Mentor
Staff Emeritus
If you compile with gcc you can pass the -ansi parameter and it force the standard. You may also need to use the __STRICT_ANSI__ macro.

Hurkyl

Staff Emeritus
Gold Member
Well, I suspect the syntax is valid, I'm more worried about the semantics -- whether I can be guaranteed that my object will live while I pass the reference around... -ansi doesn't guarantee me that, does it?

Hurkyl

Staff Emeritus
Gold Member
Oh wait... I figured out how I can figure this out. I just need to make the destructor do something... gcc will surely put the destructor call exactly where it's supposed to go, right? Or is gcc allowed to wait for a more convenient time?

dpm

Code:
// This is the questionable bit:
operator wrapper&() { return *this; }
What exactly is this operator returning? It's currently untyped.
Other than that, returning *this is perfectly fine, IIRC. You just need to make sure that you don't access the memory after your object has been deleted.

I wish to create a class that acts as a reference type.
Unless this is just for fun, check out the boost library. There's a few classes in there that do exactly this sort of thing, and you can look at the source to see how they did it, too.

Hurkyl

Staff Emeritus
Gold Member
What exactly is this operator returning? It's currently untyped.
It's a conversion operator, syntactically no different than saying operator int(): it says that the compiler may use this operator to implicitly convert anything of type wrapper into one of type wrapper&.

You just need to make sure that you don't access the memory after your object has been deleted.
Right, and my big question is when it gets deleted! I've since run my experiment, and it seems that the lifetime of the temporary is sufficiently long for my purposes (assuming that the compiler called the destructor at the earliest legal opportunity).

Unless this is just for fun, check out the boost library. There's a few classes in there that do exactly this sort of thing, and you can look at the source to see how they did it, too.
Which classes in particular?

master_coda

Hurkyl said:
Oh wait... I figured out how I can figure this out. I just need to make the destructor do something... gcc will surely put the destructor call exactly where it's supposed to go, right? Or is gcc allowed to wait for a more convenient time?
Destructors are called deterministically. When a stack-based object goes out of scope, its destructor is called immediately.

I think what you're doing is undefined behaviour. Your operator wrapper& is fine, but I don't think it's valid to return a reference to a temporary; I think that the temporary is created on the stack, and so any reference to it becomes invalid as soon as make_wrapper returns. I'm not sure, though. It's been a while since I had to think about the object creation rules in C++.

dpm

Hurkyl said:
It's a conversion operator, syntactically no different than saying operator int(): it says that the compiler may use this operator to implicitly convert anything of type wrapper into one of type wrapper&.
Yes, I know that. I just got mixed up and thought that it should be explicitly stated that it is returning something. Apparently conversion operators don't have to have an explicitly stated return type.

Which classes in particular?
http://www.boost.org/libs/smart_ptr/smart_ptr.htm" [Broken]

Last edited by a moderator:

The Physics Forums Way

We Value Quality
• Topics based on mainstream science
• Proper English grammar and spelling
We Value Civility
• Positive and compassionate attitudes
• Patience while debating
We Value Productivity
• Disciplined to remain on-topic
• Recognition of own weaknesses
• Solo and co-op problem solving