Heute habe ich über die reine Funktion gelesen und bin mit ihrer Verwendung durcheinander gekommen:

Eine Funktion wird als rein bezeichnet, wenn sie denselben Satz von Werten für denselben Satz von Eingaben zurückgibt und keine beobachtbaren Nebenwirkungen hat.

z.B strlen() ist eine reine Funktion während rand() ist ein unreines.

__attribute__ ((pure)) int fun(int i)
{
    return i*i;
}

int main()
{
    int i=10;
    printf("%d",fun(i));//outputs 100
    return 0;
}

http://ideone.com/33XJU

Das obige Programm verhält sich genauso wie ohne pure Erklärung.

Was sind die Vorteile der Deklaration einer Funktion als pure[if there is no change in output]?

pure lässt den Compiler wissen, dass er bestimmte Optimierungen an der Funktion vornehmen kann: Stellen Sie sich ein bisschen Code wie vor

for (int i = 0; i < 1000; i++)
{
    printf("%d", fun(10));
}

Bei einer reinen Funktion kann der Compiler wissen, dass er auswerten muss fun(10) Einmal und nur einmal, statt 1000 Mal. Für eine komplexe Funktion ist das ein großer Gewinn.

Wenn Sie sagen, dass eine Funktion “rein” ist, garantieren Sie, dass sie keine äußerlich sichtbaren Nebenwirkungen hat (und wie ein Kommentar sagt, wenn Sie lügen, können schlimme Dinge passieren). Zu wissen, dass eine Funktion „rein“ ist, hat Vorteile für den Compiler, der dieses Wissen nutzen kann, um bestimmte Optimierungen vorzunehmen.

Hier ist, was die GCC-Dokumentation sagt über die pure Attribut:

rein

Viele Funktionen haben außer dem Rückgabewert keine Auswirkungen und ihr Rückgabewert hängt nur von den Parametern und/oder globalen Variablen ab. Eine solche Funktion kann genau wie ein arithmetischer Operator der Eliminierung gemeinsamer Unterausdrücke und der Schleifenoptimierung unterzogen werden. Diese Funktionen sollten mit dem Attribut pure deklariert werden. Zum Beispiel,

          int square (int) __attribute__ ((pure));

Die Antwort von Philip zeigt bereits, wie das Wissen, dass eine Funktion „rein“ ist, bei Schleifenoptimierungen helfen kann.

Hier ist eine für die gemeinsame Eliminierung von Unterausdrücken (gegeben foo ist rein):

a = foo (99) * x + y;
b = foo (99) * x + z;

Kann werden:

_tmp = foo (99) * x;
a = _tmp + y;
b = _tmp + z;

Zusätzlich zu möglichen Laufzeitvorteilen ist eine reine Funktion beim Lesen von Code viel einfacher zu begründen. Außerdem ist es viel einfacher, eine reine Funktion zu testen, da Sie wissen, dass der Rückgabewert nur von den Werten der Parameter abhängt.

Eine nicht reine Funktion

int foo(int x, int y) // possible side-effects

ist wie eine Erweiterung einer reinen Funktion

int bar(int x, int y) // guaranteed no side-effects

in der Sie neben den expliziten Funktionsargumenten x, y den Rest des Universums (oder irgendetwas, mit dem Ihr Computer kommunizieren kann) als implizite potenzielle Eingabe haben. Ebenso ist neben dem expliziten ganzzahligen Rückgabewert alles, worauf Ihr Computer schreiben kann, implizit Teil des Rückgabewerts.

Es sollte klar sein, warum es viel einfacher ist, über eine reine Funktion nachzudenken als über eine nicht reine.

Nur als Add-On möchte ich erwähnen, dass C++11 Dinge mit dem Schlüsselwort constexpr etwas kodiert. Beispiel:

#include <iostream>
#include <cstring>

constexpr unsigned static_strlen(const char * str, unsigned offset = 0) {
        return (*str == '\0') ? offset : static_strlen(str + 1, offset + 1);
}

constexpr const char * str = "asdfjkl;";

constexpr unsigned len = static_strlen(str); //MUST be evaluated at compile time
//so, for example, this: int arr[len]; is legal, as len is a constant.

int main() {
    std::cout << len << std::endl << std::strlen(str) << std::endl;
    return 0;
}

Die Einschränkungen bei der Verwendung von constexpr machen es so, dass die Funktion beweisbar rein ist. Auf diese Weise kann der Compiler aggressiver optimieren (stellen Sie nur sicher, dass Sie die Endrekursion verwenden, bitte!) und die Funktion zur Kompilierzeit statt zur Laufzeit auswerten.

Um Ihre Frage zu beantworten: Wenn Sie C ++ verwenden (ich weiß, Sie sagten C, aber sie sind verwandt), ermöglicht das Schreiben einer reinen Funktion im richtigen Stil dem Compiler, alle möglichen coolen Dinge mit der Funktion zu tun: -)

Im Allgemeinen haben reine Funktionen gegenüber unreinen Funktionen drei Vorteile, die der Compiler nutzen kann:

Caching

Nehmen wir an, Sie haben reine Funktion f das 100000 Mal aufgerufen wird, da es deterministisch ist und nur von seinen Parametern abhängt, kann der Compiler seinen Wert einmal berechnen und bei Bedarf verwenden

Parallelität

Reine Funktionen lesen oder schreiben in keinen gemeinsam genutzten Speicher und können daher ohne unerwartete Folgen in separaten Threads ausgeführt werden

Übergabe durch Referenz

Eine Funktion f(struct t) bekommt sein Argument t nach Wert, und andererseits kann der Compiler übergeben t unter Bezug auf f wenn es als rein deklariert wird und gleichzeitig den Wert garantiert t wird sich nicht ändern und Leistungsgewinne haben

Zusätzlich zu den Überlegungen zur Kompilierzeit können reine Funktionen ziemlich einfach getestet werden: Rufen Sie sie einfach auf.

Keine Notwendigkeit, Objekte zu konstruieren oder Verbindungen zu DBs/Dateisystem zu simulieren.