Discussion :

[yvde01]

Bonjour à tous,

Connaissant très peu C++, je viens ici pour chercher de l'aide.

J'ai besoin de transférer une adresse mémoire contenue dans un pointeur à une fonction qui ne reçoit qu'un type double comme paramètre.
Donc je cherche à convertir la valeur d'un pointeur vers une variable de type double puis de faire l'inverse plus tard.

Quelqu'un a-t-il une solution simple à ce problème. Je n'ai pas su trouver de réponse adéquate à ma question.

[CGi]

La solution est le cast, mais il doit y avoir un gros problème de conception de ton projet pour être amener à faire cela ?
Peux-tu expliquer pourquoi tu es amené à faire cela ? il y a surement une solution plus adaptée.

[koala01]

Salut, et bienvenue sur le forum.

Alors, là, je crois que tu pars sur quelque chose qui n'est absoluement pas conseillé... A moins que tu ne te soies simplement mal exprimé .

Car, si j'ai bien compris, tu veux transformer l'adresse mémoire représentée par un pointeur (qui est, par nature, un entier généralement non signé, composé d'un "nombre de bits suffisant" que pour pouvoir donner accès à l'ensemble des adresses mémoire du système) en double, visiblement, pour pouvoir le transmettre comme paramètre à une fonction qui attend un double.

Et là, sincèrement, je me pose une seule question : POUR QUOI FAIRE ?

Pourquoi diantre veux tu transmettre une adresse mémoire à une fonction qui s'attend à recevoir un double comme paramètre
Dans quel but veux tu faire une telle chose
quel genre de résultat espères tu obtenir, sachant que l'on ne manipule -- a priori -- absolument jamais une adresse mémoire et un double de la même manière

Maintenant, peut être ne nous as tu pas tout dit... Peut être as tu un pointeur de type double * (un pointeur indiquant explicitement que l'on trouvera un double à l'adresse indiquée). Si tel est le cas, ce n'est pas l'adresse mémoire (la valeur du pointeur) que tu dois transmettre à la fonction, mais ... la valeur qui se trouve à l'adresse indiquée par le pointeur. par exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/* Voici la fonction qui s'attend à recevoir un double et que je veux appeler */
void foo(double d); // je ne sais pas ce qu'elle fait
                              // cela n'a pas d'importance ici
 
int main(){
    double pi= 3.1415926; // Ca, c'est un double
    double * ptr_pi = & pi; // ca, c'est un pointeur sur double qui contient l'adresse
                            // mémoire à laquelle se trouve la variable pi
                            // (qui est bel et bien du type double, vu que j'en ai décidé ainsi)
    /* je peux assez facilement récupérer "ce qui se trouve à l'adresse représentée par le pointeur
     * il suffit de faire précéder l'identifiant (le nom de la variable correspondant au)du pointeur 
     * par une étoile
     */
    foo( * ptr_pi); // Je transmet à foo "ce qui est pointé" par ptr_pi (ce qui se trouve à l'adresse 
                    // représentée par ptr_pi)
}

Si maintenant, ton pointeur pointe sur une donnée qui est "d'un autre type" que double et que ton pointeur n'est pas non plus de type char * (parce qu'il y a une mention spéciale concernant la conversion de et vers les char * dans la norme), c'est sans doute que tu ne veux vraiment pas appeler cette fonction qui nécessite un double en paramètre, car le résultat -- quel qu'il puiss être -- risque d'être vraiment surprenant

[yvde01]

Effectivement je comprends votre étonnement et que vous trouviez ma demande un peu farfelue.

En faite je suis entrain de faire un programme dans un autre langage qui ne connait pas, à mon grand étonnement, les pointeurs.
Et je suis obligé d'utiliser ce langage spécifique pour mon application.

Ce programme est scindé en deux parties pour des raisons qui seraient trop longues à expliquer ici.
La seule zone commune entre ces deux parties ne peut recevoir que des variables globales de type double.
D'où ma recherche pour transformer un pointeur en une variable double.

