Je continue a explorer les arcanes de la POO et cela ne va pas sans mal.
Après m´être battu pendant quelques heures avec des problèmes de définition de constructeur de copie qui ne fonctionnait pas du tout je me retrouve face à un autre problème :

Il semblerait que la norme ne permette pas de promouvoir une variable x du type X vers le type X& sauf si on essaie de le faire vers le type const X&.
Pourquoi : mon problème c´est justement pour les constructeur de copie de mes classes, j´ai le malheur d´appeler une fonction membres non const de la classe que l´on recopie. Cela ne serait pas génant si je pouvais déclarer le constructeur de copie :
A::A(A&);

Mais si je fait ainsi, VC++ me fait des warning à la compilation comme quoi ce que je fait n´est pas conforme à la norme, et comme pour lui donner raison, Dev C++ refuse carrément de compiler, sur des construction du genre :
class A
{
A(A&);
A f(int);
A g();
};

A::g()
{
return f(5);
}

sur la ligne du return il me dit (avec raison) que je n´ai pas le droit de promouvoir un A en A&.
Mais je crois avoir compris que j´ai le droit donc de convertir un A en const A& et donc qu´il faudrait que je déclare le constructeur de copie avec un argument const. Mais comme je l´ai déjà dit, je modifie un minuscule petit truc dans l´objet appelé.

Alors ma question est : y a-t-il une manière d´éviter de devoir déclarer le constructeur de copie avec un argument const ? parce que ça semble assez artificiel cette interdiction de promouvoir un type en une référence vers ce type, donc il y a peut-être un moyen de la contourner non ?

merci d´avance.

il n´est pas ici question d´interdire la promotion, mais de rester cohérent vis-a-vis des arguments et des valeurs de retour.

tout d´abord un copy ctor DOIT prendre un const & ! pourquoi ? non pas que le compilo l´empeche vraiment, mais par simple logique. Si je construis un objet a partir d´un autre, je n´ai SURTOUT pas envie que mon objet se voit modifié au passage ! sans quoi tout le monde peut faire n´importe quoi dans ses bouts de code, et apres qq operations, l´état de l´objet est parfaitement inconnu. Il FAUT donc garantir tout ce qui peut l´etre en usant et abusant de const (methodes consts, objects consts, references consts, etc.)

pour ton passage f > g > A(), manque ce que tu mets dans f(int) pour qu´on puisse dire exactement ce qui ne va pas. Retourner un objet deja existant, un nouveau, celui en cours, etc. a des implicatons différentes.
Par ex. si tu te bases sur this (qui est TOUJOURS un pointeur const, a moins de la const_caster explicitement), c´est rapé.

ma fonction f est n´importe quelle fonction qui renverrait un A et non pas un A& (c´était juste un exemple de construction que le compilo n´accepte pas).

En fait, mes classes gèrent des flux de données et pour copier une instance d´une de ces classe, j´extrait le flux de l´instance que l´on copie vers celle où je copie. Mais la manière dont tout est écrit m´empêche de le faire sur une reférence constante.

Par contre le const_cast est exactement ce qu´il me fallait, à savoir un moyen de supprimer l´attribut const d´un objet qui ne l´est pas vraiment.
Donc maintenant ça marche parfaitement (c´est ce genre de chose que je ne maitrise pas du tout en C++, particulièrement tout les opérateurs de cast autre que ceux qui sont implicite).

merci beaucoup.