template<typename T, size_t N = sizeof(T)>
void foo(T const &)
{
  // hier geht es mir nur um die Bytebreite des Typs, sprich N
}

template <typename T>
void foo(T const&)
{
    const size_t N = sizeof(T);
}

Was willst du genau erreichen?

template <typename T, size_t N> void foo_impl(T const&){}

template <typename T> void foo(T const& bar)
{
    foo_impl<T, sizeof(T)> (bar);
}

edit: Bzw. das macht keinen Sinn, da das T ja sowieso schon immer unterschiedlich ist und das N keine Rolle mehr spielt. Immerhin kannst du so aber einerseits das N vorgeben, andererseits hast du einen guten Defaultwert.

Edit:
Die Lösung von SeppJ sieht schon mal gut aus. Daran hatte ich aber auch gedacht, das Problem ist nur der Typ. Mich interessiert aber nur die Datenbreite.

Die Lösung von SeppJ sieht schon mal gut aus. Daran hatte ich aber auch gedacht, das Problem ist nur der Typ. Mich interessiert aber nur die Datenbreite.

Dann lass doch einfach den Typ-Parameter weg...

Der Wunsch, Templatefunktionen unabhängig von einem der Templateparameter haben zu wollen, klingt jedenfalls schon einmal sehr wild.

Btw. Wie kann man mit dem Visual Studio Compiler C++0x Code compilieren?

Wie im ersten Beitrag geschrieben möchte ich, dass mir der Compiler die richtige Funktion auswählt, abhängig von der Datenbreite des übergegebenen Typs. Der Typ selber ist mir dabei egal.

Ja, dann dürfte meine Lösung passend sein. Lass einfach das T bei der foo_impl weg.

Btw. Wie kann man mit dem Visual Studio Compiler C++0x Code compilieren?

Wenn du Visual Studio 2010 hast und du nur die unterstützen C++0x-Features benutzt: Ohne etwas speziell einzustellen.

@Nexus
Ich hab das Beispiel von oben getestet und da kam der erwartete Fehler. Deswegen dachte ich man könnte wie beim GCC noch einem Schalter mitgeben?
Ich hab hier VS 2010 Premium das sollte doch schon die Suite mit sämtlichen Funktionen sein?

@knivil
Wie stellst du dir das vor?

template<typename T>
void foo(T const & v)
{
  foo_impl<sizeof(T)>(reinterpret_cast<AByte const * const>(&v));
}

AByte ist einfach nur ein unsigned char.
Was mir aber nicht so gefällt ist der Cast. Ich schätze aber für das Problem gibt es sonst keine elegante Variante? In foo_impl werden die einzelnen Bytes des Typs gebraucht.

Und wenn du da jetzt keine Spezialisierung für bestimmte Größen machst, dann hau ich dich (und Nexus haut dich noch viel fester).

Übergib doch einen void*.

Naja, dann muss ich in den einzelnen Funktionen casten. Das wäre im Endeffekt nur mehr Aufwand.

Edit:
Ich hab grad nochmal den Originalcode raus gekrammt, dass hat durchaus seinen Sinn, über eine Switch-Anweisung in die Funktionen zu gehen. Weil diese als Eingabe und Ausgabe einen Typ haben, der die selbe Datenbreite hat.

Dein ursprüngliches Problem (gewürzt mit ein wenig erklärendem Quellcode) wird sicherlich kein Staatsgeheimnis sein.

Dreieckstausch mit memcpy() ?

Beispiel, bitte?

Nexus schrieb:

Dass das Verhalten von byteweisen Operationen nur für PODs definiert ist, brauch ich wohl nicht zu sagen...

Nein, ist klar.

Wie würdet ihr eine Byteswapping-Funktion implementieren? Falls es da eine Standardfunktion für gibt, bitte auch nennen. Ich hab die paar Zeilen nur lieber schnell selbst geschrieben, weil ich nichts passendes in kürzerer Zeit gefunden habe. Meine Frage bezog sich nur darauf, ob es eleganter geht. Meine Frage hat sich also somit geklärt. Auch weil noch ein paar Details dazu gekommen sind, die andere Anforderungen überflüssig gemacht haben. Außer jemand hat generell noch einen Vorschlag, wie man eine Byteswap-Funktion realisieren sollte. Bitte nicht die htonX()-Funktionen nennen, die swappen nämlich nur, wenn es notwendig ist.

Ich gehe mal davon aus, dass du die bytes im Objekt selber swappen willst.
Damit da nichts undefiniertes bei rumkommt, darf es sich bei den betroffenen Objekten nur um PODs handeln. Damit wird das byte-swappen "nur noch" implementation defined. Wozu auch immer du das brauchen solltest, portabel ist das in keiner Weise, zumal noch so Dinge wie Padding und Alignment ne Rolle spielen dürften. Die Frage ist also: wozu brauchst du das?
Schreiben würd ichs in etwa so:

template <size_t N>
void swapBytesN(void* ptr)
{
  char* raw_bytes = reinterpret_cast<char*>(ptr);
  for (size_t i = 0; i < N/2; ++i)
  {
    std::swap(raw_bytes[i], raw_bytes[N-i]);
  }
}

template <typename POD_t>
void swapBytes(POD_t& pod)
{
  swapBytesN<sizeof(POD_t)>(&pod);
}

Ich gehe mal davon aus, dass du die bytes im Objekt selber swappen willst.

Ja.

pumuckl schrieb:

Damit da nichts undefiniertes bei rumkommt, darf es sich bei den betroffenen Objekten nur um PODs handeln.

Die Grunddatentypen reichen vollkommen aus.

pumuckl schrieb:

zumal noch so Dinge wie Padding und Alignment ne Rolle spielen dürften.

Gibt es nicht, nur Grunddatentypen.

Deine Lösung dürfte wohl das sein, was Nexus vorgeschlagen hat. Ich werde es mir mal genauer betrachten.

Ausserdem würde dich jeder C-Programmierer noch fester hauen als SeppJ und ich zusammen, wenn er sähe, wie kompliziert du einen Byte-Tausch umsetzt

Auch bei den Grunddatentypen ist die Byte-Darstellung implementation-defined. Portabel ist das nicht.

Meinst du jetzt die Endianness oder etwas ganz anderes? Die Endianness soll je gerade mit dieser Aktion abgefangen werden. Die Datentypgrößen passen auch, die werden extra so gewählt. Dass sich verschiedene Fließkomma-Darstellungen so beißen werden ist klar, dass müsste man dann gesondert behandeln. Und zum Beispiel vorher das Format anpassen. Sonst würde mir da jetzt kein weiterer Fallstrick einfallen?

Nexus schrieb:

Ausserdem würde dich jeder C-Programmierer noch fester hauen als SeppJ und ich zusammen, wenn er sähe, wie kompliziert du einen Byte-Tausch umsetzt

Wieso kompliziert? Ich hab die übliche Bitshifterei gemacht, so wie man sie auch zu tausenden im Netz findet. Welche Variante nun die bessere ist, müsste man schauen. An meiner ist aber gar nichts kompliziert, ganz im Gegenteil, die ist sogar extrem einfach gehalten.

Meinst du jetzt die Endianness oder etwas ganz anderes? Die Endianness soll je gerade mit dieser Aktion abgefangen werden.

Klingt furchtbar nach Hack.

PS:
es würde ungemein helfen wenn du endlich sagst WAS du machen willst.