aaalso ich habe eine std::multimap byId vom Typ

typedef multimap<Token::ptr, Thesis::ptr> idmap;

die ::ptr sind shared_ptr auf die entsprechende Klasse.

diese bekommt daten aus einer Textdatei eingepflegt. Der Textdateiparser funktioniert so weit ganz gut, ich erhalte eine Instanz von Thesis, welche meine Daten beinhaltet, unter Anderem ein subject mit dem Typ Token::ptr.

Fülle ich jetzt Daten mittels

this->byId.insert(pair<Token::ptr, Thesis::ptr> (t->subject, t));

in meine multimap, funktioniert dieses nur, solange die key's nicht den gleichen Wert beinhalten- das ist allerdings ungünstig, weil macht ja die multimap erst aus..

Wo hab ich jetzt das Problem?
die generierten Daten sind jedes Mal neue Instanzen- auch, wenn die Werte gleich sind. Könnte er sich daran stoßen?

Edit: Der Laufzeitfehler gestaltet sich wie folgt:
/usr/include/boost/shared_ptr.hpp:315: T* boost::shared_ptr<T>::operator->() const [with T = semnet::Word]: Assertion `px != 0' failed.

Das klingt für mich in meinem jugendlichen Leichtsinn danach, dass du zuerst einen shared_ptr (implizit) default-konstruierst und ihn später (implizit) dereferenzierst.

was allerdings jetzt noch immer nicht geht, ist das Auffinden von Elementen mittels equal_range:

Database::tokeniterator tit = database->findbyToken(Token::ptr(new Token("#1")));
        Database::idmap::iterator it2;
        for (it2 = tit.first; it2 != tit.second; ++it2) {
            cout << (*it2).second->toString() << endl;
        }

dies gibt bei mir nichts aus und das, obwohl eindeutig ein Token namens #1 existiert.

Token sieht so aus:

class Token : public DBElement {
        private:
            uint32_t id;
            static uint32_t maxid;

            void setId (uint32_t id);

            virtual void fromString(string s);

        public:
            typedef boost::shared_ptr<Token> ptr;

            virtual string toString();
            virtual const uint32_t getId();

            Token();
            Token(uint32_t pid);
            Token(string pToken);
            Token(ptr p);

            bool operator== (Token & pToken);
            bool operator== (const uint32_t pId);
            bool operator<  (Token & pToken);
            bool operator<  (const uint32_t pId);

            static bool isToken (string pString);
    };

mit folgender Implementierung:

/* ****************************************
     *  token data
     */
    uint32_t Token::maxid = 0;

    /*
     * set id
     */
    void Token::setId(uint32_t id) {
        /*
         * set maximum id
         */
        if (maxid < id) {
            maxid = id;
        }
        this->id = id;
    }

    /*
     * read Id from String
     */
    void Token::fromString(string s) {
        if (s[0] == '#') {
            setId(atoi(s.substr(1).c_str()));
        }
    }

    /*
     * put Id to string
     */
    string Token::toString() {
        string s;
        stringstream ss;
        ss << "#" << id;
        ss >> s;
        return s;
    }

    /*
     * create new token
     */
    Token::Token() {
        this->setId(maxid + 1);
    }

    /*
     * create new token by id
     */
    Token::Token(uint32_t pId) {
        setId(pId);
    }

    /*
     * create new token by string
     */
    Token::Token(string pToken) {
        fromString(pToken);
    }

    Token::Token(Token::ptr p) {
        fromString(p->toString());
    }
    /*
     * get token id
     */
    const uint32_t Token::getId() {
        return id;
    }

    bool Token::operator==(Token & pToken) {
        return operator==(pToken.getId());
    }
    bool Token::operator==(const uint32_t pId) {
        return this->id == pId;
    }
    bool Token::operator<(Token & pToken) {
        return operator<(pToken.getId());
    }
    bool Token::operator<(const uint32_t pId) {
        return this->id < pId;
    }
    bool Token::isToken(string pString) {
        return (pString[0] == '#');
    }

typedef multimap<Token::ptr, Thesis::ptr> idmap;

@Doc Du musst da ein eigenes compare verwenden das die dereferenzierten keys vergleicht.

Edit: Oder 'globale' compare operatoren für die ptr

aalso neue operatoren bauen..

bool operator== ( Token & a,  Token & b) {
        return a.toString() == b.toString();
    }

ausreicht, reagiert aber kein Stück..

hm.. öh... hilfe?^^

Zweitens benutzt eine map by default den operator < (siehe 3. parameter)

std::map< 
    KeyType, 
    ValueType, 
    Compare = std::less<KeyType>, 
    Alloc<std::pair< KeyType const, ValueType> 
>

Edit: Drittens musst du den Operator für Token::ptr erstellen da das ja versucht wird zu vergleichen .get() bei shared_ptr liefert doch den pointer und keine referenz auf das objekt.