J'ai un tableau que je crée dans la partie 1 et j'ai besoin de le récupérer dans la partie 2 et je pensais utiliser un pointeur.
Je peux récupérer l'adresse de ce tableau en le passant à une fonction par référence, seul façon d'avoir l'adresse de ce tableau.

Ensuite je pensais récupérer cette adresse dans une DLL en c++ pour la transformer et en ressortir une valeur double et la stocker dans une variable globale dont je parlais auparavant.
Dans la 2eme partie je récupère les éléments de mon tableau dans une autre DLL.

Mon problème est que je connais très mal le cast en c++ et que, jusqu'à présent, je n'ai pas su trouver la solution à mon problème.

Merci pour votre aide.

[kick54]

Effectivement je comprends votre étonnement et que vous trouviez ma demande un peu farfelue.

En faite je suis entrain de faire un programme dans un autre langage qui ne connait pas, à mon grand étonnement, les pointeurs.
Et je suis obligé d'utiliser ce langage spécifique pour mon application.

Ce programme est scindé en deux parties pour des raisons qui seraient trop longues à expliquer ici.
La seule zone commune entre ces deux parties ne peut recevoir que des variables globales de type double.
D'où ma recherche pour transformer un pointeur en une variable double.

J'ai un tableau que je crée dans la partie 1 et j'ai besoin de le récupérer dans la partie 2 et je pensais utiliser un pointeur.
Je peux récupérer l'adresse de ce tableau en le passant à une fonction par référence, seul façon d'avoir l'adresse de ce tableau.

Ensuite je pensais récupérer cette adresse dans une DLL en c++ pour la transformer et en ressortir une valeur double et la stocker dans une variable globale dont je parlais auparavant.
Dans la 2eme partie je récupère les éléments de mon tableau dans une autre DLL.

Mon problème est que je connais très mal le cast en c++ et que, jusqu'à présent, je n'ai pas su trouver la solution à mon problème.

Merci pour votre aide.

Bonsoir,
Peux-tu être plus précis sur ce mystérieux langage qui ne compte pas les pointeur ? ... ou donner un extrait de code ?

[koala01]

En faite je suis entrain de faire un programme dans un autre langage qui ne connait pas, à mon grand étonnement, les pointeurs.
Et je suis obligé d'utiliser ce langage spécifique pour mon application.

Ce qui te met dans une situation vraiment peu enviable...

Ce programme est scindé en deux parties pour des raisons qui seraient trop longues à expliquer ici.
La seule zone commune entre ces deux parties ne peut recevoir que des variables globales de type double.
D'où ma recherche pour transformer un pointeur en une variable double.

A priori, si tu te retrouves avec un pointeur alors que la "zone commune" s'attend à manipuler un double, c'est que tu a "loupé" quelque chose...

C'est que, d'une manière ou d'une autre, les données que tu prépares "de ce coté" ne sont pas "en adéquation" avec l'usage que "l'autre coté" prévoit d'en faire.

Si tu veux que les deux cotés puissent dialoguer correctement, sans risquer de "foutre le boxon" dans ce qui se passe "de ce coté", il va falloir que tu comprennes très précisément la "raison d'être" du double que "l'autre coté" s'attend à recevoir: à quoi il correspond, à quel usage il est destiné et comment il sera manipulé.

J'ai un tableau que je crée dans la partie 1 et j'ai besoin de le récupérer dans la partie 2 et je pensais utiliser un pointeur.
Je peux récupérer l'adresse de ce tableau en le passant à une fonction par référence, seul façon d'avoir l'adresse de ce tableau.

Voilà une très mauvaise idée...

Il ne sert à rien d'essayer de "truander" le système en lui faisant prendre des oranges pour des balles de tennis.

Ce que tu dois faire, de trouver "l'étape qui manque" pour être en mesure de transmettre un double utilisable par "l'autre coté" à partir des données que tu as préparées et récupérées dans ton tableau.

** Peut-être ** devras tu mettre en place une boucle qui évaluera la valeur à donner au double attendu pour chaque élément du tableau, avant de faire appel (pour chacun des éléments du tableau) au processus mis en place par "l'autre coté"

