template<class T_Item>
class ItemHandle  
{
public:
	ItemHandle(const T_Item& element_);
private:
	Bbox itemBB;	
};

template<class T_Item>
ItemHandle<T_Item>::ItemHandle(const T_Item& element_) : itemBB(element.bbox())
{
}
}

..danke!

Die folgende Klasse wird unterschiedlich, mit ItemHandle<x> oder mit
ItemHandle<x*> instanziert, was auch so bleiben soll. Allerdings habe
ich dadurch das Problem, daß der Konstruktor einmal element.bbox()
und einmal element->bbox() aufrufen müßte. Gibt es eine Möglichkeit
zu unterscheiden, ob da ein Pointer oder eine Klasse hereinkommt?

template<class T_Item>
class ItemHandle  
{
public:
	ItemHandle(const T_Item& element_);
private:
	Bbox itemBB;	
};

template<class T_Item>
ItemHandle<T_Item>::ItemHandle(const T_Item& element_) : itemBB(element.bbox())
{
}
}

..danke!

template <typename T>
struct is_pointer_type
{
    enum { value = false };
};

template <typename T>
struct is_pointer_type<T*>
{
    enum { value = true };
};

template <typename T>
bool is_pointer(const T&)
{
    return is_pointer_type<T>::value;
}

Dann anwenden :xmas1:

http://ideone.com/ESMtM#view_edit_box

Geprüft (atschibätsch PI).

template <typename T>
struct is_pointer_type
{
    enum { value = false };
};

template <typename T>
struct is_pointer_type<T*>
{
    enum { value = true };
};

template <typename T>
bool is_pointer(const T&)
{
    return is_pointer_type<T>::value;
}

Dann anwenden :xmas1:

http://ideone.com/ESMtM#view_edit_box

Geprüft (atschibätsch PI).

Geil! Das sollte die Lösung sein, ich werds gleich probieren. Ich kann mich
jetzt auch erinnern, daß ich davon mal gelesen habe, und zwar in Alexandrescu's
Modern C++ Design.

Danke fürn Hinweis!

if(is_pointer(a)) a->bbox();
  else a.bbox();

compiliert natürlich nicht. Wie könnte man denn die vorgeschlagene
Spezialisierung syntaktisch umsetzen? Ich habe Beispiel gefunden, wo
man für einen festen Typ spezialisiert, aber wie denn, wenn der Typ
ein Template-Parameter ist wie in diesem Fall?

template <typename T>
void do_stuff(T* obj)
{
    // Zeigervariante
}

template <typename T>
void do_stuff(T& obj)
{
    // Referenzvariante
}

Bei Klassen mithilfe einer Spzialisierung:

template <typename T>
struct foo { ... };

template <typename T>
struct foo<T*> { ... };

Ich kann mir nicht vorstellen, dass Hackers Ding da irgendwie ne Hilfe ist. Zumal es das Ding sowieso schon unter std::is_pointer in <type_traits> gibt.

Edit: Und in deinem Fall würde ich einfach einen zweiten Ctor basteln, der einen const T* nimmt.

Edit 2: Achso, ich seh schon das Problem. Ist schon etwas spät
Ich würde wohl zwei Ctoren schreiben, die so aussehen:

ItemHandle(typename std::remove_pointer<T>::type* ptr);
ItemHandle(typename std::remove_pointer<T>::type& ref);

und dann einfach überall, wo a.foo() oder a->foo() auftauchen würde:

deref(a).foo()

schreiben.

template <typename T>
T&& deref(T&& v) { return std::forward<T>(v); }

template <typename T>
T& deref(T* v) { return *v; }

und dann einfach überall, wo a.foo() oder a->foo() auftauchen würde:

deref(a).foo()

schreiben.

Danke, das war die Lösung. Die erste Funktion mußte ich aber anpassen:

template <typename T>
T& deref(T& v) { return v; }

template <typename T>
T& deref(T* v) { return *v; }

was sollte denn das T&& deref(T&& v) bedeuten?

Stichwörter: Perfect Forwarding, Reference Collapsing.

Und vor allem Anderen Stichwort C++11 und Rvalue-Referenzen. Wenn du das anpassen musstest, kann dein Compiler das wohl noch nicht.

314159265358979 schrieb:

Stichwörter: Perfect Forwarding, Reference Collapsing.

Und vor allem Anderen Stichwort C++11 und Rvalue-Referenzen. Wenn du das anpassen musstest, kann dein Compiler das wohl noch nicht.

Ah, gcc version 4.5.2, und die Software soll am Ende auch noch auf VS 2008
compilieren. Daher habe ich es mit C++11 gar nicht eilig

Danke allen für die Hinweise, das Problem ist nun gut gelöst.

@SeppJ
Buääääääh, Konstruktoren als Funktionen misbrauchen ist mir ein Gräul

Mir auch. Der Threadersteller hat aber ausdrücklich danach gefragt. Wenn du schnell gewesen wärst, hättest du vor dem edit noch eine Version mit normalen Funktoren gesehen.

Beim GCC brauchst du nur beim kompilieren -std=c++0x angeben.

Oder, wie bei mir (wie schon bei unserer Spielwiese festgestellt):
-std=gnu++0x

Zuletzt bearbeitet von Hacker am 16:01:35 17.12.2011, insgesamt 1-mal bearbeitet

Um uns das mitzuteilen musstest du den Thread nochmals ausgegraben?

Zuletzt bearbeitet von Hacker am 16:01:35 17.12.2011, insgesamt 1-mal bearbeitet

Um uns das mitzuteilen musstest du den Thread nochmals ausgegraben?

1. Falsches Deutsch,
2. Ja. Denn bei mir z.B. klappt das anders nicht, und wenn dich der Thread nervt dann ignorier ihn verdammt nochmal. Dadurch das du (und eig. ich auch) ihn weiter befüllen bleibt er ausgegraben. :xmas1: