Substitution failure is not an error - Versionsgeschichte

Invisigoth67: Steuerzeichen entfernt/ersetzt

2024-05-18T07:48:28Z

Steuerzeichen entfernt/ersetzt

← Nächstältere Version		Version vom 18. Mai 2024, 09:48 Uhr
Zeile 41:		Zeile 41:
	Die Rückgabewerte der <code>Tester</code>-Funktion sind [[Referenz (Programmierung)\|Referenzen]], da in C++ bekanntlich keine Arrays zurückgegeben werden können. Der <code>sizeof</code>-Operator gibt beim Anwenden auf eine Referenz die Größe des referenzierten Types zurück. Beim Anwenden auf einen vermeintlichen Funktionsaufruf (also auf eine Funktion inkl. Funktionsargumente) wird die Größe des Rückgabewertes angegeben. Da die Funktion in Tat und Wahrheit nie wirklich aufgerufen wird, ist keine Funktionsdefinition vonnöten. Um die Größe des Rückgabewertes angeben zu können, muss zuerst die korrekte Funktion ausgewählt werden. Wird als Template-Argument <code>T = Foo</code> gewählt, so sind beide Überladungen korrekt, weil Foo::Type eruierbar ist. In diesem Fall wird anhand der Regeln überladener Funktionen die näherliegende ausgewählt. Da die [[variadische Funktion]] keine [[Typsicherheit]] bietet, wird die erste Funktion (die, die einen <code>TrueType</code> zurückgibt) bevorzugt. Wird hingegen <code>T = int</code> eingegeben, so wird die erste Funktion aus der Menge der infrage kommenden Überladungen ausgeschieden. Dies erzeugt dank SFINAE keinen Kompilierfehler. Es wird außerdem die Tatsache ausgenutzt, dass der Wert <code>0</code> in C++ implizit in einen [[Nullwert\|Nullzeiger]] konvertiert werden kann.		Die Rückgabewerte der <code>Tester</code>-Funktion sind [[Referenz (Programmierung)\|Referenzen]], da in C++ bekanntlich keine Arrays zurückgegeben werden können. Der <code>sizeof</code>-Operator gibt beim Anwenden auf eine Referenz die Größe des referenzierten Types zurück. Beim Anwenden auf einen vermeintlichen Funktionsaufruf (also auf eine Funktion inkl. Funktionsargumente) wird die Größe des Rückgabewertes angegeben. Da die Funktion in Tat und Wahrheit nie wirklich aufgerufen wird, ist keine Funktionsdefinition vonnöten. Um die Größe des Rückgabewertes angeben zu können, muss zuerst die korrekte Funktion ausgewählt werden. Wird als Template-Argument <code>T = Foo</code> gewählt, so sind beide Überladungen korrekt, weil Foo::Type eruierbar ist. In diesem Fall wird anhand der Regeln überladener Funktionen die näherliegende ausgewählt. Da die [[variadische Funktion]] keine [[Typsicherheit]] bietet, wird die erste Funktion (die, die einen <code>TrueType</code> zurückgibt) bevorzugt. Wird hingegen <code>T = int</code> eingegeben, so wird die erste Funktion aus der Menge der infrage kommenden Überladungen ausgeschieden. Dies erzeugt dank SFINAE keinen Kompilierfehler. Es wird außerdem die Tatsache ausgenutzt, dass der Wert <code>0</code> in C++ implizit in einen [[Nullwert\|Nullzeiger]] konvertiert werden kann.

	Ein beliebter Einsatzort von SFINAE ist das Rest~~ringieren~~ bzw. ein Spezialisieren auf Typen, die eine bestimmte Gemeinsamkeit teilen. Ein Beispiel:		Ein beliebter Einsatzort von SFINAE ist das Restringieren bzw. ein Spezialisieren auf Typen, die eine bestimmte Gemeinsamkeit teilen. Ein Beispiel:
	<syntaxhighlight lang="cpp">		<syntaxhighlight lang="cpp">
	#include <iostream>		#include <iostream>

62.2.105.234: /* Beispiele */An dem hatte ich zu beissen.

2022-09-12T16:33:48Z

Beispiele: An dem hatte ich zu beissen.

