Pragma Once en C++

Este artículo comienza con una descripción general de pragma once como directiva de preprocesador y un ejemplo simple de cómo se usa. Después de esto, cubriremos algunas propiedades específicas de pragma once con respecto a su soporte en C y C++ y, por último, incluiremos un ejemplo más holístico de cómo se puede usar y cómo es mejor que sus alternativas.

Pragma una vez en C++

pragma once se usa en C y C++ como una directiva de preprocesador. Las directivas del preprocesador son fragmentos de código de una sola línea que no componen el programa y que son leídos por el preprocesador en su lugar.

El preprocesador los analiza antes de la compilación del código. El preprocesador tampoco espera un punto y coma al final de estas directivas.

Por lo tanto, para agregar la directiva pragma once a su código, agregue lo siguiente en la parte superior del archivo.

#pragma once

pragma once en sí mismo no es estándar. Esto significa que algunos compiladores no lo admitirán y, debido a su compleja implementación, es posible que no siempre sea confiable.

Sin embargo, es muy comúnmente compatible; por lo tanto, en la mayoría de los casos, usar pragma once no debería ser un problema. Su propósito es simple: asegura que el archivo fuente actual (el archivo en el que se escribe la directiva) solo se incluye una vez en la compilación.

Este trabajo se puede hacer alternativamente usando guardias include. Discutiremos las diferencias después de un ejemplo de cómo se usa pragma once.

pragma once se usa principalmente cuando se definen clases. En el siguiente ejemplo, definiremos dos clases: Structure y Room.

La clase Habitación heredará de la clase Structure.

// This contains the code for the Structure class
// Save this as Structure.h
#pragma once

#include <iostream>
#include <string>

using namespace std;

class Structure {
  string struc_name;
  int id;

 public:
  void setVals() {
    struc_name = "Example Name";
    id = 1;
  }

  void printVals() {
    cout << "Name is: " << struc_name << " and id is: " << id << endl;
  }
};

Ahora definiremos la clase Room.

// Save this as Room.h
#pragma once

#include "Structure.h"

class Room {
  Structure example;

 public:
  void initRoom() { example.setVals(); }

  void getRoom() { example.printVals(); }
};

Ahora podemos definir una función main que utilice los objetos anteriores.

// save this in a main.cpp file
#include <iostream>

#include "Room.h"
#include "Structure.h"

using namespace std;

int main() {
  Room testRoom;

  testRoom.initRoom();
  testRoom.getRoom();

  return 0;
}

En el ejemplo anterior, si ejecutamos el código, obtenemos “El nombre es: Nombre del ejemplo e identificación es: 1” como salida, que es lo que esperamos. Sin embargo, si eliminamos el pragma una vez, obtenemos los siguientes errores.

In file included from Room.h:3,
                 from main.cpp:2:
Structure.h:8:7: error: redefinition of 'class Structure'
    8 | class Structure
      |       ^~~~~~~~~
In file included from main.cpp:1:
Structure.h:8:7: note: previous definition of 'class Structure'
    8 | class Structure
      |       ^~~~~~~~~

La clase Estructura se define dos veces. Usando pragma once, podemos asegurar que solo se lee una vez.

La alternativa es utilizar identificadores en su lugar. En el contexto del ejemplo anterior, podemos hacerlo como se define a continuación.

#ifndef STRUCTURE
#define STRUCTURE

class Structure {
  // Some sample code here
};
#endif

En el ejemplo anterior, ESTRUCTURA se puede reemplazar con cualquier cosa. Sin embargo, normalmente mantenemos el nombre como algo que corresponde al nombre de la clase.

Sin embargo, hay posibles problemas aquí. En primer lugar, es más detallado, requiere una toma de decisiones manual y el compilador no tiene protección contra el programador que usa accidentalmente el nombre de la macro en otra parte del proyecto.

Los compiladores generalmente están optimizados para “pragma una vez” aumentando la velocidad de compilación.