3. was genau bedeutet das argument (int C::*)

was genau bedeutet das argument (int C::*)

  • M

    Im C++ templates wird diese Argmuent verwendet um letztlich Klassen zu identifizieren. Bei

    void foo(typename C::X const*)

    ist mir die Syntax und die BEdeutung klar, aber hier

    void foo(int C::*)

    nicht ganz.
    Hat darüber hinaus eventuell einer eine gute Seite im Netz für solche Syntax Fragen zur Hand?

    0
  • P

    Das bedeutet nur, dass foo einen Pointer auf ein int-Member von C als Argument nimmt. Dem wurde nur kein Name gegeben, ähnlich wie bei void bar(int);

    Beispiel:

    class C {
  public:
  int i;
  int b;
};

int main() {
  foo(&C::i);
  foo(&C::b);
}
    0
  • M

    sowas dachte ich mir. nur wie kann man somit auf klassen testen? was wenn wenn diese keine int variablen hat? dann klappt der test doch auch nicht, oder?

    0
  • P

    Das Buch steht bei mir zu Hause, ich bin grad auf Arbeit - wie testen sie damit auf Klassen? Zeig mal Beispiel 🙂

    0
  • L

    Wenn die Klasse keine int Variablen hat, kannst Du die Funktion nicht aufrufen, da es nichts gibt was vom Typ her dem Argument entspräche. Du kannst aber trotzdem so eine Funktion deklarieren, daran hindert Dich niemand.

    Was meinst Du mit "Klassen identifizieren" überhaupt?

    0
  • M

    ja, meine buch steht auch zu hause... verdammt... ich schau mal, ob ich es grad im netz finde

    0
  • M
     

    template<typename T>
class IsClassT {
  private:
    typedef char One;
    typedef struct { char a[2]; } Two;
    template<typename C> static One test(int C::*);
    template<typename C> static Two test(...);
  public:
    enum { Yes = sizeof(IsClassT<T>::test<T>(0)) == 1 };
    enum { No = !Yes };
};

template <typename T>
void check()
{
    if (IsClassT<T>::Yes) {
        std::cout << " IsClassT " << std::endl;
    }
    else {
        std::cout << " !IsClassT " << std::endl;
    }
}

template <typename T>
void checkT (T)
{
    check<T>();
}

#include <iostream>
#include "isclasst.hpp"

class MyClass {
};

struct MyStruct {
};

union MyUnion {
};

void myfunc()
{
}

enum E { e1 } e;

int main()
{
    std::cout << "int:     ";
    check<int>();

    std::cout << "MyClass: ";
    check<MyClass>();

    std::cout << "MyStruct:";
    MyStruct s;
    checkT(s);

    std::cout << "MyUnion: ";
    check<MyUnion>();

    std::cout << "enum:    ";
    checkT(e);

    std::cout << "myfunc():";
    checkT(myfunc);
}

    http://www.josuttis.com/tmplbook/

    0
  • P

    Es geht dabei darum, dass eine Klasse C Member haben kann, unter anderem einen int (muss aber nicht sein) Damit ist das Konstrukt int C::* genau dann erlaubt, wenn C eine Klasse ist. Du hast natuerlich recht, das es fuer Klassen, die kein int-Member haben, so einen Pointer nicht geben kann - abgesehen vom Nullpointer, der gerade hier zum Einsatz kommt

    sizeof(IsClassT<T>::test<T>(0)) == 1

    Der Nullpointer kann also auch dann ein Pointer-auf-int-Mebmer-von-C sein, wenn C keine int-Member hat. Damit ist der Match besser als mit der Ellipse und der Test positiv.

    0
Anmelden zum Antworten