← Nächstältere Version		Version vom 12. September 2022, 18:33 Uhr
Zeile 39:		Zeile 39:
	}		}
	</syntaxhighlight>		</syntaxhighlight>
	Die Rückgabewerte der <code>Tester</code>-Funktion sind [[Referenz (Programmierung)\|Referenzen]], da in C++ bekanntlich keine Arrays zurückgegeben werden können. Der <code>sizeof</code>-Operator gibt beim Anwenden auf eine Referenz die Größe des referenzierten Types zurück. Beim Anwenden auf einen vermeintlichen Funktionsaufruf (also auf eine Funktion inkl. Funktionsargumente) wird die Größe des Rückgabewertes angegeben. Da die Funktion in Tat und Wahrheit nie wirklich aufgerufen wird, ist keine Funktionsdefinition vonnöten. Um die Größe des Rückgabewertes angeben zu können, muss zuerst die korrekte Funktion ausgewählt werden. Wird als Template-Argument <code>T = Foo</code> gewählt, so sind beide Überladungen korrekt. In diesem Fall wird anhand der Regeln überladener Funktionen die näherliegende ausgewählt. Da die [[variadische Funktion]] keine [[Typsicherheit]] bietet, wird die erste Funktion (die, die einen <code>TrueType</code> zurückgibt) bevorzugt. Wird hingegen <code>T = int</code> eingegeben, so wird die erste Funktion aus der Menge der infrage kommenden Überladungen ausgeschieden. Dies erzeugt dank SFINAE keinen Kompilierfehler. Es wird außerdem die Tatsache ausgenutzt, dass der Wert <code>0</code> in C++ implizit in einen [[Nullwert\|Nullzeiger]] konvertiert werden kann.		Die Rückgabewerte der <code>Tester</code>-Funktion sind [[Referenz (Programmierung)\|Referenzen]], da in C++ bekanntlich keine Arrays zurückgegeben werden können. Der <code>sizeof</code>-Operator gibt beim Anwenden auf eine Referenz die Größe des referenzierten Types zurück. Beim Anwenden auf einen vermeintlichen Funktionsaufruf (also auf eine Funktion inkl. Funktionsargumente) wird die Größe des Rückgabewertes angegeben. Da die Funktion in Tat und Wahrheit nie wirklich aufgerufen wird, ist keine Funktionsdefinition vonnöten. Um die Größe des Rückgabewertes angeben zu können, muss zuerst die korrekte Funktion ausgewählt werden. Wird als Template-Argument <code>T = Foo</code> gewählt, so sind beide Überladungen korrekt, weil Foo::Type eruierbar ist. In diesem Fall wird anhand der Regeln überladener Funktionen die näherliegende ausgewählt. Da die [[variadische Funktion]] keine [[Typsicherheit]] bietet, wird die erste Funktion (die, die einen <code>TrueType</code> zurückgibt) bevorzugt. Wird hingegen <code>T = int</code> eingegeben, so wird die erste Funktion aus der Menge der infrage kommenden Überladungen ausgeschieden. Dies erzeugt dank SFINAE keinen Kompilierfehler. Es wird außerdem die Tatsache ausgenutzt, dass der Wert <code>0</code> in C++ implizit in einen [[Nullwert\|Nullzeiger]] konvertiert werden kann.

	Ein beliebter Einsatzort von SFINAE ist das Restringieren bzw. ein Spezialisieren auf Typen, die eine bestimmte Gemeinsamkeit teilen. Ein Beispiel:		Ein beliebter Einsatzort von SFINAE ist das Restringieren bzw. ein Spezialisieren auf Typen, die eine bestimmte Gemeinsamkeit teilen. Ein Beispiel:

Aka: /* Weblinks */ https

2021-04-21T17:02:47Z

Weblinks: https

