Stesso oggetto come Cost e Non-Const, cosa dovrei presumere di comportarsi correttamente?

Question

Ho una funzione del modulo

return_type function(const argument_type & a, argument_type & b);

.

Se lo stesso oggetto viene passato come a e b, posso procedere con la funzione (potenzialmente modificandolo) o fermare?

Non ho la conoscenza di come le ipotesi del compilatore si propagano in tal caso.

La mia ipotesi è che le ipotesi non costness per essere passate come non cost b dovrebbero sufficienza e consentire le modifiche, ma è un'ipotesi.

---

.

La maggior parte delle risposte era di essere able per modificare a o b o chiamare metodi non const. So che se passo lo stesso oggetto di const e non-const che posso farlo. Il mio dubbio si trova di più in stato che ho intenzione di lasciare il programma quando la funzione restituisce, e se può frenare alcune ipotesi del compilatore, ad esempio:

class A(){
    int value;
}

void function1(const A & arg1);
void function2(A & arg1);
void function3(const A & arg1, A & arg2);

A a;
a.value=5;
function1(a);
if(a.value==5){/*...*/;} // the if can be optimized out to true, because [a] was const

a.value=5;
function2(a);
if(a.value==5){/*...*/;} //must be checked, [a] could have been modified

a.value=5;
function3(a, a);
if(a.value==5){/*...*/;} // ??? 

.

---

.

Domanda più simile che ho trovato (ma non proprio IT)

Modifica di sé entro il metodo conSt tramite non Puntatore Cost To Self

Answer 1

Il problema con

return_type function(const argument_type & a, argument_type & b);

.

e una chiamata function( o , o ) è che la funzione probabilmente

.

• modifica l'oggetto tramite argomento formale b, mentre

• Allo stesso tempo, aspettando argomento formale a per rimanere invariato.

Così probabilmente spezzerai le ipotesi della funzione, con conseguente e.g. risultati errati o un arresto anomalo.

---

.

C'è una funzione che per progettazione spesso ha questo tipo di firma, vale a dire l'operatore di assegnazione della copia. La sua costante argomentazione formale GeneracodictagCode è l'argomento fornito dall'esplienza e il suo argomento formale mutabile (se si può chiamarlo che) è l'implicito a. Può controllare l'auto-riferimento (aliasing degli argomenti) o può copiare e scambiare.

---

.

In sintesi, se è possibile chiamare in modo sicuro la funzione con lo stesso oggetto come argomento *this e come argomento a dipende dalla funzione, ma è probabile che vi vivi le ipotesi della funzione, che ha come precondizione implicita che il formale Gli argomenti si riferiscono a diversi oggetti.

Answer 2

Decidi se tale funzione può essere chiamata con lo stesso argomento dato due volte.
Ad ogni modo, non dovresti provare a determinare se si ottiene lo stesso oggetto due volte, purché la correttezza del tuo algoritmo non dipenda da esso o non hai fornito garanzie.

Answer 3

Sono passati esattamente allo stesso modo in fase di esecuzione, stesso riferimento / puntatore per esattamente la stessa cosa.

La differenza con const avviene solo a tempo di compilazione.Il compilatore farà in modo di chiamare solo metodi const e non proverà a modificare le proprietà di questo oggetto const, altrimenti getta un errore di compilazione, perché non si dovrebbe modificarlo.

Answer 4

.

La mia ipotesi è che le ipotesi non costness per essere passate come non-cost b dovrebbero sufficienza e consentire le modifiche, ma è un'ipotesi.

Sì, function può chiamare metodi non generacolitagCode tramite const ma non tramite b.

Intuitivamente, ciò significa che a può modificare un oggetto trasmesso tramite il function const Se lo stesso oggetto viene trasferito anche tramite il aTagCoDetagCode di riferimento non const.

In generale, b semplifica le garanzie su ciò che puoi o non può fare con una variabile const. Ci possono essere altre variabili che si riferiscono alla variabile const, o, agli oggetti al suo interno, che possono consentire la modifica della variabile const da una funzione che non sembra che stia modificando una variabile const.

Tornando al tuo caso, è composto da funzioni e classi ad un livello superiore rispetto al tuo const a se stessi, applicare i vincoli su ciò che può e non può essere modificato utilizzando parametri function, funzioni del membro, ecc.