ich habe eine Funktion die mir es erlaubt eine Variable vom big- zum litte endian Format zu konvertieren und andersrum.

Ich nutze dafür die entsprechenden Instruktionen. Daher existiert für jeden - möglichen - Typ eine Implementation:

template<typename operand>
operand bswap(
	operand 
) 
{
	assert(false);
	operand ret_val;
	return ret_val;

#ifdef _MSC_VER
#pragma message("Warning: implementation for specified operand type doesn't exist")
#endif
}

template<> uint16  bswap(uint16  value)	    {return Detail::bswap_word(value);}
template<> uint16& bswap(uint16& value)		{return Detail::bswap_word_ref(value);}
template<> uint32  bswap(uint32  value)		{return Detail::bswap_dword(value);}
template<> uint32& bswap(uint32& value)		{return Detail::bswap_dword_ref(value);}
template<> uint64  bswap(uint64  value)	    {return Detail::bswap_qword(value);}
template<> uint64& bswap(uint64& value)		{return Detail::bswap_qword_ref(value);}

Ist die non-specialized template Funktion - die bei allen anderen Typen aufgerufen wird - so in Ordnung oder sollte man das anders machen?

sollte immer ausgelöst werden.. woher soll denn der präprozessor wissen, ob das template instantiiert wird oder nicht? er sieht es -> er warnt!

bb

edit:
ich würds so machen:

template<typename T>
T endian_swap(T val); //LNK-error

template<>
T endian_swap<short>(short val)
{
  return detail::short_swap(val);
}

#ifdef _MSC_VER 
#pragma message("Warning: implementation for specified operand type doesn't exist") 
#endif

sollte immer ausgelöst werden.. woher soll denn der präprozessor wissen, ob das template instantiiert wird oder nicht? er sieht es -> er warnt!

bb

Nein, mit Sicherheit nicht.
Es wird nur ausgelöst, wenn eine unspecialized operand type Variante instantiiert (verwendet) wird.

Es ist ja der Sinn eines Templates, dass erst zur Kompilierzeit die eigentliche Klasse / Struct / Funktion angelegt wird.
Soll heißen: Bevor man (z.B.) bswap<double> nicht verwendet existiert es auch nicht.

ich würds so machen:
[cpp]
template<typename T>
T endian_swap(T val); //LNK-error

template<>
T endian_swap<short>(short val)
{
  return detail::short_swap(val);
}

Ja, stimmt schon. Ist zwar die Primitivste, aber eine definitiv funktionierende Lösung.
Ich dachte nur, es wäre schön, etwas mehr Feedback zu geben. Ist zwar im Endeffekt von vornherein Quatsch bswap für etwas anderes zu benutzten, aber man weiß ja nie

Dachte es gibt vielleicht die Möglichkeit - jetzt MSC spezifisch - eine echte Warnung auszugeben.
Der per message() erscheinende Text ist da nicht wirklich nützlich, da das im Output-Fenster sowie jeder übersieht.

Nein, mit Sicherheit nicht.

Doch. Der Präprozessor funktioniert ganz anders als du dir das offenbar vorstellst. Du kannst aber Compilezeitassertions mit Meldungen machen, guck die mal die Boost Metaprogrammierungsbibliotheken an, die müssten sowas haben.

Doch. Der Präprozessor funktioniert ganz anders als du dir das offenbar vorstellst. Du kannst aber Compilezeitassertions mit Meldungen machen, guck die mal die Boost Metaprogrammierungsbibliotheken an, die müssten sowas haben.

Ich würd's ja gerne glauben, aber warum funktioniert es dann?!

Verwende ich im Code:

bswap<double>(8.0);

kommt meine Meldung. Kommentiere ich es aus, dann nicht. Also genau das was ich wollte ...

Ich bin mir durchaus im klaren darüber, wie der Präprozessor funktioniert. Ich gehe sogar fest davon aus, dass selbige Deklaration mit gcc nicht funktionieren würde (sehen wir mal von der sowieso nicht vorhanden Direktive ab).

Mir ist klar, dass das mal wieder eine MSC-only Geschichte ist, aber andere Compiler grenze ich ja sowieso aus.

template<typename T>
void t(T)
{
#  pragma message("hi")
}

template<> void t(int) {}

int main()
{
  ; //keine msg
//  t(int()); //keine msg
//  t(float()); //msg
}

sehr eigenartig...
aber imho definitiv nicht standard-konform...

bb

sehr eigenartig...
aber imho definitiv nicht standard-konform...
bb

Sag ich doch
Was ist beim MSC schon wirklich Standard? Alles andere hab ich ja auch ausgeschaltet, aber wenn es statt message kein warning Pendandt gibt, ist die Lösung das Ding einfach nicht zu definieren und den Linker die Arbeit machen zu lassen, wohl am einfachsten.

wieso sollte man jetzt krampfhaft versuchen dieses verhalten zu verschlechtern, indem man aus dem FEHLER einen leicht zu übersehenden hinweis macht?!?

BTW: jeder C++ programmierer mit ein wenig erfahrung wird sofort verstehen was es bedeutet, wenn der compiler hier rumsudert dass er das template nicht instanzieren kann. die verständlichkeit ist IMO also auch kein argument.

wenn man die default-implementierung weglässt, wird ein compiler-FEHLER erzeugt. besser geht's ja wohl nicht.

Wie machst du das? Ich bekomm nur nen Linkererror.

template<typename T>
T endian_swap(T val)
{
    BOOST_STATIC_ASSERT( false && "not implemented for this type" );
}

static_assert() ist natürlich auch eine Möglichkeit.