← Nächstältere Version		Version vom 21. April 2021, 19:02 Uhr
Zeile 78:		Zeile 78:

	== Weblinks ==		== Weblinks ==
	* [~~http~~://en.cppreference.com/w/cpp/language/sfinae SFINAE – cppreference.com]		* [https://en.cppreference.com/w/cpp/language/sfinae SFINAE – cppreference.com]

	[[Kategorie:C++]]		[[Kategorie:C++]]

64.214.147.58: Der überarbeitete Satz war eindeutig falsch (int kann nicht implizit in Zeiger konvertiert werden, mit Ausnahme von 0 für Nullpointer, C++14 Standard 4.10.1)

2016-02-15T14:48:51Z

Der überarbeitete Satz war eindeutig falsch (int kann nicht implizit in Zeiger konvertiert werden, mit Ausnahme von 0 für Nullpointer, C++14 Standard 4.10.1)

← Nächstältere Version		Version vom 15. Februar 2016, 16:48 Uhr
Zeile 39:		Zeile 39:
	}		}
	</syntaxhighlight>		</syntaxhighlight>
	Die Rückgabewerte der <code>Tester</code>-Funktion sind [[Referenz (Programmierung)\|Referenzen]], da in C++ bekanntlich keine Arrays zurückgegeben werden können. Der <code>sizeof</code>-Operator gibt beim Anwenden auf eine Referenz die Größe des referenzierten Types zurück. Beim Anwenden auf einen vermeintlichen Funktionsaufruf (also auf eine Funktion inkl. Funktionsargumente) wird die Größe des Rückgabewertes angegeben. Da die Funktion in Tat und Wahrheit nie wirklich aufgerufen wird, ist keine Funktionsdefinition vonnöten. Um die Größe des Rückgabewertes angeben zu können, muss zuerst die korrekte Funktion ausgewählt werden. Wird als Template-Argument <code>T = Foo</code> gewählt, so sind beide Überladungen korrekt. In diesem Fall wird anhand der Regeln überladener Funktionen die näherliegende ausgewählt. Da die [[variadische Funktion]] keine [[Typsicherheit]] bietet, wird die erste Funktion (die, die einen <code>TrueType</code> zurückgibt) bevorzugt. Wird hingegen <code>T = int</code> eingegeben, so wird die erste Funktion aus der Menge der infrage kommenden Überladungen ausgeschieden. Dies erzeugt dank SFINAE keinen Kompilierfehler. Es wird außerdem die Tatsache ausgenutzt, dass <code>~~int~~</code>s in C++ implizit in [[~~Zeiger (Informatik)~~\|~~Zeiger~~]] konvertiert werden.		Die Rückgabewerte der <code>Tester</code>-Funktion sind [[Referenz (Programmierung)\|Referenzen]], da in C++ bekanntlich keine Arrays zurückgegeben werden können. Der <code>sizeof</code>-Operator gibt beim Anwenden auf eine Referenz die Größe des referenzierten Types zurück. Beim Anwenden auf einen vermeintlichen Funktionsaufruf (also auf eine Funktion inkl. Funktionsargumente) wird die Größe des Rückgabewertes angegeben. Da die Funktion in Tat und Wahrheit nie wirklich aufgerufen wird, ist keine Funktionsdefinition vonnöten. Um die Größe des Rückgabewertes angeben zu können, muss zuerst die korrekte Funktion ausgewählt werden. Wird als Template-Argument <code>T = Foo</code> gewählt, so sind beide Überladungen korrekt. In diesem Fall wird anhand der Regeln überladener Funktionen die näherliegende ausgewählt. Da die [[variadische Funktion]] keine [[Typsicherheit]] bietet, wird die erste Funktion (die, die einen <code>TrueType</code> zurückgibt) bevorzugt. Wird hingegen <code>T = int</code> eingegeben, so wird die erste Funktion aus der Menge der infrage kommenden Überladungen ausgeschieden. Dies erzeugt dank SFINAE keinen Kompilierfehler. Es wird außerdem die Tatsache ausgenutzt, dass der Wert <code>0</code> in C++ implizit in einen [[Nullwert\|Nullzeiger]] konvertiert werden kann.

	Ein beliebter Einsatzort von SFINAE ist das Restringieren bzw. ein Spezialisieren auf Typen, die eine bestimmte Gemeinsamkeit teilen. Ein Beispiel:		Ein beliebter Einsatzort von SFINAE ist das Restringieren bzw. ein Spezialisieren auf Typen, die eine bestimmte Gemeinsamkeit teilen. Ein Beispiel:

EricSchreyer: Lesbarkeit

2015-08-11T10:15:52Z

Lesbarkeit