Ou peut-être devras tu évaluer -- sous la forme d'un double -- une sorte de "hash code" basé sur l'ensemble des éléments de ton tableau et le transmettre à "l'autre coté"

Quoi qu'il en soit, le seul moyen de t'assurer que tu transmettra des données "correctes et cohérents" à "l'autre coté" est de savoir ... la manière dont ces données seront traitées par l'autre coté.

Ensuite je pensais récupérer cette adresse dans une DLL en c++ pour la transformer et en ressortir une valeur double et la stocker dans une variable globale dont je parlais auparavant.
Dans la 2eme partie je récupère les éléments de mon tableau dans une autre DLL.

que la transformation des informations récupérées au travers de ton tableau se face dans une DLL, dans une autre même d'une manière tout autre n'a, en définitive, aucune espèce d'intérêt...

ce genre de considération relève plus de l'organisation générale de ton code que d'autre chose

De qui importe surtout, c'est de déterminer quelles transformations doivent être apportées aux données obtenues au travers de ton tableau pour qu'elles être transmises à "l'autre coté". Et il n'y a rien à faire, le simple fait de prendre l'adresse du tableau et d'essayer de la faire passer pour un double n'est, clairement, pas une bonne idée

Mon problème est que je connais très mal le cast en c++ et que, jusqu'à présent, je n'ai pas su trouver la solution à mon problème.

Peut être est-ce parce que le cast n'est, en l'état, clairement pas la solution à ton problèe

[yvde01]

@koala01
Merci pour tes remarques les bienvenues.

J'avais pensé à transférer mon tableau élément par élément comme tu l'expliques dans ton message, d'autant plus que mon tableau est composé de valeurs double.
Le hic est que mon tableau comporte des milliers d'éléments et transférer les éléments les uns après les autres de la partie 1 vers la partie 2 me semble improbable (probablement beaucoup trop long).
En plus je ne vois pas comment, pour l'instant, organiser séquentiellement ce travail. Je rappelle que les 2 parties tournent en parallèle sans dialogue entre les 2. Du moins à mon niveau. Peut-être qu'en tapant dans les événements qui gère mes 2 parties il y a quelque chose à faire. Mais cela me semble aussi compliqué que mon idée sur laquelle je suis parti. Il y a une quantité inouïe d'objet déjà existant et des couches à n'en plus finir. Donc se retrouver dans ce dédale = bonne chance.
Je n'ai pas essayé cette solution parce qu'il me semblait que mon idée de transférer un pointeur serait plus rationnelle. Mais peut-être que c'est une solution parmi d'autre.

Comme je l'ai dit auparavant, la seule possibilité de dialoguer entre les 2 parties est d'accéder à quelques variables double. Je ne sais pas combien j'en ai à disposition mais je ne pense pas une infinité.
Donc je pensais mettre mon adresse tableau dans une des variables globales de type double (donc "caster" ma variable pointeur en double) puis de récupérer la valeur de cette variable pour faire le cheminement inverse dans la partie 2.
Cette variable globale n'est là que pour faire le transfert. Il est clair que je ne l'utilise pas tel quel, n'y dans la partie 1, n'y dans la partie 2.

Ensuite, comme je ne peux pas utiliser un pointeur comme on devrait le faire normalement, j'utiliserait une dll c++ pour faire ce travail.
Une première dll c++ pour transformer mon adresse en une valeur de type double, sauvegarder cette valeur double dans une des variable globale (cela ne me pose pas de problème) puis une 2eme dll c++ pour accéder/récupérer les éléments de mon tableau dans la 2eme partie.

Ce sont ces dll qui me pose problème (surtout la première) car je ne sais pas faire ces transformations en c++.
Raison pour laquelle je viens demander de l'aide pour ces transformations.

Avec mes remerciements.

En écrivant ces lignes il me vient l'idée suivante: est-il possible de sauvegarder mon tableau sur le disque et de le récupérer dans la 2eme partie. Il reste toujours le problème de la séquence de ces opérations. En creusant un peu ... espoir!

