Operator ambiguity

Yeah, the problem is that the compiler has the choice of using your subscript operator, or implicitly converting to float* and then using the built-in subscript operator. This is why typecast operators are generally a really, really bad idea.

What are you trying to do here? Why do you want to convert to a float*?

---

How appropriate. You fight like a cow.

Don''t provide an implicit operator to float. If you want an easy way to call glVertex3fv with your vector class, you should make an overloaded version:


You can do the same for whatever else you needed to cast to float* for.

Maybe your overloaded operator[] should return a reference instead?

sneftel: the reason i''m using explicit cast operator is coz i''m using it in a vector math class. the vector parameters are defined as a union of 4 float parameters, public too. now it is already convenient to access the values as x,y,z OR v[0...2].

i just wanted to overload the index operator[] in case i REALLY get lazee but the cast operator comes in handy in case i want to directly cast the vector into an array of floats:

without my intended approach:

float *list = vectorTemp.v; OR
float *list = &vectorTemp.x

with my intended approach:

float *list = (float*)vectorTemp;

it felt simpler for me to work with the casting way, though i think it is slower. anyway, it was also because i wanted to learn a bit about operator overloading. guess i got carried away. i scrapped the casting operator though.. found the index operator more useful.

cgoat: ur suggestion doesn''t work coz the issue doesnt seem to be with return type. in fact wat boggled me initially is y does ambiguity even exist when the parameter list for the operators differ.

using the operator[] REQUIRES an index integral, but the cast doesnt need. so y does msvc go through all the trouble of trying to do implicit casting before indexing instead of simply using my self-made operator. kinda irritating when the compiler stops listening to you.. grrr