← Nächstältere Version		Version vom 11. August 2015, 12:15 Uhr
Zeile 1:		Zeile 1:
	'''Substitution failure is not an error''' ('''SFINAE''') ist eine Programmiertechnik in der Programmiersprache [[C++]]. Dabei wird die Tatsache ausgenutzt, dass eine fehlgeschlagene Substitution von [[Template (Programmierung)\|Template]]-Argumenten keinen Kompilierfehler erzeugt.		'''Substitution failure is not an error''' ('''SFINAE''') ist eine Programmiertechnik in der Programmiersprache [[C++]]. Dabei wird die Tatsache ausgenutzt, dass eine fehlgeschlagene Substitution von [[Template (Programmierung)\|Template]]-Argumenten keinen Kompilierfehler erzeugt.

	Ist beispielsweise eine [[Funktion (Programmierung)\|Funktion]] mehrfach [[überladen]] und sind gewisse Kandidaten das Ergebnis der Instanziierung eines Funktionstemplates mit möglicherweise deduzierten Template-Argumenten, so wird – sofern die Substitution der Template-Argumente fehlgeschlagen ist – die Überladung aus der Menge der Kandidaten entfernt, ohne dass der Kompiliervorgang mit einem Kompilierfehler abgebrochen wird. Sind die ~~schlussendlich~~ verbliebenen Kandidaten mehrdeutig, beispielsweise weil sie dieselbe [[Signatur (Programmierung)\|Signatur]] haben und sich nur durch den Rückgabewert unterscheiden, oder sind ~~schlussendlich~~ keine Kandidaten für den Funktionsaufruf mehr vorhanden, so wird dennoch wie üblich ein Kompilierfehler erzeugt.		Ist beispielsweise eine [[Funktion (Programmierung)\|Funktion]] mehrfach [[überladen]] und sind gewisse Kandidaten das Ergebnis der Instanziierung eines Funktionstemplates mit möglicherweise deduzierten Template-Argumenten, so wird – sofern die Substitution der Template-Argumente fehlgeschlagen ist – die Überladung aus der Menge der Kandidaten entfernt, ohne dass der Kompiliervorgang mit einem Kompilierfehler abgebrochen wird. Sind die schließlich verbliebenen Kandidaten mehrdeutig, beispielsweise weil sie dieselbe [[Signatur (Programmierung)\|Signatur]] haben und sich nur durch den Rückgabewert unterscheiden, oder sind keine Kandidaten für den Funktionsaufruf mehr vorhanden, so wird dennoch wie üblich ein Kompilierfehler erzeugt.

	== Beispiele ==		== Beispiele ==

195.83.139.7: Englischsprachinge duch deutschsprachigen Begriff ersetzt

2014-10-07T13:29:26Z

Englischsprachinge duch deutschsprachigen Begriff ersetzt

← Nächstältere Version		Version vom 7. Oktober 2014, 15:29 Uhr
Zeile 1:		Zeile 1:
	'''Substitution failure is not an error''' ('''SFINAE''') ist eine Programmiertechnik in der Programmiersprache [[C++]]. Dabei wird die Tatsache ausgenutzt, dass eine fehlgeschlagene Substitution von [[Template (Programmierung)\|Template]]-Argumenten keinen Kompilierfehler erzeugt.		'''Substitution failure is not an error''' ('''SFINAE''') ist eine Programmiertechnik in der Programmiersprache [[C++]]. Dabei wird die Tatsache ausgenutzt, dass eine fehlgeschlagene Substitution von [[Template (Programmierung)\|Template]]-Argumenten keinen Kompilierfehler erzeugt.

	Ist beispielsweise eine [[Funktion (Programmierung)\|Funktion]] mehrfach [[überladen]] und sind gewisse Kandidaten das Ergebnis der Instanziierung eines Funktionstemplates mit möglicherweise deduzierten Template-Argumenten, so wird – sofern die Substitution der Template-Argumente fehlgeschlagen ist – die Überladung aus der Menge der Kandidaten entfernt, ohne dass der Kompiliervorgang mit einem Kompilierfehler abgebrochen wird. Sind die schlussendlich verbliebenen Kandidaten ~~ambiguos~~, beispielsweise weil sie dieselbe [[Signatur (Programmierung)\|Signatur]] haben und sich nur durch den Rückgabewert unterscheiden, oder sind schlussendlich keine Kandidaten für den Funktionsaufruf mehr vorhanden, so wird dennoch wie üblich ein Kompilierfehler erzeugt.		Ist beispielsweise eine [[Funktion (Programmierung)\|Funktion]] mehrfach [[überladen]] und sind gewisse Kandidaten das Ergebnis der Instanziierung eines Funktionstemplates mit möglicherweise deduzierten Template-Argumenten, so wird – sofern die Substitution der Template-Argumente fehlgeschlagen ist – die Überladung aus der Menge der Kandidaten entfernt, ohne dass der Kompiliervorgang mit einem Kompilierfehler abgebrochen wird. Sind die schlussendlich verbliebenen Kandidaten mehrdeutig, beispielsweise weil sie dieselbe [[Signatur (Programmierung)\|Signatur]] haben und sich nur durch den Rückgabewert unterscheiden, oder sind schlussendlich keine Kandidaten für den Funktionsaufruf mehr vorhanden, so wird dennoch wie üblich ein Kompilierfehler erzeugt.

	== Beispiele ==		== Beispiele ==

