Thread: Vector of Structure

I just looked up a tutorial and saw

"These [operator] functions return a reference to the stream object so that these operators can be chained together ( e.g. cout << "the answer is" << i << endl; )"

Should I put references on the intstr object?

Code:

ostream &operator<<(ostream &output, IntStr &intstr)

and

Code:

istream &operator>>(istream &input, IntStr &intstr)

?

Thanks

Since it's outside the class, obviously you must specify the instance of whose member you are referring to. Yes, they should be outside the class and friends.

Yes, it is incorrect because it lacks a reference. Also add references to << and use const correctness. Otherwise you cause unnecessary overhead.

typeid would only see your struct, not what it contains. And typeid is bad anyway. Plus what the name() returns is not standard either, so it's unportable, as well.

Originally Posted by CPlus

Oh I was hoping to relate to the mTypeInfo within the class. Overloading operators must be done outside of the class and referred to with friend, right?

If I ignored inputs for now, how could I make it so that it outputs a string or int within the union depending on the type?
Would I use
typeid().name()
or would that simply return a union type?

Thanks.

If I could have used run time type identification on a union, I would have, but you won't get what you want. The union interprets the same area of memory as a value of some type, depending on the member you access. This means that if the expression of typeid is the union variable, it will be of union type, if you access mInt, for example, it will be interpreted as an int even if it doesn't make sense. Hence, we make the internal representation private and keep track of the type ourselves.

If you must have stream operators, then I would define a public access method that returns the type information someway. I don't use idioms when they don't work for me, though.

Now why return a string with its type, though? Why wouldn't an integer value be better?
Is there also not a typo in your code? You're lacking one "?". I'd also make it a switch seeing as it nests two ifs. But that's a style issue.

I get a run-time error starting at 'cout'. I think I messed up the I/O again

Your code for this is:

Code:

istream& operator >> (istream &input , IntStr &intstr)
{
    input >> intstr;
    return input;
}
ostream& operator << (ostream &output , const IntStr &intstr)
{
    output << intstr;
    return output;
}

The way you did it before is closer to what you needed. When you write this kind of code you shouldn't send things to a stream that it doesn't know how to handle. That said, remember that I said I don't use idioms when they don't work for me?

You can already do this:

Code:

if (!sample.GetInt(foo)) cout << foo;

string bar;
cin >> bar;
/* copy bar to some new C string qux here */
if (!sample.SetString(qux)) /* do something */

A method that does this is not hard.

To see if I understand: a union type contains enough memory for each type it unifies and can be treated as any type at any time?
If not, do I have to specify which part of the memory I want inside the union to be represented at runtime? Or is this handled inside of the class?

As I said, we keep track of the type inside the class. The fact that you can treat a union as any one type it contains at a time is the idea. In an assignment, it will put the value in its memory, which is as big in size as the largest type it contains. If you don't manage it things will become mystified quickly.

Again, for the moment, IntStr does not clean up qux when it changes types or dies. This is also problem. Unions are basically something C++ shouldn't have, because they don't work with other objects, only plain data types. I even spoke against doing exactly this, but whatever I guess. Make sure IntStr deletes strings whenever it changes types or dies.

It should be self-explanatory that it is an int.
But this is getting awfully complicated. I really suggest you ditch this idea or use boost. You already have a solution for your needs. Use it.