correttezza costante per le strutture con i puntatori

Question

Ho una struttura che contiene alcuni puntatori. Voglio che il valore di questi non sia modificabile. Ma semplicemente scrivere const infront non rende i membri della struct immutabili

typedef struct{ 
    int *x; 
    int *y; 
}point; 

void get(const point *p,int x, int y){ 
    p->x[0]=x;//<- this should not be allowed 
    p->y[0]=y;//<- this should not be allowed 
} 

Qualcuno può indicarmi la giusta direzione.

EDIT:

Quindi sembrerebbe che non esiste un modo semplice di utilizzare il prototipo di funzione per dire che tutto ciò che appartiene alla struct dovrebbe essere immodificabile

Answer 1

di spiegare che cosa è necessario stabilire, quando si scrive

point str; 

point *p=&str; 

Qui p è un puntatore a str che è di tipo punto

Quando si dichiara come const, è significa che p è un puntatore costante. Questo non limita i puntatori che la struttura può contenere.

Se si desidera che il const ness da applicare all'interno della struttura, è necessario definire i puntatori all'interno della struttura anche come const

typedef struct{ 
    const int * x; 
    const int * y; 
}point; 

Ancora una volta a spingere a casa il mio punto di dichiarare il parametro come

void get(point * const p,int x, int y) 
    //Constant Pointer (*to prevent p from pointing to anything else*) 

    // AND 

    //Make the pointers inside point structure constant 
    //(*to prevent the int pointers x & y from pointing to anything else*) 

Se la struttura si sta puntando è anche l'uso const

 void get(const point * const p, int x, int y) 
    //Constant Pointer to constant structure 

Answer 2

Questo perché si modifica il contenuto della memoria puntato da un altro puntatore rispetto a p.

p punti su una struttura contenente 2 puntatori a int. Non si modifica la memoria a cui punta p ma un'altra area di memoria. Quindi il compilatore sta bene con quello.

 +----------+ 
p -> | x  | -> wherever 
     +----------+ 
     | y  | -> another place in memory 
     +----------+ 

Il const NESS od p non è ereditabile. Se avessi scritto p->a = array;, il compilatore si sarebbe lamentato. Il const è solo un contratto che dice che non cambierete la memoria attraverso quel puntatore.

Answer 3

Se ho compreso correttamente la tua domanda, ti piacerebbe ottenere la propagazione automatica della costanza dell'intero oggetto struct agli oggetti puntati da quei membri della struct. Cioè se l'oggetto struct non è const, gli array dovrebbero essere modificabili, mentre se l'oggetto struct è const, gli array non dovrebbero essere modificabili.

Se è così, quindi, sfortunatamente, non è ottenibile in linguaggio C.

In C++ è possibile forzare l'utente a utilizzare la funzione membro accessor per accedere ai membri dati (anziché accedere direttamente ai membri dati). Ma in C semplicemente non può essere fatto.

Answer 4

È possibile farlo senza fusione di caratteri mediante la definizione di un tipo di punto const e un tipo di punto mutevole, quindi utilizzare un sindacato trasparente:

typedef struct{ 
    const int * x; 
    const int * y; 
} const_point; 

typedef struct{ 
    int * x; 
    int * y; 
} mutable_point; 

typedef union __attribute__((__transparent_union__)) { 
    const_point cpoint; 
    mutable_point point; 
} point; 

Poi, si dichiara i parametri di funzione utilizzando sia il punto o il tipo const_point (mai il tipo mutable_point).

l'oggetto del tipo di punto verrà convertito in modo trasparente in un tipo const_point, ma non nel contrario. Ciò consente di avere un grado maggiore di sicurezza del tipo.

Vedi qui per un esempio in gcc: http://toves.freeshell.org/xueg/

Si noti che l'unione trasparente non è stata sostenuta nell'ultima versione di C++ ho controllato (non sono sicuro circa l'ultimo standard C++) in modo da può aspettare problemi di portabilità.

Può anche rendere il codice più difficile da leggere e mantenere, specialmente se si dispone di una struttura più complessa. ad esempio: potresti avere il tipo di punto in cui x o y è const oppure potresti dover incorporare la struttura puntiforme in un'altra struttura, ad es. rettangolo, per il quale potrebbe essere necessario definire più strutture per più tipi a seconda della loro costanza.

Tutto sommato, non sono sicuro che valga sempre la pena supplementare.