map<unsigned int index,vector<De bugInfo> >

[OriginalCopy]

This is a demonstrative code which could be used for debugging purposes. And yet I don't know how to insert the necessary data on line 63, purely syntactically speaking ? I'm a beginner with STL, and from what I've read insert() accepts references for almost all of its overloaded versions. If so, what could one do so those element's memory space doesn't wipe out? I suppose one should use the heap. In rest I hope the code speaks for itself, it's a demonstrative rewrite of a code using heavily VC++ preprocessor's features for mingw

00000001 #include <iostream>
00000002 #include <vector>
00000003 #include <string>
00000004 #include <map>
00000005 using namespace std;
00000006 /**
00000007  * __FILE__
00000008  * __LINE__
00000009  * __BASE_FILE__
00000010  *
00000011  */
00000012
00000013
00000014 /**
00000015  * one single "display debug" item of a vector
00000016  */
00000017 struct AtomicDebugInfo {
00000018     string *message;
00000019     unsigned int line;
00000020 };
00000021 /**
00000022  * the first item of the map holds additional data
00000023  * same as AtomicDebugInfo but with additional attributes
00000024  */
00000025 struct StartDebugInfo {
00000026     string *message;
00000027     unsigned int line;
00000028     unsigned int attributes;
00000029 };
00000030 /**
00000031  * use this so we need only a vector of it, undependently of the position
00000032  * in the vector. In this way we can also have per-item attributes
00000033  */
00000034 union DebugInfo {
00000035     struct AtomicDebugInfo item;
00000036     struct StartDebugInfo top;
00000037 };
00000038
00000039
00000040 /**
00000041  * a demonstrative debugging class
00000042  */
00000043
00000044 typedef map<unsigned int,vector<DebugInfo> > Calls;
00000045
00000046 class Debug {
00000047 private:
00000048     unsigned int index;//which frame of the map this instance owns
00000049     static Calls calls;
00000050 public:
00000051     Debug(string msg,unsigned int line,unsigned int index);
00000052     static void Out();
00000053 };
00000054
00000055 //allocate static memory
00000056 map<unsigned int,vector<DebugInfo> > Debug::calls;
00000057
00000058
00000059 Debug::Debug(string msg,unsigned int line,unsigned int index) {
00000060     //How to insert one StartDebugInfo into Debug::calls ?
00000061     //One certainly needs to cast from DebugInfo
00000062     //But how ?
00000063     //Debug::calls.insert(index,
00000064 }
00000065
00000066 void Debug::Out() {
00000067     Calls::iterator iter;
00000068     iter = Debug::calls.begin();
00000069     cout << "dumping out debugging info" << endl;
00000070     while(iter != Debug::calls.end()) {
00000071         //cout << iter->first << endl;
00000072         iter++;
00000073     }
00000074 }
00000075
00000076 #define D(msg,index) Debug((msg),__LINE__,(index))
00000077
00000078
00000079 int main(void) {
00000080     /*
00000081     //using the class Debug would go like this
00000082     Debug *d1 = new D("foo",0);
00000083     Debug *d2 = new D("foo",123);
00000084     */
00000085     return EXIT_SUCCESS;
00000086 }
00000087 

As I'm a beginner in STL, the sintax overwhelms me, so please show me how to write it syntactically and forgive my bad english. Thanks.

[weaknessforcats]

You need to use inheritance.

Your base class is DebugInfo.

AtomicDebugInfo derives from DeugInfo as adds the message and the line.

StartDebugInfo derives from AtomicDebugInfo and adds attributes.

When you create a StartDebugInfo object it will contain message, line and atrtributes.

Next, you write functions using DebugInfo pointer or reference arguments and you pass in your StartDebugInfo object as a DebugInfo object.

Virtual functions in DebugInfo will be overriden in your derived classes so you can call your derived class methods.

If you need to call methods in your derived class that are not in your base class, then research the Visitor design pattern. It's in the book "Design Patterns".