STL Map Problem with user defined Class

I've a Class called Var which handles multiple basic datatypes like int, float, char, string etc..
that Class works file when I use it like this.

Code:

---

Var x = (Var)2;
cout<<x;

---

But When I made a map of string and var its going Crazy.

Code:

---

typedef vector<string>                        stringList;
typedef map<string, Var>                paramsMap;

int main(int argc, char *argv[]){
        paramsMap lst;
        lst["x"] = (Var)2;
        lst["y"] = (Var)5;
       
        for(paramsMap::iterator it=lst.begin();it != lst.end();it++){
                cout<<it->first<<" => "<<it->second<<endl;
        }

  return EXIT_SUCCESS;
}

---

The Above Should Output.

Code:

---

x => 2
x => 5

---

But whet its showing is.

Code:

---

x => y
y => 5

---

Here is my code for var.h and var.cpp
var.h
http://pastebin.com/m576e6998
var.cpp
http://pastebin.com/m57e02d88
toString()
http://pastebin.com/m788b6711

I'm taking a guess but your errors come from the fact you are building a (string) temporary in your constructors and then taking the pointer value of c_str() without making a copy of it (you are just storing the address). Once the temporary is destroyed, you find yourself with a dangling pointer.

That makes me say, you should use a std::string instead of a const char* to hold the "data". And don't forget to create a constructor for every built-in type or you'll have errors. Because this

Code:

---

const short s = 0;
Var x(s);

---

should yield an error.

I understood the problem that you have focused.
But Whats the solution if I store __data in char*

The problem is that you are assigning a pointer. There is one copy of the data in existance, which is deallocated when the std::string destructor is called.
What do you do? You make a copy. I'll leave it to you to figure out what you have to do to make that work.

so you mean something like this Right ??

Code:

---

char* __tmp = ::toString(val).c_str();
__data = __tmp;

---

No.
You are working with pointers and reassigning them. Perhaps a lesson on pointers will help?

Tutorial:
Name: "My data"
Address: XXXX
Data: "My data"

Name: Ptr1
Address: YYYY
Data: XXXX

Name: Ptr2
Address: ZZZZ
Data: XXXX

Name: Ptr3
Address: AAAA
Data: XXXX

Code:
char* Ptr2 = ::toString(val).c_str();
Ptr3 = Ptr2;

Generated Code:
Create Ptr2;
Create temporary std::string.
std::string::string(); // constructor
// Begin std::string::string():
Ptr1 = new char[...];
// End std::string::string():
std::string::c_str(); // Call to get pointer.
Ptr2 = return_value; // Assign returnvalue to Ptr2;
std::string::~string();
// Begin std::string::~string():
delete [] Ptr1;
// End std::string::~string():
Ptr3 = Ptr2;

Ptr1 is used internally by std::string.
Now std::string calls delete on Ptr1.

The result will be this:

Name: "My data"
Address: XXXX
Data: UNDEFINED

Name: Ptr1
Address: YYYY
Data: XXXX

Name: Ptr2
Address: ZZZZ
Data: XXXX

Name: Ptr3
Address: AAAA
Data: XXXX

So now Ptr2 and Ptr3 will all pointer to UNDEFINED, because you copied the address (the pointers) and not the data itself.

So how ?? I am totally Puzzled and frustrated. struggling with it for more than a week.
I am learning through this Programm.

See my tutorial above. Perhaps it can shed some light on what's happening.

What foxman tries to say is that the string you generate in toString is a temporary string. It ceases to exist when you leave the function calling toString. It does, however, still point at valid memory, and as long as you don't overwrite the string with something else (string or otherwise), it will still exist in memory.

You need to allocate a separate piece of memory and copy the string into that.

--
Mats

Ya I understood it as I told before just cant figure out the solution Correctly.

can it be solved by using bcopy()

No, you need to look up allocation functions (new/delete) and string copy functions (strcpy).

LOL Its 100 times simpler to use string as the datatype of __data.
and I realized that there is 0 profit if I keep it in char* type in this case . (Am I Right ??)
and Its also working well thus.
Thanks

>> and I realized that there is 0 profit if I keep it in char* type in this case

I have my reasons to believe that c_str is only there to support the interface certain functions, like file stream constructors, or the open method. Use the string class' interface as much as you can, it's functioning code.

Thanks you all

One more Small question map arranges all alphabetically But I dont need that so whats the alternative ?? that works more or less same as map but doesnt arrange alphabatically automatically.

>> But I dont need that so whats the alternative ??
If you don't care what order they're in, then you should still use the map and let it order them.

If you don't want them to be in alphabetical order, but any other seemingly random order will do, then you can use a hash table (like unordered_map) which will allow fast lookups without ordering the elements.

If you want them to be in the same order you insert them, then you'll have to use a vector (or maybe a deque or list) and combine the key and value into a single struct. The problem is then that you won't be able to do lookups quickly because the entire container will have to be searched. If you don't plan on doing lookups, then this shouldn't be a problem.

If you want fast lookups and specific ordering, then you'll need some combination of containers to hold that information.

are all these overloads valid ??

Code:

---

Var(const double val);
Var(const float val);
Var(const int val);
Var(const short val);
Var(const unsigned float val);
Var(const unsigned int val);
Var(const unsigned long val);
Var(const unsigned short val);

---

Edit: especially for the float and double type.

No, there are no unsigned floats.

What ??????????
floats cant be unsigned ?? never knew before
the same applies for double too Right ??
But why they cant be unsigned ??

Floats and doubles cannot be unsigned (nor can they be signed with the keyword signed).
Although, if I were you, I'd study basic templates since they would simplify much of your code.

Quote:

---

Originally Posted by noobcpp

What ??????????
floats cant be unsigned ?? never knew before
the same applies for double too Right ??
But why they cant be unsigned ??

---

Because it wouldn't make any sense to do so (where should the extra bit go -- significand or exponent? If significand, you've not extended the range, so what's the point; if the expnoent, you'll have to change the bias, which means a whole new set of algorithms to actually do the math, and it's not worth it).

Quote:

---

Although, if I were you, I'd study basic templates since they would simplify much of your code.

---

Yes, from a cursory look at your work it seems that you simply want a class that can hold anything as its string representation.

Actually you might not even need a separate class. What you need is something to turn stuff into their string representation and back. Boost libraries have lexical_cast for that, but it wouldn't be hard to write your own with stringstreams. (The difference with the C conversion functions is that you can turn anything, including user-defined classes, into string and back as long as operators << and >> have been overloaded for them.)

Most basic (more error checks could be added):

Code:

---

#include <iostream>
#include <string>
#include <sstream>

template <class From, class Into>
bool convert(const From& from, Into& into)
{
    std::stringstream ss;
    ss << from;
    return ss >> into;
}

//example usage
int main()
{
    //convert long into string
    long n = 42;
    std::string s;
    convert(n, s);

    //convert string into int
    int i;
    if (convert(s, i)) {
        std::cout << "Success: " << i << '\n';
    }
    else {
        std::cout << "Failed to convert " << s << " into int.\n";
    }
}

---