Che cosa è un opaco valore in C++?

Che cosa è un “opaco valore” in C++?

  • Alcuni ancora di più il contesto?
  • Controllare questo link potrebbe aiutarti a – calumgrant.net/opaque/index.html
  • perché questa domanda tagged as indipendente dalla lingua?
  • Perché gli oggetti opachi sono comuni in molte lingue.
  • Significa solo che non si può vedere cosa c’è dentro (e quindi opaco).
  • York… quindi la domanda dovrebbe essere scritto in questo modo: “che Cos’è un ‘opaco valore’?
  • Vedere il riepilogo di modifica per la revisione. Non volevo rimuovere il C++ contesto, perché è così che l’OP ha chiesto, ma ancora non vale praticamente per tutte le altre lingue.
  • Best practice a dichiarare: stackoverflow.com/questions/3965279/…

 

5 Replies
  1. 31

    Per esempio, un Opaco Valore è FILE (dalla libreria C):

    #include <stdio.h>
    
    int main()
    {
        FILE * fh = fopen( "foo", "r" );
        if ( fh != NULL )
        {
            fprintf( fh, "Hello" );
            fclose( fh );
        }
        return 0;
    }

    Si ottiene un FILE puntatore fopen(), e si usa come parametro per altre funzioni, ma non hai mai preoccuparsi di che cosa realmente si punti per.

    • Che è in realtà un puntatore non è importante; puntatori opachi, sono solo opaco valori che capita di essere puntatori.
    • In realtà, opaca, poco ha a che fare con il fatto che si la briga con che cosa punta, che è una scelta dell’utente. Un vero puntatore opaco rivela nessun dettaglio. Se si guarda dentro stdio.h e la struttura è definita, quindi il FILE non è opaco.
    • La linguistica. Nessuna operazione mai richiede effettivamente accedere a valore di un FILE, basta passare in giro. Se non riusciva a capire il suo contenuto nell’header si potrebbe ancora decodificare, ma non è necessario, perché la sua struttura è di nessuna importanza. La biblioteca realizzatore potrebbe cambiare il suo funzionamento, senza alcun ulteriore preavviso, e non dovrebbe fare la differenza. (A meno che, naturalmente, è non piratare la sua struttura interna.) Non confondere la facilità di accesso con l’accessibilità. C++ private membri dati non sono “invisibili” o…
    • Buon esempio, ma è anche necessario includere stdlib.h
    • No non voglio!?! Cosa ti ha dato quell’idea? Vediamo… FILE, fopen, NULL, fprintf, fclose… mi dispiace che stdio.h, che ho incluso.
    • Oh, non lo sapevo che. Ho risposto che fopen funzione è in stdlib.h file in un college esame e ho voti per che. Doveva confermare con il docente.
    • Si potrebbe conferma con la lingua standard. Non mettere troppa fiducia nei docenti; sono stati conosciuti per essere sbagliato, di volta in volta. 😉
    • come si fa completamente conseal la struttura del FILE di definizione in testa, ma solo per esporre il nome del FILE “*” per l’utente della biblioteca? Quando fai qualcosa come “typedef struct XXX *opaco;” l’intestazione, la struttura XXX deve essere noto a quel punto, giusto?
    • in effetti no. I puntatori possono scegliere in modo incompleto variabili tipizzate, non si può non definire le variabili di voi, in modo da FILE *x avrebbe funzionato, ma non FILE x. Dal momento che lo standard mandati solo il primo per stdio, va bene così. Ma, se anche non fosse, si potrebbe ancora definire FILE come un array di char per nascondere il contenuto e il cast a una vera e propria struttura all’interno fread/fwrite/etc. Che rivelano solo la dimensione.
    • Quindi vuoi dire in un’intestazione posso semplicemente fare “struct file{};” questo è un incompleto struct. Poi, lo stesso file che si fanno “typedef struct file *FILE;” e questo va bene? Quindi nell’attuazione effettiva del file che include l’intestazione, è possibile ridefinire il “struct file{ soci…};” per renderla completa tipo??
    • Ho aggiunto una sezione alla fine di dettagliare come si può fare questo. Vorrei fare solo una nota: non siete ridefinizione la struttura, in qualsiasi punto dal struct file; è un dichiarazione (dichiaro che questa cosa esiste, e definire altrove), piuttosto che un definizione (posso definire il significato di questa cosa qui).
    • Nel caso In cui il fatto è sfuggita la vostra attenzione, questo è il mio risposta, non la tua, e siamo d’accordo su ciò che costituisce un puntatore opaco / valore la prima volta intorno. Mi piacerebbe molto se si preferisce mettere come altrove, grazie.
    • Come si desidera. Il punto di tutta QUINDI, è quello di creare le migliori risposte, in modo che questa proprietà mentalità è piuttosto deludente. Ancora, se volete, lasciato solo, così sia.
    • Ho seriamente d’accordo con il tuo punto che un puntatore opaco / valore come FILE deve essere offuscato, in primo luogo, e penso che sia fuorviante e complica inutilmente il problema. Il punto è questo: io non mi sento le modifiche aggiungi per la risposta. Sentitevi liberi di aggiungere una risposta di tuo.
    • come il mio extra info è stato rimosso da qui, ho creato la mia personale risposta. Sentitevi liberi di leggere la risposta se si desidera che le informazioni da lei richieste. Dev, si sta andando ad avere per trovare l’accordo su questo dato che si sta utilizzando una definizione di opaco che non corrisponde con la versione inglese, o CompSci quelli come en.wikipedia.org/wiki/Opaque_data_type. Se è deve per essere nascosto non è in questione, se si vuole sostenere è’e opaco, è per essere nascosto. Che cosa opaco significa. Ancora, non ho intenzione di ri-discutere il caso, io ho la mia risposta ora e il MODO sciame può decidere.

  2. 41

    “Opaco” è definito, in inglese, come “non in grado di essere visto; non trasparente”. In informatica, questo significa un valore che non rivela dettagli, poi il tipo del valore stesso.

    Spesso la gente usa il tipo C FILE come il classico esempio, ma spesso questo è non opaco – i dettagli sono rivelati in stdio.h per chiunque di vedere e che semplicemente si basano su l’utente del tipo di non giocherellare con le parti interne. Va bene fintanto che la gente attenersi alle regole, solo il passaggio di tali valori per le funzioni come fread() e fclose() ma il problema di rivelare informazioni che a volte la gente (stupidamente) iniziare a fare affidamento su di esso.

    Per esempio, glibc pubblica il suo FILE struttura (come struct _IO_FILE) in libio.h in modo che il tipo non è tecnicamente opaco.

    Di notare che una parte della definizione, a fronte: “non in grado” piuttosto che “non volere”. Opacità richiede informazioni per essere nascosto, piuttosto che solo attuando un “gentleman’s agreement” di non usarlo.

    Puntatori opachi, fatto correttamente, dovrebbe rivelare non informazioni di tipo diverso da quello stesso nome e si può implementare in C, in modo relativamente semplice. Si consideri il seguente file di intestazione prog2.h per il conseguimento e il rilascio di xyzzy oggetti:

    struct xyzzy;
    struct xyzzy *xyzzyOpen (void);
    void xyzzyClose (struct xyzzy *fh);

    Questo è tutto ciò che i clienti del codice di vedere, un tipo incompleto struct xyzzy e alcune funzioni da allocare e rilasciare gli oggetti di quel tipo (che non arriva a vedere prog2.c descritto di seguito). Nota che puntatori per un tipo incompleto sono belle, ma non è possibile creare un’istanza di un oggetto di questo tipo poiché non si conosce il suo funzionamento. Così il codice:

    struct xyzzy myvar;

    causerebbe un errore lungo le linee di:

    prog1.c: In function main’:
    prog1.c:3:15: error: storage size of 'myvar' isn't known

    Ora si può tranquillamente utilizzare quelle funzioni da un programma prog1.c senza conoscere i dettagli della struttura:

    #include "prog2.h"
    int main (void) {
        //struct xyzzy myvar;             //will error
        struct xyzzy *num1 = xyzzyOpen();
        struct xyzzy *num2 = xyzzyOpen();
        struct xyzzy *num3 = xyzzyOpen();
        xyzzyClose (num1);
        xyzzyClose (num3);                //these two intentionally
        xyzzyClose (num2);                //  reversed.
        return 0;
    }

    E il attuazione delle chiamate, prog2.c, in realtà i controlli e sa l’interno, in modo da potete usarli abbastanza liberamente:

    #include <stdio.h>
    #include <stdlib.h>
    #include "prog2.h"
    
    struct xyzzy { int payload; };
    static int payloadVal = 42;
    
    struct xyzzy *xyzzyOpen (void) {
        struct xyzzy *plugh = malloc (sizeof (struct xyzzy));
        plugh->payload = payloadVal++;
        printf ("xyzzyOpen payload = %d\n", plugh->payload);
        return plugh;
    }
    
    void xyzzyClose (struct xyzzy *plugh) {
        printf ("xyzzyClose payload = %d\n", plugh->payload);
        free (plugh);
    }

    Il printf chiamate sono lì semplicemente per dimostrare che si può utilizzare l’interno, e si sarebbe probabilmente desidera aggiungere il controllo del valore restituito da malloc in e pronto per la produzione di codice, ma che non è pertinente ai fini di questo esempio.

    Quando si compila prog1.c e prog2.c in un singolo file eseguibile e lanciarlo, il risultato è:

    xyzzyOpen payload = 42
    xyzzyOpen payload = 43
    xyzzyOpen payload = 44
    xyzzyClose payload = 42
    xyzzyClose payload = 44
    xyzzyClose payload = 43

    come ci si aspetterebbe dalla funzione principale.

    • Con voto positivo nonostante il nostro disaccordo, perché quando sono messi in proprio, non evidenziare un angolo interessante sull’argomento. A Me, in disaccordo con la sua necessità non significa che io non posso dare un voto positivo una buona presentazione dei suoi meriti. 😉 Senza rancore, e avere un buon tempo.
    • se siamo tutti d’accordo, sarei annoiato witless 🙂 Ciao.
    • Interessante pointification: Se ho l’accesso alla fonte di prog2.c, I sarebbe essere in grado di accedere all’interno della struttura. È la struct ancora “opaco” con la tua definizione, quindi? O non vero opacità richiedono un closed-source modello di programmazione? (Tirando la gamba c’è, cercando di scegliere la mia definizione di “opacità” guardando la documentazione, non l’origine intestazione. 😉 )
    • S’Okay, @Dev, come un Australiano, ho un caustico senso dell’umorismo di me. Hai ragione che “di nascosto” è una questione di grado, poiché, anche senza la fonte per prog2.c, è possibile esaminare il codice assembly per capire. Infatti, l’unico modo per nascondere è per la versione non è che invece danno la sua utilità. E di una cucina completamente definito FILE entro stdio.h potrebbe essere considerato opaco per le persone che non hanno idea di come trovare l’intestazione 🙂
    • Questa è la risposta giusta. DevSolar è semplicemente sbagliato … il FILE NON è opaco, i suoi interni sono visibili per l’utente, proprio come qualsiasi altra struttura, e le persone sono stati conosciuti per prendere vantaggio di questo (e poi bruciato quando l’attuazione modificate o il codice è stato portato su un’altra applicazione). L’idea che si potrebbe copiare definizione della struttura dalla sorgente e poi gettato il puntatore opaco, mentre è tecnicamente vero, è solo un ostinato rifiuto di ammettere la risposta corretta.
    • Mentre né paxdiablo nè io davvero funzionato questo punto, dovrebbe essere abbastanza ovvio che se non FILE è opaco (secondo paxdiablo e la tua definizione) è tutto per l’attuazione (perché si potrebbe facilmente applicare paxdiablo tecnica per FILE così). Si può inoltre notare che, mentre in disaccordo sul soggetto, paxdiablo e me erano in grado di farlo senza essere maleducato e chiamando l’un l’altro “sbagliata” o in “ostinato”. Inoltre, la mia risposta precedente uno con un buon margine, quindi non c’è niente che ho “ammettere” qui.

  3. 2

    Simile a quello di puntatore opaco – un valore che non memorizzare i dati del tuo codice potrebbe interpretare o fornire l’accesso ai dati, ma identifica solo alcuni altri dati. Un esempio tipico è un Win32 gestire come HBITMAP bitmap maniglia si può passare solo a rilevanti funzioni, ma non si può fare nulla per il sottostante bitmap direttamente.

    • sharptooth DETTO che HBITMAP è un puntatore opaco; non c’è sostenere che esso contiene l’immagine bitmap stessa.
    • o ho letto male, o è stato modificato dopo il mio commento, o ho inteso qualcosa di differente. Onestamente, dopo quattro anni, non ricordo. Io di cancellare il mio commento comunque dato che non è più pertinente (se mai lo è stato).
  4. 2

    FILE* è un buon esempio di un opaco valore. Non utilizzare direttamente; si tratta di un unico “blob”, che non è possibile interpretare o modificare. Invece, è possibile utilizzare una serie di funzioni (fopen, fwrite, fprintf, etc.) che sa come manipolare.

    Essere opaco in questo modo è comune a molte situazioni (e in molte Api) dove si ha un “magico” manico: una scatola nera.

  5. 1

    da Wikipedia

    In informatica, un opaco tipo di dati è un tipo di dati che è
    definiti in modo incompleto in un’interfaccia, in modo che i valori che può solo essere
    manipolato da chiamate a sottoprogrammi che hanno accesso al mancanti
    informazioni. La rappresentazione concreta del tipo è nascosto
    i suoi utilizzatori

    Tipici esempi di opaco tipi di dati includono le maniglie per le risorse
    fornito da un sistema operativo software applicativo.

    Alcuni linguaggi, come il C, consentire la dichiarazione di opaco record
    (struct), le cui dimensioni e i campi sono nascosti al cliente. Il solo
    cosa che il cliente può fare con un oggetto di questo tipo è quello di prendere
    il suo indirizzo di memoria, per produrre un puntatore opaco.

    Se le informazioni fornite dall’interfaccia è sufficiente
    determinare il tipo di dimensione, quindi i clienti possono dichiarare variabili, campi,
    e le matrici di che tipo, di assegnare loro valori, e possibilmente confrontare
    loro per la parità. Questo è di solito il caso per puntatori opachi.

Lascia un commento