Weshalb bekomme ich keine Kompilerwarnung innerhalb von foo2() aber innerhalb von foo1() ? Beide bedingte Ausdrücke sind doch zur Laufzeit konstant?

Was ist der Unterschied zwischen einer if-Bedingung und dem ?-Operator? Wird das vom Compiler unterschiedlich übersetzt? Wie gehe ich vor, wenn ich mehrere Template-Parameter habe und diese mit Bedingungen zur Compilerzeit überprüfen muss?

#include <stdio.h>  // printf()

template<bool a>
char foo1() {
  if (a)           // MS-VC2008 Warnung: "Bedingter Ausdruck ist konstant"
    return '1';
  else
    return '0';
}

template<bool a>
char foo2() {
  return a ? '1' : '0';
}

int main() {
  printf("%c\n", foo1<1>());
  printf("%c\n", foo2<1>());
  return 0;
}

Gruss
T.

Beide Arten bewirken das gleiche, aber so sind die Compiler. Probiere einen anderen und er wird dir andere Warnungen generieren.

Aber einfach gesagt: Bei templates spezialisiert man (statisch), während das Aus-if-en eigentlich zur Laufzeit änderbare Variablen bedient.
Ein gutes Stichwort für dich ist Template Specialization bzw. Partial Template Specialization

Probier mal

template<bool a> char foo1();

template<> char foo1<true>()  { return '1'; }
template<> char foo1<false>() { return '0'; }

oder noch besser:

template<bool a> struct foo;
template<> struct foo<true>  { static const char value = '1'; };
template<> struct foo<false> { static const char value = '0'; };
...
char chr1 = foo<true>::value;
char chr2 = foo<false>::value;

Theoretisch entstehen bei deinem Code zwei Funktion:

char foo1<true>() { if (true) return '1'; else return '0'; }
char foo1<false>() { if (false) return '1'; else return '0'; }

Jeder gute Compiler wird das ohnehin weg-optimieren, aber in beiden Fällen sollte der Compiler fragen wieso du ihm eine solche if/?-Bedingung überhaupt angibst.

lg XOR

template<bool a> struct foo { static char const value = a ? '0' : '1'; }

Mit if wird das nix

Ich hoffe das war jetzt nicht zu wirr erklärt . Zusammenfassung: Ja, es gibt einen Unterschied im Compiler zwischen ? und if.

Die Compiler sind hier dennoch unterschiedlich bei den Warnungen. Hatte erst kürzlich wieder eine if(false) - Pseudo-Auskommentierung, die der MSVC ignoriert, während der GCC davor warnt.

T.