Aka: Tippfehler entfernt

2014-07-24T17:12:33Z

Tippfehler entfernt

← Nächstältere Version		Version vom 24. Juli 2014, 19:12 Uhr
Zeile 18:		Zeile 18:
	template<typename U>		template<typename U>
	static TrueType& Tester(typename U::Type*);		static TrueType& Tester(typename U::Type*);


	template<typename>		template<typename>
	static FalseType& Tester(...);		static FalseType& Tester(...);
Zeile 39:		Zeile 39:
	}		}
	</syntaxhighlight>		</syntaxhighlight>
	Die Rückgabewerte der <code>Tester</code>-Funktion sind [[Referenz (Programmierung)\|Referenzen]], da in C++ bekanntlich keine Arrays zurückgegeben werden können. Der <code>sizeof</code>-Operator gibt beim Anwenden auf eine Referenz die Größe des referenzierten Types zurück. Beim Anwenden auf einen vermeintlichen Funktionsaufruf (also auf eine Funktion inkl. Funktionsargumente) wird die Größe des Rückgabewertes angegeben. Da die Funktion in Tat und Wahrheit nie wirklich aufgerufen wird, ist keine Funktionsdefinition ~~von Nöten~~. Um die Größe des Rückgabewertes angeben zu können, muss zuerst die korrekte Funktion ausgewählt werden. Wird als Template-Argument <code>T = Foo</code> gewählt, so sind beide Überladungen korrekt. In diesem Fall wird anhand der Regeln überladener Funktionen die näherliegende ausgewählt. Da die [[variadische Funktion]] keine [[Typsicherheit]] bietet, wird die erste Funktion (die, die einen <code>TrueType</code> zurückgibt) bevorzugt. Wird hingegen <code>T = int</code> eingegeben, so wird die erste Funktion aus der Menge der infrage kommenden Überladungen ausgeschieden. Dies erzeugt dank SFINAE keinen Kompilierfehler. Es wird außerdem die Tatsache ausgenutzt, dass <code>int</code>s in C++ implizit in [[Zeiger (Informatik)\|Zeiger]] konvertiert werden.		Die Rückgabewerte der <code>Tester</code>-Funktion sind [[Referenz (Programmierung)\|Referenzen]], da in C++ bekanntlich keine Arrays zurückgegeben werden können. Der <code>sizeof</code>-Operator gibt beim Anwenden auf eine Referenz die Größe des referenzierten Types zurück. Beim Anwenden auf einen vermeintlichen Funktionsaufruf (also auf eine Funktion inkl. Funktionsargumente) wird die Größe des Rückgabewertes angegeben. Da die Funktion in Tat und Wahrheit nie wirklich aufgerufen wird, ist keine Funktionsdefinition vonnöten. Um die Größe des Rückgabewertes angeben zu können, muss zuerst die korrekte Funktion ausgewählt werden. Wird als Template-Argument <code>T = Foo</code> gewählt, so sind beide Überladungen korrekt. In diesem Fall wird anhand der Regeln überladener Funktionen die näherliegende ausgewählt. Da die [[variadische Funktion]] keine [[Typsicherheit]] bietet, wird die erste Funktion (die, die einen <code>TrueType</code> zurückgibt) bevorzugt. Wird hingegen <code>T = int</code> eingegeben, so wird die erste Funktion aus der Menge der infrage kommenden Überladungen ausgeschieden. Dies erzeugt dank SFINAE keinen Kompilierfehler. Es wird außerdem die Tatsache ausgenutzt, dass <code>int</code>s in C++ implizit in [[Zeiger (Informatik)\|Zeiger]] konvertiert werden.

	Ein beliebter Einsatzort von SFINAE ist das Restringieren bzw. ein Spezialisieren auf Typen, die eine bestimmte Gemeinsamkeit teilen. Ein Beispiel:		Ein beliebter Einsatzort von SFINAE ist das Restringieren bzw. ein Spezialisieren auf Typen, die eine bestimmte Gemeinsamkeit teilen. Ein Beispiel:

