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!