Hello la foule

J'ai un petit problème C++ (vous savez, le langage hyper lourd et bien compliqué que tout le monde déteste </end of fud>).

Voila, je dispose d'une classe String (pas la classe standard ...) munie d'un constructeur du type String(const char *).

Dans mon code, j'aimerais qu'une méthode du type:

A::DoSomething(String & a) ou A::DoSomething(String * a)

puis être utilisée comme suit:

A::DoSomething("Hello World");

En gros, une bonne conversion automatique sans devoir chaque fois surcharger les methodes pour qu'elles acceptent les deux types (String et char *).

Si quelqu'un a une solution, je lui en serais très reconnaissant. Dans l'absolu, la solution doit fonctionner sous Visual Studio et gcc vu que mon brol tourne sous windows et linux.

Merci à tous les experts C++

Y a pas l'overload en C++ comme cela existe en Pascal?
En POO tu écrirais:

DoSomething(a: string); overload;
DoSomething(a: PChar); overload;

Mais bon tu n'as pas ton problème de string déjà en pascal il va le transformer tout seul

Je ne veux pas de surcharge des méthodes

La raison est simple: mon "brol" utilise à profusion l'héritage unique (enfin presque, car j'utilise certaine conventions pour utiliser des "Interfaces" et des classes abstraites) à partir d'un objet racine Object (tout comme en java quoi). Le principe est net, clair et simple, n'en déplaise au défenseur du C++. Le seul truc qui m'énerve, c'est cette difficulté à se passer du char * ... merci l'héritage du C ... Ce qui m'empêche de généraliser totalement l'utilisation de mon objet racine dans mes méthodes (pour des Map ou des listes par exemple).

Je veux arriver à ce que le C++ comprenne, d'une manière ou d'une autre, que "xxxx" est un String et non un char * ...

Ah oué flute...

Euh... Pascal est ton ami, sinon je laisse ma langue au chat

C++ n'est pas à typage dynamique, et les conversions implicites n'existent que pour les types numériques...

Je crains que la surcharge ne soit ton seul salut...

Ou alors appeler toujours explicitement (ce qui n'est pas moins lisible AMHA):

A::DoSomething(String("Hello World"));

Je ne suis pas un gourou du C++ mais quand même j'ai eu des cours dessus et je l'ai pas mal utilisé (maintenant moins), et à ce que je me souvienne la solution pour ce type de cas c'est la surcharge de fonction, clairement

Je crois que je vais devoir me tapper un truc du genre si je vous écoute bien ...

#define _S(x) String(x)
#define _PS(x) &String(x)

Ou pour éviter la création d'objets inutiles:

#define _S(x) StringManager::GetString(x)
#define _PS(x) StringManager::GetStringPtr(x)

Cette dernière solution ayant au moins l'intérêt de ne créer l'objet qu'une seule fois pour chaque string unique. Au cout, bien évidement, d'un lookup dans une hashtable.
Ca assure aussi qu'on considère l'objet crée comme +/- "statique" et que donc on ne se tracasse plus de son existence pour la désallocation.

Mais comme les strings fixes seraient de toute façon marginales, on ne pénalise pas trop les perfs.

Bon ok, c'est pas terribles les defines mais si ça me permet de m'en sortir pour le reste...

Quand tu utilises String(x) tu ne dois pas te soucier de la désallocation.

Il n'utilise pas le String standard, donc on n'en sait rien.

il n'a pas fait de new -> au pire destrution automatique à la fin du bloque.

Oui mais non ... justement ... Je ne veux pas que l'objet soit détruit.

Quand tu passes une "chaine" comme paramètre d'une méthode, le compilateur alloue une fois pour toute la chaine dans l'exécutable. On est donc sûr qu'à chaque instant, la référence vers cette chaine reste valide, ou que l'on soit dans le flow d'éxecution du process.

Le comportement n'est pas le même s'il y a destruction automatique de l'objet.

Dans la MFC de Visual C++5 ils ont un opérateur LPCSTR permettant de combiner les char* avec les CString (CString::operator LPCSTR) mais je ne sais plus dans quel sens c'est (CString => char* ou l'inverse), et je ne sais plus comment ça marche.
En résumé, mon post ne sert peut-être à rien

Pour ça, il te faut



Et oui la chaîne "Hello World" est constante