Wikinger08: /* Weblinks */

2014-06-30T09:43:06Z

Weblinks

← Nächstältere Version		Version vom 30. Juni 2014, 11:43 Uhr
Zeile 78:		Zeile 78:

	== Weblinks ==		== Weblinks ==
	* [http://en.cppreference.com/w/cpp/language/sfinae SFINAE - cppreference.com]		* [http://en.cppreference.com/w/cpp/language/sfinae SFINAE – cppreference.com]

	[[Kategorie:C++]]		[[Kategorie:C++]]

Wikinger08: /* Beispiele */ Typo; Interpunktion; Grammatik

2014-06-30T09:41:58Z

Beispiele: Typo; Interpunktion; Grammatik

← Nächstältere Version		Version vom 30. Juni 2014, 11:41 Uhr
Zeile 4:		Zeile 4:

	== Beispiele ==		== Beispiele ==
	Als Standardbeispiel sei ein Konstrukt genannt, ~~welches~~ von einem Typen <code>T</code> bestimmt, ob <code>T::Type</code> ebenfalls ein Typ ist.		Als Standardbeispiel sei ein Konstrukt genannt, das von einem Typen <code>T</code> bestimmt, ob <code>T::Type</code> ebenfalls ein Typ ist.
	<syntaxhighlight lang="cpp">		<syntaxhighlight lang="cpp">
	#include <iostream>		#include <iostream>
Zeile 11:		Zeile 11:
	class HasType		class HasType
	{		{
	// Es werden zwei Typen benötigt, die unterschiedlich ~~gross~~ sind, sodass man sie mit sizeof differenzieren kann:		// Es werden zwei Typen benötigt, die unterschiedlich groß sind, sodass man sie mit sizeof differenzieren kann:
	typedef char FalseType[1];		typedef char FalseType[1];
	typedef char TrueType[2];		typedef char TrueType[2];
Zeile 23:		Zeile 23:

	public:		public:
	// Die gesammelte Information wird mit einem einfachen booleschen Wert nach ~~aussen~~ gegeben:		// Die gesammelte Information wird mit einem einfachen booleschen Wert nach außen gegeben:
	static const bool Value = sizeof(Tester<T>(0)) == sizeof(TrueType);		static const bool Value = sizeof(Tester<T>(0)) == sizeof(TrueType);
	};		};
Zeile 39:		Zeile 39:
	}		}
	</syntaxhighlight>		</syntaxhighlight>
	Die Rückgabewerte der <code>Tester</code>-Funktion sind [[Referenz (Programmierung)\|Referenzen]], da in C++ bekanntlich keine Arrays zurückgegeben werden können. Der <code>sizeof</code>-Operator gibt beim Anwenden auf eine Referenz die Größe des referenzierten Types zurück. Beim Anwenden auf einen vermeintlichen Funktionsaufruf (also auf eine Funktion inkl. Funktionsargumente) wird die Größe des Rückgabewertes angegeben. Da die Funktion in Tat und Wahrheit nie wirklich aufgerufen wird, ist keine Funktionsdefinition von Nöten. Um die Größe des Rückgabewertes angeben zu können, muss zuerst die korrekte Funktion ausgewählt werden. Wird als Template-Argument <code>T = Foo</code> gewählt, so sind beide Überladungen korrekt. In diesem Fall wird anhand der Regeln überladener Funktionen die näherliegende ausgewählt. Da die [[variadische Funktion]] keine [[Typsicherheit]] bietet, wird die erste Funktion (die die einen <code>TrueType</code> zurückgibt) bevorzugt. Wird hingegen <code>T = int</code> eingegeben, so wird die erste Funktion aus der Menge der infrage kommenden Überladungen ausgeschieden. Dies erzeugt dank SFINAE keinen Kompilierfehler. Es wird ~~ausserdem~~ die Tatsache ausgenutzt, dass <code>int</code>s in C++ implizit in [[Zeiger (Informatik)\|Zeiger]] konvertiert werden.		Die Rückgabewerte der <code>Tester</code>-Funktion sind [[Referenz (Programmierung)\|Referenzen]], da in C++ bekanntlich keine Arrays zurückgegeben werden können. Der <code>sizeof</code>-Operator gibt beim Anwenden auf eine Referenz die Größe des referenzierten Types zurück. Beim Anwenden auf einen vermeintlichen Funktionsaufruf (also auf eine Funktion inkl. Funktionsargumente) wird die Größe des Rückgabewertes angegeben. Da die Funktion in Tat und Wahrheit nie wirklich aufgerufen wird, ist keine Funktionsdefinition von Nöten. Um die Größe des Rückgabewertes angeben zu können, muss zuerst die korrekte Funktion ausgewählt werden. Wird als Template-Argument <code>T = Foo</code> gewählt, so sind beide Überladungen korrekt. In diesem Fall wird anhand der Regeln überladener Funktionen die näherliegende ausgewählt. Da die [[variadische Funktion]] keine [[Typsicherheit]] bietet, wird die erste Funktion (die, die einen <code>TrueType</code> zurückgibt) bevorzugt. Wird hingegen <code>T = int</code> eingegeben, so wird die erste Funktion aus der Menge der infrage kommenden Überladungen ausgeschieden. Dies erzeugt dank SFINAE keinen Kompilierfehler. Es wird außerdem die Tatsache ausgenutzt, dass <code>int</code>s in C++ implizit in [[Zeiger (Informatik)\|Zeiger]] konvertiert werden.

	Ein beliebter Einsatzort von SFINAE ist das Restringieren bzw. ein Spezialisieren auf Typen, die eine bestimmte Gemeinsamkeit teilen. Ein Beispiel:		Ein beliebter Einsatzort von SFINAE ist das Restringieren bzw. ein Spezialisieren auf Typen, die eine bestimmte Gemeinsamkeit teilen. Ein Beispiel:
