b'\n_START_ARTICLE_\nPuntero opaco\n_START_PARAGRAPH_\nEn programaci\xc3\xb3n, se llama puntero opaco a un caso especial de tipo de dato opaco, un tipo de dato declarado como puntero a un registro o estructura de datos de tipo no especificado._NEWLINE_Los punteros opacos se encuentran en varios lenguajes de programaci\xc3\xb3n, incluidos Ada, C, C++ y Modula-2._NEWLINE_Si el lenguaje es de tipado fuerte, los programas y procedimientos que no tienen informaci\xc3\xb3n adicional sobre un puntero opaco de tipo T, pueden aun as\xc3\xad declarar variables, vectores y registros de tipo T, asignar valores de ese tipo y comparar si dichos valores son iguales. Sin embargo, no ser\xc3\xa1n capaces de usar este tipo de puntero para hacer referencia a su contenido y s\xc3\xb3lo podr\xc3\xa1n hacer cambios en \xc3\xa9l mediante llamadas a procedimientos que s\xc3\xad tengan conocimiento para ello._NEWLINE_Los punteros opacos son una manera de ocultar a clientes ordinarios los detalles de implementaci\xc3\xb3n de una interfaz, de manera que la pueda sufrir cambios sin necesidad de recompilar los m\xc3\xb3dulos que hacen uso de ella. Esto tambi\xc3\xa9n supone una ventaja para el programador, ya que se pueden crear interfaces sencillas y ocultar la mayor parte de los detalles en otro fichero. Esto es importante para proporcionar compatibilidad binaria a lo largo de diferentes versiones de una biblioteca compartida, por ejemplo._NEWLINE_Esta t\xc3\xa9cnica est\xc3\xa1 descrita en Design Patterns con el nombre de patr\xc3\xb3n Bridge. Tambi\xc3\xa9n se la ha llamado "clases handle",  "Pimpl idiom" ("pointer to implementation" - puntero a la implementaci\xc3\xb3n), "Compiler firewall idiom" o "gato Cheshire", especialmente en la comunidad C++.\n_START_SECTION_\nAda\n_START_PARAGRAPH_\npackage Library_Interface is_NEWLINE__NEWLINE_   type Handle is limited private;_NEWLINE__NEWLINE_   -- Operaciones...private_NEWLINE_   type Hidden_Implementation;    -- Definido en el cuerpo del paquete_NEWLINE_   type Handle is access Hidden_Implementation;end Library_Interface;_NEWLINE_El tipo Handle es un puntero opaco a la verdadera implementaci\xc3\xb3n, que no est\xc3\xa1 definida en la especificaci\xc3\xb3n. Observe que el tipo no es s\xc3\xb3lo privado (para prohibir a los clientes el acceso directo al tipo, permitido s\xc3\xb3lo mediante las operaciones), sino tambi\xc3\xa9n limitado (para evitar la copia de la estructura de datos, previniendo as\xc3\xad referencias colgantes._NEWLINE_package body Library_Interface is_NEWLINE__NEWLINE_   type Hidden_Implementation is record_NEWLINE_      ...    -- La implementaci\xc3\xb3n en s\xc3\xad puede ser cualquier cosa_NEWLINE_   end record;_NEWLINE__NEWLINE_   -- Definici\xc3\xb3n de las operaciones...end Library_Interface;_NEWLINE_A veces a estos tipos se los llama "tipos Taft" (por Tucker Taft, el dise\xc3\xb1ador principal de Ada 95) porque se introdujeron en la que se conoce como Taft Amendment (la Enmienda Taft sobre Ada 83.\n_START_SECTION_\nC\n_START_PARAGRAPH_\n/* obj.h */struct obj;/* * El compilador considera struct obj como un tipo incompleto. Los tipos * incompletos se pueden usar en declaraciones. */size_t obj_size(void);int obj_setid(struct obj *, int);int obj_getid(struct obj *, int *);_NEWLINE_/* obj.c */#include "obj.h"struct obj {_NEWLINE_    int id;};/* * El que realiza la llamada se encargar\xc3\xa1 de hacer * la reserva de memoria. * Proporcionar s\xc3\xb3lo la informaci\xc3\xb3n necesaria */size_tobj_size(void){_NEWLINE_    return sizeof(struct obj);}intobj_setid(struct obj *o, int i){_NEWLINE_    if (o == NULL) return -1;_NEWLINE_    o->id = i;_NEWLINE_    return 0;}intobj_getid(struct obj *o, int *i){_NEWLINE_    if (o == NULL || i == NULL) return -1;_NEWLINE_    *i = o->id;_NEWLINE_    return 0;}_NEWLINE_Este ejemplo muestra la manera de conseguir el aspecto de ocultaci\xc3\xb3n de informaci\xc3\xb3n ([[Encapsulamiento (dise\xc3\xb1o orientado a objetos)|encapsulamiento) de la Programaci\xc3\xb3n orientada a objetos usando el lenguaje C. Si alguien quisiera cambiar la declaraci\xc3\xb3n de struct obj, no ser\xc3\xada necesario recompilar ning\xc3\xban otro m\xc3\xb3dulo del programa que use el fichero de cabecera obj.h, a menos que tambi\xc3\xa9n cambie la API.\n_START_SECTION_\nC++\n_START_PARAGRAPH_\n//header file:class Handle {public:_NEWLINE_    Handle();                         // Constructor_NEWLINE_    Handle(const Handle&);            // Constructor de copia_NEWLINE_    Handle(Handle&&);                 // Constructor de movimiento_NEWLINE_    Handle& operator=(const Handle&); // Operador de copia por asignaci\xc3\xb3n_NEWLINE_    ~Handle();                        // Destructor_NEWLINE_    // Other operations...private:_NEWLINE_    struct CheshireCat;               // No se define aqu\xc3\xad_NEWLINE_    CheshireCat* smile;               // Handle};_NEWLINE_//CPP file:#include "handle.h"struct Handle::CheshireCat {_NEWLINE_    int a;_NEWLINE_    int b;};Handle::Handle()_NEWLINE_    : smile(new CheshireCat()) {_NEWLINE_    // do nothing}Handle::Handle(const Handle& other)_NEWLINE_    : smile(new CheshireCat(*other.smile)) {_NEWLINE_    // do nothing}Handle::Handle(Handle&& other) _NEWLINE_    : smile(0){_NEWLINE_    std::swap(smile, other.smile);}Handle& Handle::operator=(const Handle &other) {_NEWLINE_    if(this != &other) {_NEWLINE_        *smile = *(other.smile);_NEWLINE_    }_NEWLINE_    return *this;}Handle::~Handle() {_NEWLINE_    delete smile;}_NEWLINE_Un tipo de puntero opaco que se usa a menudo en las declaraciones de clase de C++ es el d-pointer. Un d-pointer es el \xc3\xbanico dato miembro privado de la clase y apunta a una instancia de una estructura. Bautizado por Arnt Gulbrandsen de Trolltech, este m\xc3\xa9todo permite que las declaraciones de clase omitan miembros privados, excepto por el propio d-pointer.  El resultado: (a) se oculta a la vista una mayor cantidad de la implementaci\xc3\xb3n de la clase; (b) si se a\xc3\xb1aden nuevos miembros a la estructura privada, eso no afecta la compatibilidad primaria; (c) el fichero de cabecera que contiene la declaraci\xc3\xb3n de la clase s\xc3\xb3lo necesita incluir los otros ficheros necesarios para la interfaz de la clase, sin los de su implementaci\xc3\xb3n. Un beneficio adicional es que los ciclos de compilaci\xc3\xb3n se aceleran porque los ficheros de cabecera cambian con menos frecuencia. El d-pointer se usa ampliamente en las bibliotecas Qt (biblioteca) y KDE.\n_START_SECTION_\nC#\n_START_PARAGRAPH_\nV\xc3\xa9ase el Patr\xc3\xb3n Private class data.'