En los lenguajes de programación C y C++, #pragma once es una directiva del preprocesador no estándar pero con un extenso soporte. Está diseñado para asegurar que el código fuente que lo invoca sea incluido una única vez. Así pues, #pragma once sirve al mismo propósito que la protección de macros, pero con una menor cantidad de código y sin la posibilidad de que lleguen a coincidir las identificaciones.

Ejemplos

El código con #pragma once sería:

//abuelo.h

#pragma once

struct foo
{
    int miembro;
};

//padre.h

#include "abuelo.h"

//hijo.c

#include "abuelo.h"
#include "padre.h"

Ventajas y desventajas

Usando #pragma once en lugar de la protección de macros (también visto como protección de inclusiones (include) ) generalmente aumentará la velocidad de compilación puesto que es un mecanismo de nivel más alto.

Algunos compiladores como GCC incluyen código especial para reconocer y optimizar las protecciones de macros, por lo que no se conseguirá apenas un aumento en la velocidad usando, en este caso, #pragma once.[1]

Como el propio compilador es el responsable del funcionamiento de #pragma once, no será necesario que el programador cree nuevos nombres de macros tales como _ABUELO_H_, tal como debería haber hecho en el ejemplo anterior para evitar su repetida inclusión si no hubiera usado #pragma once. Esto elimina la posibilidad de nombres repetidos, lo que significa que asegurará la inclusión de todos los archivos de cabecera una única vez. Además implica la escritura de menos código para el programador.

Sin embargo el programador debe confiar en la capacidad del compilador de hacer funcionar #pragma once de forma correcta. Si el compilador comete un fallo como, por ejemplo, al reconocer dos Enlace simbólicos con distintos nombres que apunten al mismo fichero, entonces la compilación fallará. Originalmente GCC dio un aviso declarando #pragma once "obsoleto" cuando compilaba código que lo usaba. Sin embargo, desde la versión 3.4 de GCC, el funcionamiento del código #pragma once fue corregido asegurando un funcionamiento correcto con Enlace simbólicos y Enlace duros, con lo que el aviso fue eliminado.[2] [3]

Se pueden usar ambos #pragma once y protecciones de macro para escribir código portable que puede, además, tomar la ventaja de las optimizaciones de #pragma once que el compilador soporte:

//abuelo.h

#pragma once
#ifndef _ABUELO_H_
#define _ABUELO_H_

struct estructura
{
    int miembro;
};

#endif /* _ABUELO_H_ */