[kick54]

Ben oui, un bon vieux fichier, y'a rien de tel !

[mintho carmo]

les 2 parties tournent en parallèle sans dialogue entre les 2.

Il faudrait détailler ce que sont ces "parties" mais si c'est 2 programmes/process indépendants, alors leurs espaces mémoires ne sont pas partagés et ton pointeur sera invalide dans la partie 2.

L'idée du fichier est possible. Il existe d'autres méthodes, comme utiliser le réseau ou un protocole comme IPC (Inter Process Communication).

[kick54]

Au final :
Quels sont les langages que tu utilises ; C ou bien C++ ?... et l'autre ?
Quels est le système d'exploitation ?

[yvde01]

Je me dirigerais plutôt vers c++
L'autre langage est MQL
Chaque partie de mon programme appartiennent à 2 objets distincts.
Certaines informations glanées sur internet me laisse fortement pensé que la mémoire est commune.
Donc je reviens à ma question du début:

comment puis-je transférer une variable contenant une adresse mémoire vers une variable de type double.

[kick54]

Je me dirigerais plutôt vers c++
L'autre langage est MQL
Chaque partie de mon programme appartiennent à 2 objets distincts.
Certaines informations glanées sur internet me laisse fortement pensé que la mémoire est commune.
Donc je reviens à ma question du début:

comment puis-je transférer une variable contenant une adresse mémoire vers une variable de type double.

Bonjour,
J'ai trouvé ceci sur un autre Forum
https://stackoverflow.com/questions/...-mql4-to-c-dll
Cordialement

[koala01]

Le gros problème, c'est que, tant que l'on n'aura pas plus d'information, il nous sera parfaitement impossible de te conseiller...

Il y a, en effet, beaucoup trop de possibilités, au vu de ce que l'on sait, pour choisir celle qui sera "la plus adaptée à ton problème".

Les informations majeures qui nous manquent pour avoir une chance de te conseiller correctement étant : quel langage cette "deuxième partie" utilise-t-elle et que fait cette deuxième partie des informations transmises au travers d'un double n'utilise-t-elle que ce seul double, ou est elle destinée à utiliser plusieurs double contigus en mémoire et dans ce cas, combien de double contigus prend elle en charge

Tant que nous n'aurons pas ces informations, nous ne pourrons pas aller plus loin...

Cela fait trois fois que l'on te demande quel langage est utilisé, et tu n'as pas encore répondu à la question

Je t'ai demandé comment le double transmis est destiné à être utilisé, et tu n'as pas répondu à la question, sous prétexte que "c'est un foutoir impossible à démeler". Soit! Est-ce que cela t'empêche de vérifier si ce double est utilisé seul ou si "le process" va aussi aller jouer avec les données contigues en mémoire

La règle principale sur un forum est "aide nous à t'aider", car nous ne sommes pas à tes cotés, et encore moins dans ta tête. Nous ne disposons que des informations que tu acceptes de nous donner, et nous n'avons aucune idée ni de ce que tu penses, ni de ce que tu as essayé, ni des décisions que tu as pu prendre (et encore moins des raisons qui t'ont fait les prendre) !

Or, pour que l'on soit en mesure de t'aider, il faut que nous puissions nous faire une idée de toutes ces choses. Le moyen le plus simple pour y arriver étant -- si possible -- un code minimal compilable (un code qui reproduise le problème en un minimum de lignes).

Tant que tu n'auras pas compris ce fait, et que tu ne te décideras pas à nous aider à t'aider, nous ne pourrons rien de plus pour toi

[henderson]

Salut !
Si j'ai tout compris :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
char Text[256];
char String[256]; // <<<
strcpy(String, "012345678"); // <<< une valeur quelconque
char *pString = &String[0];  // <<< pointeur vers la chaîne
double d = (int)pString;     // <<< contenu du pointeur
// contenu de d
sprintf(Text, "%lf", d);
MessageBox(NULL, Text, "?", MB_ICONEXCLAMATION|MB_OK);

