Register to reply

Is this ANSI C++?

by Hurkyl
Tags: ansi
Share this thread:
Hurkyl
#1
Oct15-05, 02:40 PM
Emeritus
Sci Advisor
PF Gold
Hurkyl's Avatar
P: 16,098
Allow me to present a simplified version of what I'm doing: (yes, I have a reason to do this. )

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++?
Phys.Org News Partner Science news on Phys.org
Sapphire talk enlivens guesswork over iPhone 6
Geneticists offer clues to better rice, tomato crops
UConn makes 3-D copies of antique instrument parts
ComputerGeek
#2
Oct15-05, 02:59 PM
P: 534
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
#3
Oct15-05, 05:13 PM
P: 19
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; }

Hurkyl
#4
Oct15-05, 05:28 PM
Emeritus
Sci Advisor
PF Gold
Hurkyl's Avatar
P: 16,098
Is this ANSI C++?

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
#5
Oct15-05, 05:32 PM
Emeritus
Sci Advisor
PF Gold
Hurkyl's Avatar
P: 16,098
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
#6
Oct15-05, 05:35 PM
P: 19
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
#7
Oct15-05, 05:37 PM
P: 19
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
#8
Oct15-05, 08:55 PM
P: 1,373
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
#9
Oct16-05, 06:07 AM
Emeritus
Sci Advisor
PF Gold
Hurkyl's Avatar
P: 16,098
Because it's nice to have code that relies only on defined behavior. This isn't solely for personal use -- I expect others to be able to use this as well.
dduardo
#10
Oct16-05, 08:29 AM
Emeritus
dduardo's Avatar
P: 1,919
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
#11
Oct16-05, 08:43 AM
Emeritus
Sci Advisor
PF Gold
Hurkyl's Avatar
P: 16,098
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
#12
Oct16-05, 08:44 AM
Emeritus
Sci Advisor
PF Gold
Hurkyl's Avatar
P: 16,098
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
#13
Oct26-05, 03:50 PM
P: 28
// 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
#14
Oct26-05, 06:13 PM
Emeritus
Sci Advisor
PF Gold
Hurkyl's Avatar
P: 16,098
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
#15
Oct26-05, 10:44 PM
P: 678
Quote Quote by Hurkyl
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
#16
Oct29-05, 07:17 AM
P: 28
Quote Quote by Hurkyl
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


Register to reply

Related Discussions
Military Standards / ANSI / Mil Spec Mechanical Engineering 9
Lets talk all about ANSI C Programming & Computer Science 6