Come dichiarare e definire una funzione pura in gcc?

Question

GCC ha gli attributi puro e const, in cui const viene effettivamente utilizzato per le vere funzioni pure (puro è per idempotent functions which are also side-effect free).

Quindi, come posso dichiarare e definire una funzione utilizzando l'attributo const?

Modifica: Sono interessato alle funzioni pure reali, quelle dichiarate con l'attributo const, non quelle dichiarate con l'attributo puro.

Answer 1

Esempio:

// Declaration: 
int square (int x) __attribute__ ((const)); 
// Definition: 
int __attribute__ ((const)) square (int x) 
{ 
    return x*x; 
} 

---

La sintassi per tutti gli attributi è più o meno lo stesso: __attribute__ ((<attribute-name>)) o __attribute__ ((<attribute-name> (<attribute-options>))). Citando la documentazione che si collega a:

La parola chiave __attribute__ consente di specificare attributi speciali quando si effettua una dichiarazione. Questa parola chiave è seguita da una specifica di attributo all'interno di doppie parentesi.

ci sono esempi nella documentazione si collega a per diversi altri attributi, tra cui pure:

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

così tutto il necessario, la sintassi-saggio, per usare const, è cambiare pure a const:

int square (int) __attribute__ ((const)); 

Come sottolineato nei commenti: se lo si usa in una definizione, allora avete bisogno di mettere __attribute__ ((const)) in una posizione diversa:

int square (int) __attribute__ ((const)) { ... } // doesn't work 
int __attribute__ ((const)) square (int) { ... } // does work 

ma il const e pure attributi sono praticamente utile solo se sono applicati a dichiarazioni esterne, quindi non dovrebbe essere un problema. Se la definizione è visibile, GCC è in genere in grado di determinare se la funzione può essere considerata come const/pure senza il tuo aiuto.

Answer 2

Secondo questo this article, la sintassi corrisponde con quello che @hvd dice:

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

Tuttavia, sembra che gcc non impone la proprietà di non esaminare lo stato globale quando compilo il seguente esempio.

#include <stdio.h> 

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

int outerX = 7; 
int square(int x) { 
    return outerX * x; 
} 

int main(){ 
    printf("%d\n", square(5)); 
    return 0; 
} 

le seguenti stampe senza errori, e le piste di codice e produce 35.

gcc -Wall -Werror -pedantic -O3 Pure.c 


gcc --version 
gcc (Ubuntu/Linaro 4.8.1-10ubuntu9) 4.8.1 

Ancora più stranamente, gcc anche non importa se mutare lo stato globale all'interno della funzione e restituiscono un valore diverso per ogni chiamata causa di una modifica ha causato nello stato globale.

#include <stdio.h> 

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

int outerX = 7; 
int square(int x) { 
    outerX++; 
    return outerX * x; 
} 

int main(){ 
    printf("%d\n", square(5)); 
    printf("%d\n", square(5)); 
    printf("%d\n", square(5)); 
    return 0; 
} 

uscita:

40 
45 
50 

Answer 3

A partire da C++ 11 è possibile utilizzare uno attribute specifier sequence per specificare tali attributi. Per esempio:

[[ gnu::const ]] 
int square (int x) 
{ 
    return x * x; 
} 

Inoltre, a partire da C++ 17 tutti gli attributi sconosciuto a un compilatore vengono ignorati senza causare un errore. Quindi il codice sopra diventa portatile tra diversi compilatori e piattaforme.