A plus !

[CGi]

Chaque partie de mon programme appartiennent à 2 objets distincts.

Qu'entends-tu par "partie" et "objet" ?

[yvde01]

Henderson est sur la bonne voie. Merci.

Je suis venu ici pour avoir une info sur le transtypage en c++ d'une variable contenant une adresse mémoire en hexadécimal vers une variable double et vice-versa.

Ce qui se passe avant le passage adresse mémoire vers double et plus tard double vers adresse mémoire n'influence en aucune manière ces 2 transformations.
J'ai juste besoin d'une variable double dans mon programme car je n'ai que ça à disposition pour transmettre l'information.

Je prends en compte toutes les remarques que vous m'avez données et qui me seront certainement utile pour la suite de mon programme.

Pour l'instant je suis bloqué sur ces transformations. Une fois cette étape franchie je ne me fais pas de souci pour la suite je pourrai avancé dans la seconde partie.

Avec mes remerciements

[mintho carmo]

La syntaxe donnée par henderson est plus du C (mais valide en C++)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
double d = (double)p;
void* p = (void*)d;

En C++, on va préférer les fonctions de cast (ce qui est équivalent dans ce cas) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
double d = reinterpret_cast<double>(p);
void* p = reinterpret_cast<void*>(d);

[yvde01]

Merci mintho-carmo pour ta solution.
Cependant chez moi j'ai le message d'erreur: impossible de convertir
Ta variable p c'est la valeur du pointeur?

[mintho carmo]

C'est un pointeur.

[koala01]

Je suis venu ici pour avoir une info sur le transtypage en c++ d'une variable contenant une adresse mémoire en hexadécimal vers une variable double et vice-versa.

Nous sommes bien d'accord...

Ce qui se passe avant le passage adresse mémoire vers double et plus tard double vers adresse mémoire n'influence en aucune manière ces 2 transformations.
J'ai juste besoin d'une variable double dans mon programme car je n'ai que ça à disposition pour transmettre l'information.

C'est justement là que tu fais fausse route...

Car la raison pour laquelle tu veux tenter ce genre de transtypage est -- a priori -- mauvaise!

Te donner la solution sans attirer ton attention sur les problèmes que cela risque de provoquer dans ton programme n'est donc pas acceptable.

Parce que ton but -- et donc, indirectement, le notre -- n'est pas d'arriver à avoir un code qui se contente de compiler, ni même un code qui "devrait fonctionner", mais bien d'avoir un code qui fasse effectivement ce que l'on attend de sa part, et qui le fasse correctement, sans risquer de "faire planter le système" à tout moment.

Car un programme qui plante ou qui fournit des résultat incohérents est un programme incorrect, tout simplement; un programme qui risque de provoquer des catastrophes.

Je prends en compte toutes les remarques que vous m'avez données et qui me seront certainement utile pour la suite de mon programme.

Pour l'instant je suis bloqué sur ces transformations. Une fois cette étape franchie je ne me fais pas de souci pour la suite je pourrai avancé dans la seconde partie.

Justement, le meilleur moyen d'avancer rapidement en développement informatique est d'avoir une "vue d'ensemble" du problème.

Quoi que tu fasses, la moindre instruction, la moindre fonction, la moindre donnée n'a de l'intérêt que par l'usage qui en sera fait "ailleurs". Si tu n'as pas cette "vue d'ensemble" au moment de te concentrer sur la vue limitée d'un problème particulier, il y a neuf chances sur dix que la solution que tu vas apporter à ce problème en particulier ne soit pas correcte par rapport à l'usage qui sera fait du résultat.

Si tu veux obtenir au final quelque chose qui "tienne un minimum la route", tu n'as pas d'autre choix que de prendre le temps d'élargir régulièrement ton "champs de vision" de la solution que tu mets en oeuvre pour t'assurer qu'elle s'intègre correctement dans l'existant, et surtout, qu'elle soit cohérente avec ce qui existe.

Et c'est donc la responsabilité que nous avons également en tant que "support externe" et en tant que professionels