Thread: Vector of Structure

I went ahead and added the constructors:

Code:

struct IntStr
{
    int i;
    IntStr(int x):    i(x)    {}

    string s;
    IntStr(const char* y):    s(y)    {}

    vector<IntStr> v;
};

int main()
{
    IntStr temp;
    temp.i = 123;
    temp.s = "abc";
    temp.v.push_back(789);
    temp.v.push_back("xyz");
}

Now, if I don't have

Code:

IntStr(int x):    i(x)    {}

and

Code:

IntStr(const char* y):    s(y)    {}

then the compiler complains at temp.v.

If I do have them, then
the compiler says
no matching function for call to `IntStr::IntStr()'
candidates are: IntStr::IntStr(const IntStr&)
IntStr::IntStr(const char*)
IntStr::IntStr(int)
at

Code:

IntStr temp;

This is confusing

Yeah but I'm still learning things though. I'm a C++ programmer since I use C++, but I never said I was good at it.
I just take notes as I go along

Is there a way to do this:

Code:

#include <iostream>
#include <string>
#include <vector>
using namespace std;

struct IntStr
{
    IntStr() {}       

    int i;
    IntStr(int ii):  i(ii)  {}

    string s;
    IntStr(const char* ss):  s(ss)  {}
    
    vector<IntStr> v;
    IntStr(vector<IntStr> vv):  v(vv)  {}
};

int main()
{
    IntStr temp; //works
    
    temp.i = 123; //works
    cout << temp.i << endl; //works

    temp.s = "abc"; //works
    cout << temp.s << endl; //works

    temp.v.push_back(123789); //works
    temp.v.push_back("abcxyz"); //works
    cout << temp.v.size() << endl; //outputs 2 (proof that v is holding the two elements)

    //cout << temp.v.at(0) << endl; //Compiler complains here
    //cout << temp.v.at(1) << endl; //Compiler complains here

}

Thanks

I wonder if what you really want is a structure that involves a union. Because it seems like sometimes you want a specific item in the vector to be a string, and at other times an int.

Can it be done with a union?

I was using struct because I noticed the compiler did not complain by doing

Code:

    vector<IntStr>

before the struct IntStr was completed.
I thought this self-reference would allow me to use vectors of both int and string by defining the int and string inside of the struct.

In order to overload <<
would I do something like this:

Code:

IntStr operator<<(const int index) //index number with associated element
{
	return v.at(index);
}

Originally Posted by CPlus

I thought this self-reference would allow me to use vectors of both int and string by defining the int and string inside of the struct.

When you chose to use a structure, you're saying you needed both the int and the string version. Hence when you push back something to the vector, it should be the whole structure, not just an integer or just a string.

I'm saying you could do something like:

Code:

class IntStr
{
    public:
    IntStr (const char* init)
    {
        SetString (init);
    }

    IntStr (int init)
    {
        SetInt (init);
    }

    IntStr ()
    {
        mTypeInfo = UNION;
    }

    bool GetString (const char *&retval)
    {
        if (mTypeInfo == STRING)
        {
            retval = mIntStr.mStr;
            return false;
        }
        else if (mTypeInfo == INTEGER)
        {
            std::ostringstream conv;
            conv << mIntStr.mInt;
            if (conv)
            {
                SetString (conv.str().c_str());
                retval = mIntStr.mStr;
                return false;
            }
            else
            {
                return true;
            }
        }
        else
        {
            return true;
        }
    }

    bool GetInt (int &retval)
    {
        if (mTypeInfo == INTEGER)
        {
            retval = mIntStr.mInt;
            return false;
        }
        else if (mTypeInfo == STRING)
        {
            std::istringstream conv;
            conv.str(mIntStr.mStr);
            int temp;
            conv >> temp;
            if (conv)
            {
                SetInt (temp);
                retval = mIntStr.mInt;
                return false;
            }
            else
            {
                return true;
            }
        }
        else
        {
            return true;
        }
    }

    void SetString (const char *init)
    {
        mTypeInfo = STRING;
        mIntStr.mStr = init;
        return ;
    }

    void SetInt (int init)
    {
        mTypeInfo = INTEGER;
        mIntStr.mInt = init;
        return ;
    }

    private:

    typedef enum { INTEGER, STRING, UNION } MyType;
    MyType mTypeInfo;

    union IntStrTag {
        const char *mStr;
        int mInt;
    }
    mIntStr;
};

The union comment was more of a source of inspiration, considering the way you want your object to behave. Actually using a union here would be bothersome, as unions cannot contain objects, so you would have to manage a char* string.

Rather, have your object contain both a string and an int, and have an interface like this one, Let the object treat its value like an int or a string at any given time, just like a union.

Thanks, it works WhiteFlags.

How do I use the << operater on the IntStr type?

I tried this:

Code:

IntStr IntStr::operator<< (IntStr argument)
{
    return argument;
}

It fails, but aside from that, the compiler did not complain at the following declarations

Code:

    IntStr number;
    number = 123;
    IntStr letter;
    letter = "abc";

Oh and I'm just testing different ways of doing things.
I do remember about LaserLight's suggestion of Boost::Variant.

Thanks.

Would it look something like this?

Code:

ostream &operator<<(ostream &output, IntStr intstr)
{
    if (mTypeInfo == INTEGER)
        output << intstr.mInt;
    elif (mTypeInfo == STRING)
        output << intstr.mStr;
    return output;
}

istream &operator>>(istream &input, IntStr intstr)
{
    if (mTypeInfo == INTEGER)
        input >> intstr.mInt;
    elif (mTypeInfo == STRING)
        input >> intstr.mStr;
    return input;
}

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?

Is the operator>> incorrect because of the reference (&) before it?
istream input instead of istream &input ?

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.