Zeile 73:		Zeile 73:
	}		}
	</syntaxhighlight>		</syntaxhighlight>
	Wegen ~~den~~ Default-Template-~~Argumenten~~ ist das Programm nicht in C++03 lauffähig sondern erst in C++11. Die Elemente <code>std::enable_if</code> etc. hingegen sind auch in C++03 implementierbar.		Wegen der Default-Template-Argumente ist das Programm nicht in C++03 lauffähig, sondern erst in C++11. Die Elemente <code>std::enable_if</code> etc. hingegen sind auch in C++03 implementierbar.

	Dank SFINAE spart man sich hier das separate Spezialisieren des Funktionstemplates auf alle einzelnen [[Integer (Datentyp)\|integralen]] bzw. [[Fließkommazahl\|Fließkommatypen]].		Dank SFINAE spart man sich hier das separate Spezialisieren des Funktionstemplates auf alle einzelnen [[Integer (Datentyp)\|integralen]] bzw. [[Fließkommazahl\|Fließkommatypen]].

	== Weblinks ==		== Weblinks ==
	* [http://en.cppreference.com/w/cpp/language/sfinae SFINAE - cppreference.com]		* [http://en.cppreference.com/w/cpp/language/sfinae SFINAE - cppreference.com]

Fytcha: Asfdlol verschob die Seite Benutzer:Asfdlol/Substitution failure is not an error nach Substitution failure is not an error: Artikel fertig gestellt

2014-06-26T11:59:39Z

Asfdlol verschob die Seite Benutzer:Asfdlol/Substitution failure is not an error nach Substitution failure is not an error: Artikel fertig gestellt

← Nächstältere Version	Version vom 26. Juni 2014, 13:59 Uhr
(kein Unterschied)