Сьогодні я читав про чисту функцію, заплутавшись із її використанням:

Функція називається чистою, якщо вона повертає однаковий набір значень для одного і того ж набору входів і не має спостережуваних побічних ефектів.

наприклад, strlen()є чистою функцією, а rand()є нечистою.

__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

Вищевказана програма поводиться так само, як і за відсутності pureдекларації.

Які переваги оголошення функції як pure[якщо не буде змін у виведенні]?

pure дає змогу компілятору знати, що він може зробити певні оптимізації щодо функції: уявіть собі трохи коду

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

Завдяки чистій функції компілятор може знати, що йому потрібно оцінювати fun(10)один раз, а не 1000 разів. Для складної функції це великий виграш.

Коли ви говорите, що функція є "чистою", ви гарантуєте, що вона не має зовнішніх видимих ​​побічних ефектів (і, як зазначається в коментарі, якщо ви брешете, можуть статися погані речі). Знання того, що функція є "чистою", має переваги для компілятора, який може використовувати ці знання для певної оптимізації.

Ось що говорить документація GCC про pureатрибут:

чистий

Багато функцій не мають ефектів, крім поверненого значення, і їх повернене значення залежить лише від параметрів та / або глобальних змінних. Така функція може підлягати загальному усуненню підвиразу та оптимізації циклу, як і арифметичний оператор. Ці функції слід оголосити з атрибутом pure. Наприклад,

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

Відповідь Філіпа вже показує, як знання функції "чисто" може допомогти в оптимізації циклу.

Ось один для загального усунення підвиразу (наведено fooчисто):

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

Може стати:

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

На додаток до можливих переваг під час виконання, чисту функцію набагато легше міркувати про читання коду. Крім того, набагато простіше перевірити чисту функцію, оскільки ви знаєте, що повертане значення залежить лише від значень параметрів.

Нечиста функція

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

це як розширення чистої функції

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

в якому ви маєте, крім явних аргументів функції x, y, решту Всесвіту (або все, з чим ваш комп'ютер може спілкуватися) як неявний потенційний вхід. Подібним чином, крім явного цілочисельного значення повернення, все, на що може писати ваш комп’ютер, неявно є частиною поверненого значення.

Повинно бути зрозуміло, чому набагато легше міркувати про чисту функцію, ніж про нечисту.

Як доповнення, я хотів би згадати, що C ++ 11 дещо кодує речі, використовуючи ключове слово constexpr. Приклад:

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

Обмеження на використання constexpr роблять це таким чином, щоб функція була доказово чистою. Таким чином, компілятор може більш агресивно оптимізувати (просто переконайтеся, що ви використовуєте рекурсію хвоста, будь ласка!) І оцінити функцію під час компіляції, а не часу виконання.

Отже, щоб відповісти на ваше запитання, це те, що якщо ви використовуєте C ++ (я знаю, ви сказали C, але вони пов'язані між собою), написання чистої функції у правильному стилі дозволяє компілятору робити всілякі цікаві речі з функцією: -)

Загалом, чисті функції мають 3 переваги перед нечистими функціями, якими компілятор може скористатися:

Кешування

Скажімо, у вас є чиста функція f , яку викликають 100000 разів, оскільки вона детермінована і залежить лише від її параметрів, компілятор може обчислити її значення один раз і використати її, коли це необхідно

Паралельність

Чисті функції не читають і не записують у жодну спільну пам’ять, тому можуть працювати в окремих потоках без будь-яких несподіваних наслідків

Проходження за посиланням

Функція f(struct t)отримує свій аргумент tза значенням, а з іншого боку, компілятор може передавати tпосилання на те, fякщо вона оголошена чистою, гарантуючи, що значення tне зміниться і матиме приріст продуктивності

На додаток до міркувань часу компіляції, чисті функції можна протестувати досить просто: просто викликайте їх.

Не потрібно конструювати об'єкти або знущатись над з'єднаннями з базами даних / файловою системою.