juste curieux sur la raison pour laquelle un param doit être un const en opération surcharge de l'opération
CVector& CVector::operator= (CVector& param) //no const
{
x=param.x;
y=param.y;
return *this;
}
7 Réponses :
vous n'avez pas besoin de const: strong> @ numerical25: juste curieux sur la raison pour laquelle un param doit être un const en opération surchargeant p>
blockquote> Ce n'est pas nécessaire, mais c'est une bonne décision de conception. p> Voir la section standard C ++ 12.8-9: P> Un affectation de copie déclarée par l'utilisateur
opérateur x :: opérateur = est une non-statique
Fonction de membre non modèles de la classe
X avec exactement un paramètre de type
X, x &, const x &, volatile x & ou const
Volatile X & P>
blockQuote> Utilisation d'un paramètre Const semble être une décision de conception logique si vous voulez Assurez-vous que l'autre valeur ne sera pas modifiée. p> Il indique à d'autres personnes qui utilisent votre classe que vous ne changerez pas la valeur aussi si vous autorisez des références non constons à l'objet comme paramètre, puis Vous limitez la quantité d'objets pouvant utiliser votre fonction. Si c'est Const, il peut être utilisé pour les paramètres Const et non Const. Si votre paramètre est non Const, il ne peut être utilisé que par des paramètres non constitués. p> @ numerical25: n'est pas quand quelque chose devient un const, il est immuable pour le reste de la vie des applications ?? Comment cela diffère-t-il dans la surcharge d'opération ??? P>
blockQuote> une référence de const est simplement qu'une référence qui est constituée. Il ne change pas la const-ness de l'objet réel que vous passez. P> Un exemple de surcharge de l'opérateur non constitutionnel: strong> p> Voici un exemple de surcharge de l'opérateur où le paramètre n'est pas constitué.
autre code> lorsque vous dites quelque chose comme: myObject = autre; code> et il applique ceci afin que vous ne puissiez pas changer accidentellement autre code>. p>
Je ne recommande pas de le faire: P> class B
{
public:
const B& operator=(B& other)
{
other.x = 3;
x = other.x;
return *this;
}
int x;
};
void main(int argc, char** argv[])
{
B a;
a.x = 33;
B b;
b.x = 44;
a = b;//both a and b will be changed
return 0;
}
Et c'est const pour la portée de la déclaration et non la vie de l'application.
@Cuppm: Oui, c'est implicite car toute la variable de référence elle-même dépasse également. Cela ne change pas la const-ness de l'objet d'origine lors de sa portée. Par exemple, si vous avez 2 threads.
A Dans ce cas, vous souhaitez déclarer un argument de const afin que votre opérateur d'affectation accepte à la fois des variables non constituées et des variables constantes; Ce dernier cas, en particulier, comprend le résultat d'expressions, qui est une variable de const temporaire et que vous souhaitez généralement prendre en charge les missions. Const Const est constitué tout au long de la fonction, il ne change pas sa constance en dehors de celle-ci.
O, vous dites que g = (a + b * c) le résultat du côté droit est considéré comme une constante ?? Lorsque vous dites qu'un const n'est qu'un const dans la fonction. Dites-vous que une fois que cette fonction est effectuée en cours d'exécution. Ces valeurs pourront être changées à nouveau ??
Vous savez quoi. Cela a du sens maintenant. Si je jette une valeur de const dans une valeur variable. cela ne fait pas la variable a const, cela signifie juste qu'il contient maintenant la valeur du const qui peut être changeable
@numerical, gardez à l'esprit que votre idée ne fonctionne que comme ce que vous avez mentionné s'il est transmis par référence.
Si vous avez utilisé
const CVector& my_vector = GetMyVector(); some_other_vector = my_vector; // call assignment operator - error!
Pour la même raison pour laquelle vous utiliseriez Const n'importe où n'importe où: Pour vous assurer que les modifications futures de la méthode ne modifient pas par inadvertance le paramètre passé, pour aider à documenter l'interface pour informer les appelants qu'il est sécuritaire de transmettre des paramètres sans risque Changer et permettre aux appelants de transmettre des références déclarées comme Const dans le code d'appel.
Vous pouvez utiliser la variété non-Const, mais cela comporte deux répercussions, qui est fonctionnelle et qui est à propos de ce que vous avez, comme l'auteur de la fonction, indiquez à l'utilisateur.
1) Les gens appellent La fonction qui prend une référence de non-Const ne serait pas en mesure de l'appeler à l'aide d'une variable const p>
2) lorsque vous avez un argument de la fonction qui est une référence non-Const, vous signalez: "Je reserver le droit de changer cela ». En règle générale, lorsqu'un utilisateur de votre fonction écrit A = B;, il ne s'attend pas à ce que B de changer. P>
Notez qu'il y a une troisième option que vous pourriez utiliser pour cela, transbord-u-valeur: P>
CVector& CVector::operator= (CVector param) //no reference
Une autre raison est de permettre les conversions. Par exemple: ici, une implémentation peut choisir de ne fournir que l'opérateur d'affectation qui prend une référence constante à une chaîne en tant que paramètre et dépend du compilateur à l'aide d'un constructeur pour créer un constructeur Chaîne du char * "bar". Cela ne fonctionnerait pas si le paramètre OP = 'S n'était pas constitué, car vous ne pouvez pas lier de manière temporaire à une référence non-Const.
Le qualificatif Const fait que le paramètre passe (dans votre exemple est «const cvector & param») en lecture seule. Le qualificatif Const garantit que le paramètre (param) n'est pas modifié à l'intérieur de la méthode opérateur = ().
Sans le qualificatif Const, vous pouvez le suivant: P>
CVector& CVector::operator= (CVector& param)
{
x=param.x;
y=param.y;
param.x = 10; // some random value
param.y = 100;
return *this;
}