Funktion, die den Datentyp ausgibt

Schweinefrau

Hallo Zusammen,

leider habe ich vergessen, wie die Funktion hieß, mit der man sich den Datentyp einer Variablen anzeigen lassen kann. Ich habe eine Template-Klasse und möchte dort bei einer map anders agieren als bei einer set.
Habe auch schon gesucht, aber scheinbar nicht die richtigen Suchbegriffe verwendet.

Danke,
Rebecca

typeid

Bashar

Schweinefrau schrieb:

leider habe ich vergessen, wie die Funktion hieß, mit der man sich den Datentyp einer Variablen anzeigen lassen kann. Ich habe eine Template-Klasse und möchte dort bei einer map anders agieren als bei einer set.

Mit Funktionen ist dir da nicht geholfen, versuchs mal mit Spezialisierung.

Schweinefrau

Vielen Dank,
Spezialisierung wäre wohl das richtige, aber igendwie bekomme ich das nicht richtige umgesetzt. Habe jetzt zu der allgemeinen Funktion noch eine spezialisiert gemacht, aber ich erhalte beim Aufruf die Fehlermeldung:
error C2667: 'Symmetric_Difference' : Keine von 2 Ueberladungen ergibt beste Konvertierung
error C2668: 'Symmetric_Difference' : Mehrdeutiger Aufruf einer ueberladenen Funktion
Meine Funktionen sehen wie folgt aus

//allgemeine Fkt
template<class set_type>
void Symmetric_Difference(const set_type& s1,
                          const set_type& s2,
                          set_type& result) {
    set_type temp;
    typename set_type::const_iterator i = s1.begin();

    if(&s1 != &s2) {
       while(i != s1.end()) {
           if(s2.find(*i) == s2.end())  // not found
              temp.insert(*i);
           ++i;
       }

       i = s2.begin();
       while(i != s2.end()) {
           if(s1.find(*i) == s1.end())  // not found
              temp.insert(*i);
           ++i;
       }
    }
    temp.swap(result);
}

//Fkt für eine Map
template<class P1, class P2>
void Symmetric_Difference(const std::map<P1, P2> &s1,
                          const std::map<P1, P2> &s2,
                          std::map<P1, P2> &result) 
 {
    std::map<P1, P2> temp;
    typename std::map<P1, P2>::const_iterator i = s1.begin();

    if(&s1 != &s2) {
       while(i != s1.end()) {
           if(s2.find((*i).first) == s2.end())  // not found
              temp.insert(*i);
           ++i;
       }

       i = s2.begin();
       while(i != s2.end()) {
           if(s1.find((*i).first) == s1.end())  // not found
              temp.insert(*i);
           ++i;
       }
    }
    temp.swap(result);
}

//Aufruf

std::map<std::string, Node<S>*> oldPredecessors, newPredecessors, changeArc;
Symmetric_Difference(oldPredecessors, newPredecessors, changeArc);

Was habe ich falsch gemacht?

Mis2com

Hi,

Was habe ich falsch gemacht?

du hast nicht das c++-Tag verwendet.

[code]
//allgemeine Fkt
template<class set_type>
void Symmetric_Difference(const set_type& s1,
const set_type& s2,
set_type& result) {
set_type temp;
typename set_type::const_iterator i = s1.begin();

if(&s1 != &s2) {
while(i != s1.end()) {
if(s2.find(*i) == s2.end()) // not found
temp.insert(*i);
++i;
}

i = s2.begin();
while(i != s2.end()) {
if(s1.find(*i) == s1.end()) // not found
temp.insert(*i);
++i;
}
}
temp.swap(result);
}

//Fkt für eine Map
template<class P1, class P2>
void Symmetric_Difference(const std::map<P1, P2> &s1,
const std::map<P1, P2> &s2,
std::map<P1, P2> &result)
{
std::map<P1, P2> temp;
typename std::map<P1, P2>::const_iterator i = s1.begin();

if(&s1 != &s2) {
while(i != s1.end()) {
if(s2.find((*i).first) == s2.end()) // not found
temp.insert(*i);
++i;
}

i = s2.begin();
while(i != s2.end()) {
if(s1.find((*i).first) == s1.end()) // not found
temp.insert(*i);
++i;
}
}
temp.swap(result);
}

//Aufruf

std::map<std::string, Node<S>*> oldPredecessors, newPredecessors, changeArc;
Symmetric_Difference(oldPredecessors, newPredecessors, changeArc);

MfG Eisflamme

Schweinefrau

Hi,

meintes Du mit c++-tag dieses:

Symmetric_Difference<std::string, Node<S>*>(oldPredecessors, newPredecessors, changeArc);

Dann erhalte ich nämlich die Fehlermeldung:
error C2977: 'Symmetric_Difference' : Zu viele Vorlagenargumente

Habe glaube ich gerade voll das Brett vorm Kopf.
Gruß,
Rebecca

Schweinefrau

Ok,

so funktioniert es wohl:
Symmetric_Difference<std::map<std::string, Node<S>*> >(oldPredecessors, newPredecessors, changeArc);

Rebecca

Schweinefrau

Das mit der Spezialisierung scheint doch noch nicht so wirklich zu funktionieren, denn scheinbar springt er nicht in die richtige template-funktion.
also der Aufruf ist nun wie folgt:

Symmetric_Difference<std::map<std::string, Node<S>*> >(oldPredecessors, newPredecessors, changeArc);

Als Fehlermeldung erhalte ich:
'find' : Fuer 2 Ueberladung(en) gibt es keine zulaessige Konvertierung fuer den this-Zeiger
Und die Fehlermeldung verweist auf die allgemeine Funktione und nicht die für Maps.

Hat jemand eine Ahnung, was noch falsch ist?
Gruß,
Rebecca