Kopieren von Maps unterschiedlichen Typs

Reply to Kopieren von Maps unterschiedlichen Typs on Mon, 31 Mar 2008 16:12:43 GMT

lord.hong — Mon, 31 Mar 2008 16:12:43 GMT

Hallo an alle,

ich habe zwei maps unterschiedlichen Typs und würde nun gerne eine Map in die andere kopieren (zum. die Keys).

typedef std::map RegisteredMyClass;
  RegisteredMyClass m_mRegisteredMyClass;

  typedef std::map WaitingList;
  WaitingList m_mWaitingListMyClass;

Die Elemente der WaitingList sollen in die RegisteredMyClass kopiert werden oder genauer etwas genauer die Keys und jeder bool sollte auf false gesetzt werden.

Meine erster Ansatz ist nun dieser:

void MyClass::Register()
    {
      WaitingList::const_iterator itCurrent(m_mWaitingListMyClass.begin());
      WaitingList::const_iterator itEnd(m_mWaitingListMyClass.end());

      for ( ; itCurrent != itEnd; ++itCurrent)
      {
        m_mRegisteredMyClass[itCurrent->first] = false;
      }

      m_mWaitingListMyClass.clear();
    }

Gibt es einen schöneren und eleganteren Weg Keys zu kopieren mit der STL (copy, transform, ...)?

Danke,
Markus

Reply to Kopieren von Maps unterschiedlichen Typs on Thu, 03 Apr 2008 13:01:05 GMT

OhneName — Thu, 03 Apr 2008 13:01:05 GMT

Also für copy müsstest du dir wahrscheinlich einen eigenen Iterator schreiben, den du als dritten Parameter übergibst.
Ich habs mit transform versucht, hab aber leider immer irgendwelche Compilerfehler bekommen.
Hier wäre eine Variante mit for_each:

#include 
#include 
#include 
#include 

typedef std::map IntBool;
typedef std::map IntInt;

class func
{
    public:
        func(std::map& m) : ii(m) {}
        void operator() (const std::pair& p) { ii.insert(std::make_pair(p.first, false)); }
    private:
        std::map& ii;
};

int main(int argc, char* argv[])
{
    IntInt ii;
    IntBool ib;

    ii[0] = 0;
    ii[1] = 1;
    ii[2] = 2;
    ii[3] = 3;

    for(std::map::iterator iter1 = ii.begin(); iter1 != ii.end(); ++iter1)
        std::cout << iter1->first << " " << iter1->second << std::endl;

    std::for_each(ii.begin(), ii.end(), func(ib));

    for(std::map::iterator iter2 = ib.begin(); iter2 != ib.end(); ++iter2)
        std::cout << iter2->first << " " << iter2->second << std::endl;
}

Reply to Kopieren von Maps unterschiedlichen Typs on Thu, 03 Apr 2008 17:22:40 GMT

OhneName — Thu, 03 Apr 2008 17:22:40 GMT

Also ich habs jetzt doch noch mit transform hinbekommen. Ist ein bisschen kürzer weil eine freie Funktion reicht und du keinen Funktor schreiben musst.

#include 
#include 
#include 
#include 

typedef std::map IntBool;
typedef std::map IntInt;

std::pair func(const std::pair& p)
{
    return std::make_pair(p.first, false);
}

int main(int argc, char* argv[])
{
    IntInt ii;
    IntBool ib;

    ii[0] = 0;
    ii[1] = 1;
    ii[2] = 2;
    ii[3] = 3;

    for(std::map::iterator iter1 = ii.begin(); iter1 != ii.end(); ++iter1)
        std::cout << iter1->first << " " << iter1->second << std::endl;

    std::transform(ii.begin(), ii.end(), std::inserter(ib, ib.end()), func);

    for(std::map::iterator iter2 = ib.begin(); iter2 != ib.end(); ++iter2)
        std::cout << iter2->first << " " << iter2->second << std::endl;
}

Reply to Kopieren von Maps unterschiedlichen Typs on Fri, 04 Apr 2008 11:50:19 GMT

camper — Fri, 04 Apr 2008 11:50:19 GMT

Es ist evtl. sinnvoll anzumerken, dass diese Lösung zwar einigermaßen elegant aber auch, zumindest wenn IntInt nicht zuvor leer ist, möglicherweise ineffizient ist.
Wenn N die Anzahl der Elemente in IntBool, und M die Anzahl IntInt ist, können wir die Komplexität obigen Algorithmuses in erster Näherung als O(N*lg(M)) abschätzen. Das stimmt nicht so ganz, weil die Größe der Map ja während des Einfügens anwächst, aber damit erhöht sich die Komplexität ja nur noch weiter.
Es ist aber andererseits sehr einfach, einen Algorithmus anzugeben mit O(N+M), dann müssen wir aber ohne Standardalgorithmen auskommen:

#include 
#include 
#include 
#include 

typedef std::map IntBool;
typedef std::map IntInt;

int main(int argc, char* argv[])
{
    IntInt ii;
    IntBool ib;

    ii[0] = 0;
    ii[1] = 1;
    ii[2] = 2;
    ii[3] = 3;

    for(std::map::iterator iter1 = ii.begin(); iter1 != ii.end(); ++iter1)
        std::cout << iter1->first << " " << iter1->second << std::endl;

//  std::transform(ii.begin(), ii.end(), std::inserter(ib, ib.end()), func);
    {
        std::map::const_iterator iter1 = ii.begin();
        std::map::iterator iter2 = ib.begin();
        if ( iter1 != ii.end() && iter2 != ib.end() )
            for ( ;; )
            {
                if ( iter1->first < iter2->first )
                {
                    ib.insert( std::make_pair( iter1->first, false ), iter2 );
                    if ( ++iter1 == ii.end() )
                        break;
                }
                else
                    if ( ++iter2 == ib.end() )
                        break;
            }
        while ( iter1 != ii.end() )
            ib.insert( std::make_pair( iter1->first, false ), ib.end() );
    }

    for(std::map::iterator iter2 = ib.begin(); iter2 != ib.end(); ++iter2)
        std::cout << iter2->first << " " << iter2->second << std::endl;
}

Das ist schneller zumindest dann, wenn M nicht 0 und nicht sehr groß gegen N ist. Will man die beste Lösung, müsste man wohl zuerst die Größen der Maps untersuchen, und in Abhängigkeit davon dann den Algorithmus auswählen.