~2026-15034-40: /* Beispiele */

2026-03-10T00:07:55Z

Beispiele

Neue Seite

Ein '''Quine''' ist eine Art von [[Computerprogramm]], das eine Kopie seiner selbst (üblicherweise seines [[Quelltext]]es) als Ausgabe schreibt. Es handelt sich somit um eine Form der [[Selbstbezüglichkeit]].

[[Hacker]] und [[Geek]]s sehen es als sportliche Herausforderung, die kleinstmöglichen Quines in [[Programmiersprache]]n ihrer Wahl zu erstellen (siehe [[International Obfuscated C Code Contest|IOCCC]]).

Quines sind nach dem Logiker und Philosophen [[Willard Van Orman Quine]] benannt.

== Konstruktion von Quines ==
=== Frage dich selbst ===
Ein Quine ließe sich in einem [[C (Programmiersprache)|C]]-ähnlichen Pseudo-Code so schreiben<ref>Craig S. Kaplan: ''[http://www.cgl.uwaterloo.ca/~csk/washington//paper/index.html The Search For Self-Documenting Code]''</ref>

<syntaxhighlight lang="c">
main() {
print myself out.
}
</syntaxhighlight>

Üblicherweise werden C-Programme [[Compiler|übersetzt]], d. h. die [[Laufzeit (Informatik)|Laufzeitversion]] des Programms liegt in [[Maschinensprache]] vor (Repräsentation als Folge von [[Byte]]s, abgespeichert in einer sogenannten binären Datei), seine ursprüngliche Repräsentation ist jedoch in der Regel ein [[American Standard Code for Information Interchange|ASCII]]-codierter Quelltext, der zudem noch in einer anderen Datei abgelegt ist.
Der für diesen Ansatz zur Implementierung eines Quines benötigte Zugriff auf die eigene Repräsentation (''myself'') wäre also sehr kompliziert.

Weiter fordert man für ein Quine, dass es abgeschlossen ist:

* Es soll ohne Zugriff auf externe Daten auskommen, womit auch der Zugriff auf die eigene Quelltextdatei ausgeschlossen ist.
* Ebenso soll der wesentliche Code im Quine selbst vorhanden sein, weshalb externe Funktionen nur spärlich genutzt werden sollen, die Bibliotheksfunktion ''ein Zeichen ausgeben'' etwa ist noch zulässig.

Nur wenige Sprachen unterstützen Selbstbezüglichkeit ([[Reflexion (Programmierung)|Reflexion]]) in der Form, dass ein Programm dieser Sprache Zugriff auf seine eigene Repräsentation hat.

Eine [[Interpreter|interpretierte]] Programmiersprache, wie zum Beispiel [[Perl (Programmiersprache)|Perl]] oder [[Python (Programmiersprache)|Python]], hätte es prinzipiell leichter, da man die vom Interpreter benötigte Repräsentation des auszuführenden Programms auch dem selbigen verfügbar machen könnte, aber in der Regel wird das nicht unterstützt, zum Beispiel aus Sicherheitsgründen, oder weil die Designer der Sprache nicht so weit gehen wollten (zum Beispiel weil [[selbstmodifizierender Code]] abgelehnt wird).
Meist ist dem Programm dort nicht viel mehr Reflexion möglich, als seinen Namen und die Namen seiner Variablen und Funktionen vom Laufzeitsystem zu erfahren.

Reflexion führt daher in den meisten Programmiersprachen nicht zu einem korrekten Quine.

=== Code als Daten ===
Die meisten Programmiersprachen bieten wenig Hilfe, Programme angemessen intern zu repräsentieren und mit diesen Repräsentationen zu arbeiten:

* sie zu analysieren ([[Parser|Parsen]]),
* aus vorhandenen Repräsentationen neue Programme zu erzeugen ([[Komposition (UML)|Komposition]]) und insbesondere
* das repräsentierte Programm auszuführen ([[Auswertung (Informatik)|Applikation]]).

Ein bekanntes Anwendungsbeispiel wäre ein [[Funktionsplotter]], das ist ein Programm zum [[Plotter|Plotten]] der [[Funktionsgraph|Graphen]] beliebiger mathematischer Funktionen.

Mit anderen Worten:

''Für Funktionen gibt es in vielen Programmiersprachen keinen angemessenen Datentyp mit entsprechenden Operationen.''

In C kann man ein Stück Programmcode in einer [[Zeichenkette]] ablegen, man kann aber wenig damit anfangen, denn dieser ist mit den Mitteln von C nur aufwendig zu analysieren und auszuführen.
Man muss dann zu komplexen verpointerten Strukturen und externen Bibliotheken greifen.

Ein positives Beispiel ist [[LISP]], weil diese Sprache Quellcode im algebraischen Datentyp ''Liste'' darstellt, den sie auch selbst hauptsächlich verwendet ([[Homoikonizität]]).

=== Quinierung ===
Die obigen Ausführungen haben die Schwierigkeit aufgeführt, die ein Programm hat, falls es seine eigene Struktur erfragen will. Dennoch muss es auch in C möglich sein, einen Quine zu realisieren (siehe die Ausführungen zur Existenz von Quines im Theorieteil). Dazu wird folgende Technik verwendet:

''Wenn man die eigene Struktur nicht erfragen kann, muss man sie von vornherein wissen.''

Man entwirft das Programm in zwei Teilen, in einen, den man den Code nennt, und einen, den man die Daten nennt. Die Daten repräsentieren den Code (bzw. seine Textform) und sie sind auf einem algorithmischen Weg vom Code hergeleitet (meistens, indem Anführungszeichen gesetzt wurden, manchmal aber noch auf eine leicht kompliziertere Weise).
Der Code benutzt die Daten, um den Code auszugeben (was einfach ist, da die Daten den Code darstellen); dann benutzt er die Daten, um die Daten auszugeben (was möglich ist, da die Daten in einer algorithmischen Transformation besorgt werden).

Wie oben ausgeführt, ist dies in einigen Sprachen leichter und in anderen schwieriger umzusetzen, zum Beispiel je nachdem, ob Funktionen ''[[First-Class-Funktion|first class citizens]]'' der Sprache sind oder nicht.

Im strengen Sinn sollten Quines vom Zeichensatz unabhängig sein, und der Quellcode sollte einschließlich aller Zeilenwechsel exakt wieder ausgegeben werden.

== Beispiele ==

{| class="wikitable sortable"
|- class="hintergrundfarbe5"
! Sprache !! class="unsortable"|Beispiel !! class="unsortable"|Hinweise
|-
| [[Lisp]] ||
<syntaxhighlight lang="lisp">
((lambda (x)
(list x (list (quote quote) x)))
(quote
(lambda (x)
(list x (list (quote quote) x)))))
</syntaxhighlight>
||Benötigt als einziges Beispiel keinen Datentyp "String"
|-
| [[Go (Programmiersprache)|Go]] ||
<syntaxhighlight lang="go">
package main
import "fmt"
func main() {
fmt.Printf("%s%c%s%c\n", s, 0x60, s, 0x60)
}
var s = `
package main
import "fmt"
func main {
fmt.Printf("%s%c%s%c\n", s, 0x60, s, 0x60)
}
var s = `
</syntaxhighlight>
||Nutzt die ASCII-Kodierung des Akzents Grave
|-
| [[C (Programmiersprache)|C]] ||
<syntaxhighlight lang="c">
#include <stdio.h>
char*f="#include <stdio.h>%cchar*f=%c%s%c;int main() {printf(f,10,34,f,34,10);}%c";int main() {printf(f,10,34,f,34,10);}

</syntaxhighlight>
|| Nutzt die ASCII-Kodierung des Anführungszeichens
|-
| [[Lua]] ||
<syntaxhighlight lang="lua">
a="a=%q print(a:format(a))" print(a:format(a))

</syntaxhighlight>
|| Vom Zeichensatz unabhängig
|-
| [[Python (Programmiersprache)|Python 2]] ||
<syntaxhighlight lang="python">
a="a=%c%s%c;print a%%(34,a,34)";print a%(34,a,34)
</syntaxhighlight>
|| Nutzt die ASCII-Kodierung des Anführungszeichens
|-
| [[Python (Programmiersprache)|Python 3]] ||
<syntaxhighlight lang="python">
a="a=%c%s%c;print(a%%(34,a,34))";print(a%(34,a,34))
</syntaxhighlight>
|| Nutzt die ASCII-Kodierung des Anführungszeichens
|-
| [[Perl (Programmiersprache)|Perl]] ||
<syntaxhighlight lang="perl">
$a='$a=%c%s%c;printf($a,39,$a,39,10);%c';printf($a,39,$a,39,10);
</syntaxhighlight>
|| Nutzt die ASCII-Kodierung des Hochkommas
|-
| Perl ||
<syntaxhighlight lang="perl">
$r='\'; $_=$r; s/([\\\'\\\\])/\\\\$1/g; print \'$r=\\\'\'.$_.$r;
'; $_=$r; s/([\'\\])/\\$1/g; print '$r=\''.$_.$r;
</syntaxhighlight>
|| Vom Zeichensatz unabhängig
|-
|Perl6
|<syntaxhighlight lang="perl6">
my $t="; say \"my \\\$t=\",\$t.perl,\$t"; say "my \$t=",$t.perl,$t
</syntaxhighlight>
|
|-
| [[Ruby (Programmiersprache)|Ruby]] ||
<syntaxhighlight lang="ruby">
puts <<2*2,2
puts <<2*2,2
2
</syntaxhighlight>
|| Vom Zeichensatz unabhängig
|-
| Ruby ||
<syntaxhighlight lang="ruby">
eval s=%q(puts"eval s=%q(#{s})")
</syntaxhighlight>
|| Vom Zeichensatz unabhängig
|-
| [[Rust_(Programmiersprache)|Rust]] ||
<syntaxhighlight lang="rust">
fn main() {
let x = "fn main() {\n let x = ";
let y = "print!(\"{}{:?};\n let y = {:?};\n {}\", x, x, y, y)\n}\n";
print!("{}{:?};
let y = {:?};
{}", x, x, y, y)
}
</syntaxhighlight>
||
|-
| [[C-Sharp|C#]] ||
<syntaxhighlight lang="csharp">
var f="var f={1}{0}{1};Console.Write(f,f,(char)34);";Console.Write(f,f,(char)34);
</syntaxhighlight>
||Möglich ab C# 9 durch Top-Level-Statements
|-
| [[Java (Programmiersprache)|Java]] ||
<syntaxhighlight lang="java">
class Q{public static void main(String[]a){String f=
"class Q{public static void main(String[]a){String f=%c%s%1$c;System.out.printf(f,34,f);}}";
System.out.printf(f,34,f);}}
</syntaxhighlight>
||Nur eine Zeile
|-
| [[Kotlin (Programmiersprache)|Kotlin]] ||
<syntaxhighlight lang="kotlin">
fun main(args: Array<String>){val f="""fun main(args: Array<String>){val f="%s"%s"%s";System.out.printf(f,'"',f,'"')}""";System.out.printf(f,'"',f,'"')}
</syntaxhighlight>
||Nur eine Zeile, vom Zeichensatz unabhängig
|-
| [[JavaScript]] ||
<syntaxhighlight lang="javascript">
(x=>console.log(x+JSON.stringify(x)+')'))("(x=>console.log(x+JSON.stringify(x)+')'))(")
</syntaxhighlight>
||
|-
| [[Sleep (Programmiersprache)|Sleep]] ||
<syntaxhighlight lang="php">
[{$s = ';print("[{\$s = ".chr(39).$s.chr(39).$s);}]';print("[{\$s = ".chr(39).$s.chr(39).$s);}]
</syntaxhighlight>
||
|-
| [[PHP]] ||
<syntaxhighlight lang="php">
<?php printf($c = '<?php printf($c = %c%s%c, 39, $c, 39); ?>', 39, $c, 39); ?>
</syntaxhighlight>
||
|-
| [[Pascal (Programmiersprache)|Pascal]] ||
<syntaxhighlight lang="pascal">
const a=';begin write(^#^/^.^3^4^`^!^}#39,a,#39,a)end.';begin write(^#^/^.^3^4^`^!^}#39,a,#39,a)end.
</syntaxhighlight>
|| Nutzt Escape-Sequenzen
|-
| [[Embarcadero Delphi|Delphi]] ||
<syntaxhighlight lang="delphi">
program Quine;{$APPTYPE CONSOLE}var x:String=
'program Quine;{$APPTYPE CONSOLE}var x:String=;begin Insert(#39+x+#39,x,46);WriteLn(x);ReadLn;end.';
begin Insert(#39+x+#39,x,46);WriteLn(x);ReadLn;end.
</syntaxhighlight>
|| Ohne Zeilenumbrüche (wäre sonst zu lang für diese Tabelle)
|-
| [[Commodore_Basic_V2|Commodore 64 Basic V2]] ||
<syntaxhighlight lang="basic">
1 a$="5 q$=chr$(34):s$=chr$(36):g$=chr$(61):z$=chr$(157)"
2 b$="6 printz$;1;chr$(65)s$g$q$a$q$:printz$;2;chr$(66)s$g$q$b$q$"
3 c$="7 printz$;3;chr$(67)s$g$q$c$q$:printz$;4;chr$(68)s$g$q$d$q$"
4 d$="8 printa$:printb$:printc$:printd$"
5 q$=chr$(34):s$=chr$(36):g$=chr$(61):z$=chr$(157)
6 printz$;1;chr$(65)s$g$q$a$q$:printz$;2;chr$(66)s$g$q$b$q$
7 printz$;3;chr$(67)s$g$q$c$q$:printz$;4;chr$(68)s$g$q$d$q$
8 printa$:printb$:printc$:printd$
</syntaxhighlight>
|| Nutzt die ASCII-Kodierung des Anführungszeichens und der Buchstaben der Variablennamen
|}

== Theoretischer Hintergrund ==

Die Existenz von Quines wird theoretisch durch den [[Rekursionssatz]] (auch Fixpunktsatz von [[Kleene]] genannt) gesichert.

Grob verläuft die Argumentation so:

* Man kann auf die Eigenschaften von Programmiersprachen durch Ergebnisse der [[Berechenbarkeitstheorie]] schließen, welche sehr einfache Modelle von Programmen mathematisch exakt analysiert.
* Da man alle Programme (genauer: deren endliche Quelltexte) abzählen, also [[Bijektion|bijektiv]] auf die [[Natürliche Zahl|natürlichen Zahlen]] abbilden kann, reicht in dieser Modellwelt die Angabe einer natürlichen Zahl als Repräsentation eines Programms vollkommen aus. Diese Zahl leistet dasselbe wie der Quelltext, nämlich die Auswahl genau der Funktion, die der Semantik des Programms entspricht.
* Mit dem [[Fixpunktsatz von Kleene]] lässt sich zeigen, dass es ein Programm mit der Nummer <math>q</math> (mit <math>\forall x: \varphi_q(x) = q</math>) gibt, dessen Ausgabe (für alle möglichen Eingaben <math>x</math>) wiederum die Zahl <math>q</math> ist. Somit ist dieses <math>q</math> aus dem obigen [[Hilfssatz|Lemma]] der Berechenbarkeitstheorie genau das Äquivalent eines Programms, welches seine eigene Repräsentation ausgibt – eines Quines.

Die Aussagen aus der Berechenbarkeitstheorie für berechenbare Funktionen lassen sich leicht auf [[Turingmaschine]]n und damit letztlich auf beliebige [[Turing-Vollständigkeit|Turing-vollständige]] Sprachen verallgemeinern.

Quines sind daher nicht nur zufällig das Ergebnis findiger Programmierer, die eine Programmiersprache austricksen, es handelt sich vielmehr um eine fundamentale Eigenschaft Turing-vollständiger Programmiersprachen, dass für sie Quines existieren.

== Siehe auch ==
* [[HQ9+]] ([[Esoterische Programmiersprache]]): Gibt mittels des [[HQ9+#Befehlssatz|''Q''-Befehls]] den eigenen Quelltext aus.
* [[Reproduktion]]

== Literatur ==
* S. Barry Cooper: ''Computability Theory.'' Chapman & Hall/CRC mathematics, Boca Raton FL u. a. 2004, ISBN 1-58488-237-9.
* [[Douglas R. Hofstadter]]: ''[[Gödel, Escher, Bach]]. Ein Endloses Geflochtenes Band.'' 16. Auflage. Klett-Cotta, Stuttgart 2001, ISBN 3-608-94338-2.
* [[Ken Thompson]]: ''[http://cm.bell-labs.com/who/ken/trust.html Reflections on Trusting Trust]''. In: ''[[Communications of the ACM]].'' Vol. 27, No. 8, August 1984, S. 761–763.

== Weblinks ==
* [http://www.madore.org/~david/computers/quine.html Ausführliche Seite zu Quines] (englisch)
* [http://www.nyx.net/~gthompso/quine.htm Quines in vielen Sprachen] (englisch)

== Einzelnachweise ==
<references />

[[Kategorie:Programmierung]]
[[Kategorie:Theoretische Informatik]]
[[Kategorie:Berechenbarkeitstheorie]]

Quine (Computerprogramm) - Versionsgeschichte

~2026-15034-40: /* Beispiele */