Чистые функции / функции константы в C++

Я думаю об использовании чистых функций / функций константы в большей степени в моем коде C++. (чистый атрибут / атрибут константы в GCC)

Однако мне любопытно, насколько строгий я должен быть об этом и что могло возможно повредиться.

Самый очевидный случай является выводами отладки (в любой форме, мог быть на суде, в некотором файле или в некотором пользовательском классе отладки). У меня, вероятно, будет много функций, которые не имеют никаких побочных эффектов несмотря на этот вид вывода отладки. Неважно, если вывод отладки будет сделан или не, то это не будет абсолютно иметь никакого эффекта на остальную часть моего приложения.

Или другой случай, о котором я думаю, является использованием некоторого класса SmartPointer, который может сделать некоторый дополнительный материал в глобальной памяти будучи в режиме отладки. Если я использую такой объект в чистом функциональном / функциональной константе, это действительно имеет некоторые небольшие побочные эффекты (в том смысле, что некоторая память, вероятно, будет отличаться), который не должен иметь никаких реальных побочных эффектов, хотя (в том смысле, что поведение всегда отличается).

Подобный также для взаимных исключений и другого материала. Я могу думать о многих сложных случаях, где это имеет некоторые побочные эффекты (в смысле которого некоторая память будет отличаться, возможно, даже, некоторые потоки создаются, некоторое управление файловой системой сделано, и т.д.), но не имеет никакого вычислительного различия (все те побочные эффекты могли очень хорошо быть не учтены, и я даже предпочту это).

Так, для суммирования я хочу отметить функции как чистые / константа, которые не чисты / константа в строгом смысле. Легкий пример:

int foo(int) __attribute__((const));

int bar(int x) {
   int sum = 0;
   for(int i = 0; i < 100; ++i)
       sum += foo(x);
   return sum;
}

int foo_callcounter = 0;

int main() {
   cout << "bar 42 = " << bar(42) << endl;
   cout << "foo callcounter = " << foo_callcounter << endl;
}

int foo(int x) {
   cout << "DEBUG: foo(" << x << ")" << endl;
   foo_callcounter++;
   return x; // or whatever
}

Обратите внимание, что функциональное нечто не является константой в строгом смысле. Хотя, не имеет значения, какой foo_callcounter находится в конце. Также не имеет значения, если оператор отладки не сделан (в случае, если функция не вызвана).

Я ожидал бы вывод:

DEBUG: foo(42)
bar 42 = 4200
foo callcounter = 1

И без оптимизации:

DEBUG: foo(42) (100 times)
bar 42 = 4200
foo callcounter = 100

Оба случая прекрасны полностью, потому что то, что только имеет значение для моего варианта использования, является возвращаемым значением панели (42).

Как это удается на практике? Если я отмечаю такие функции как чистые / константа, она могла бы повредить что-нибудь (полагающий, что код является все правильным)?

Обратите внимание, что я знаю, что некоторые компиляторы не могли бы поддерживать этот атрибут вообще. (BTW., я собираю их здесь.) Я также знаю, как использовать эти атрибуты способом, что код остается портативным (через #defines). Кроме того, все компиляторы, которые интересны мне, поддерживают его в некотором роде; таким образом, я не забочусь о том, если мой код работает медленнее с компиляторами, которые не делают.

Я также знаю, что оптимизированный код, вероятно, будет выглядеть по-другому в зависимости от компилятора и даже версии компилятора.

Очень релевантный также эта статья LWN "Последствия чистых и постоянных функций", особенно глава "Обманов". _{(Спасибо ArtemGr для подсказки.)}