Dzisiaj czytałem o czystej funkcji, pomyliłem się z jej użyciem:

O funkcji mówi się, że jest czysta, jeśli zwraca ten sam zestaw wartości dla tego samego zestawu danych wejściowych i nie ma żadnych obserwowalnych skutków ubocznych.

np. strlen()jest czystą funkcją, podczas gdy rand()jest nieczysta.

__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

Powyższy program zachowuje się analogicznie jak w przypadku braku puredeklaracji.

Jakie są korzyści z zadeklarowania funkcji jako pure[jeśli nie ma zmiany w wyniku]?

pure pozwala kompilatorowi wiedzieć, że może dokonać pewnych optymalizacji dotyczących funkcji: wyobraź sobie kawałek kodu, na przykład

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

Dzięki czystej funkcji kompilator może wiedzieć, że musi przeprowadzić ocenę fun(10)raz i tylko raz, a nie 1000 razy. W przypadku złożonej funkcji to duża wygrana.

Kiedy mówisz, że funkcja jest „czysta”, gwarantujesz, że nie ma ona żadnych zewnętrznych efektów ubocznych (a jak mówi komentarz, jeśli kłamiesz, mogą się zdarzyć złe rzeczy). Świadomość, że funkcja jest „czysta”, przynosi korzyści kompilatorowi, który może wykorzystać tę wiedzę do wykonania pewnych optymalizacji.

Oto, co dokumentacja GCC mówi o pureatrybucie:

czysty

Wiele funkcji nie ma żadnych efektów poza wartością zwracaną, a ich wartość zwracana zależy tylko od parametrów i / lub zmiennych globalnych. Taka funkcja może podlegać zwykłej eliminacji podwyrażeń i optymalizacji pętli, tak jak byłby to operator arytmetyczny. Funkcje te należy zadeklarować z atrybutem pure. Na przykład,

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

Odpowiedź Philipa już pokazuje, jak wiedza o funkcji jest „czysta” może pomóc w optymalizacji pętli.

Oto jedno z typowych eliminacji podwyrażeń (podane foojest czyste):

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

Może zostać:

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

Oprócz możliwych korzyści w czasie wykonywania, czysta funkcja jest znacznie łatwiejsza do rozważenia podczas czytania kodu. Ponadto o wiele łatwiej jest przetestować czystą funkcję, ponieważ wiesz, że wartość zwracana zależy tylko od wartości parametrów.

Nie czysta funkcja

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

jest jak rozszerzenie czystej funkcji

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

w którym oprócz jawnych argumentów funkcji x, y masz resztę wszechświata (lub cokolwiek, z czym twój komputer może się komunikować) jako niejawne potencjalne dane wejściowe. Podobnie, poza jawną wartością zwracaną w postaci liczby całkowitej, wszystko, do czego komputer może zapisać, jest niejawnie częścią wartości zwracanej.

Powinno być jasne, dlaczego wnioskowanie o czystej funkcji jest znacznie łatwiejsze niż o nieczystej.

Jako dodatek chciałbym wspomnieć, że C ++ 11 kodyfikuje pewne rzeczy za pomocą słowa kluczowego constexpr. Przykład:

#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;
}

Ograniczenia dotyczące użycia constexpr sprawiają, że funkcja jest dająca się udowodnić czystość. W ten sposób kompilator może bardziej agresywnie optymalizować (po prostu upewnij się, że używasz rekurencji ogonowej, proszę!) I oceniać funkcję w czasie kompilacji, a nie w czasie wykonywania.

A więc, odpowiadając na twoje pytanie, jeśli używasz C ++ (wiem, że powiedziałeś C, ale są one powiązane), napisanie czystej funkcji w odpowiednim stylu pozwala kompilatorowi robić różne fajne rzeczy z funkcją: -)

Ogólnie rzecz biorąc, funkcje Pure mają 3 zalety w porównaniu z nieczystymi funkcjami, z których kompilator może skorzystać:

Buforowanie

Powiedzmy, że masz czystą funkcję, fktóra jest wywoływana 100000 razy, ponieważ jest deterministyczna i zależy tylko od jej parametrów, kompilator może obliczyć jej wartość raz i użyć jej w razie potrzeby

Równoległość

Czyste funkcje nie odczytują ani nie zapisują w żadnej pamięci współdzielonej i dlatego mogą działać w oddzielnych wątkach bez żadnych nieoczekiwanych konsekwencji

Przekazywanie przez odniesienie

Funkcja f(struct t)pobiera argument tprzez wartość, az drugiej strony kompilator może przekazać tprzez odwołanie do, fjeśli jest zadeklarowana jako czysta, gwarantując, że wartość tnie zmieni się i przyniesie wzrost wydajności

Oprócz kwestii związanych z czasem kompilacji, czyste funkcje można testować dość łatwo: wystarczy je wywołać.

Nie ma potrzeby tworzenia obiektów ani pozorowania połączeń z bazami danych / systemem plików.