Equivalent en c++

Serge Paccalin

17/10/2003 à 16:18

Le vendredi 17 octobre 2003 à 13:53, Sivaller a écrit dans
fr.comp.lang.c++ :

Pouvez vous me donner l'équivalent en C++ (le convertir) ,merci beaucoup :

"
Program TestProc;

{$apptype CONSOLE}

var dynproc : procedure(t : integer);
...

@dynproc := @myproc1; (*ne sais pas (*void*)dynproc = myproc1 ??*)
...

dynproc(47); (*risque de probléme avec le linker pour le C*)

"

J'ai chercher au moin une demie-journée pour rechercher comment pointer une
procedure, mais en vain.

void (*)(int t) dynproc;
...
dynproc = myproc1;
...
dynproc(47);

--
___________ 2003-10-17 16:15:59
_/ _ _`_`_`_) Serge PACCALIN -- sp ad mailclub.net
_L_) Il faut donc que les hommes commencent
-'(__) par n'être pas fanatiques pour mériter
_/___(_) la tolérance. -- Voltaire, 1763

Gourgouilloult

17/10/2003 à 19:07

Serge Paccalin wrote:

void (*)(int t) dynproc;

Pour déclarer un pointeur de fonction ? Je dirais plutôt

void (* dynproc) (int t);

Gourgou

Serge Paccalin

18/10/2003 à 18:56

Le vendredi 17 octobre 2003 à 19:07:01, Gourgouilloult a écrit dans
fr.comp.lang.c++ :

Serge Paccalin wrote:

void (*)(int t) dynproc;

Pour déclarer un pointeur de fonction ? Je dirais plutôt

void (* dynproc) (int t);

Et tu aurais raison.

--
___________ 2003-10-18 18:56:02
_/ _ _`_`_`_) Serge PACCALIN -- sp ad mailclub.net
_L_) Il faut donc que les hommes commencent
-'(__) par n'être pas fanatiques pour mériter
_/___(_) la tolérance. -- Voltaire, 1763

Frederic Lachasse

19/10/2003 à 05:51

"Sivaller" wrote in message
news:bmol7j$vmm$

Pouvez vous me donner l'équivalent en C++ (le convertir) ,merci beaucoup :

"
Program TestProc;

{$apptype CONSOLE}

var dynproc : procedure(t : integer);

Procedure Myproc1(t : integer);
begin
writeln(t);(*cout>>t>>endl*)
end;

Procedure Myproc2(t : integer);
begin
write(t);(*cout>>t*)
end;

begin
readln(choix); (*cin <<choix*)
@dynproc := @myproc1; (*ne sais pas (*void*)dynproc = myproc1 ??*)
if choix = 2 then @dynproc := @myproc2; (* if (choix==2) {//ne sais
pas//}
dynproc(47); (*risque de probléme avec le linker pour le C*)
end.

// Définition directe de dynproc:
void (*dynproc)(int);

// Autre méthode, plus lisible, avec un typedef
//typedef void dynproc_t(int);
//dynproc_t* dynproc;

// Procedure Myproc1
void Myproc1(int t)
{
cout << t << endl;
}

// Procedure Myproc2
void Myproc2(int t)
{
cout << t;
}

// program
int main()
{
int choix;
cin >> choix;
// Note: Je n'utilise pratiquement jamais "cin >>".
// Je préfère de loin "getline(cin)" dans un std::string
// puis de convertir.

dynproc = Myproc1;
// Note: on peut aussi faire:
//dynproc = &Myproc1;
// cette notation permet de mieux mettre en évidence
// que l'on prend l'adresse de la function.
// Mais le "&" est inutile, car le compilateur considère
// déjà le symbole Myproc1 comme un pointeur vers fonction.

if (choix == 2) {
dynproc = Myproc2; // ou &Myproc2
}

// Pour appeler une fonction, on utilise l'opérateur "()":
dynproc(47);
// Note: comme on peut utiliser "&" pour prendre l'adresse
// vers une fonction, le compilateur accepte aussi que l'on
// utilise "*" pour déréférencer un pointeur vers fonction:
//(*dynproc)(47);
// Note l'utilisation nécessaire des () car l'opérateur "()"
// est plus prioritaire que "*", donc l'expression:
// *dynproc(47)
// est interprété comme:
// *(dynproc(47))
// et ne donne pas du tout le même résultat...
}

--
Frédéric Lachasse -

"Sivaller" <sivaller@lycos.fr> wrote in message
news:bmol7j$vmm$1@news-reader4.wanadoo.fr...

Pouvez vous me donner l'équivalent en C++ (le convertir) ,merci beaucoup :

"
Program TestProc;

{$apptype CONSOLE}

var dynproc : procedure(t : integer);

Procedure Myproc1(t : integer);
begin
writeln(t);(*cout>>t>>endl*)
end;

Procedure Myproc2(t : integer);
begin
write(t);(*cout>>t*)
end;

begin
readln(choix); (*cin <<choix*)
@dynproc := @myproc1; (*ne sais pas (*void*)dynproc = myproc1 ??*)
if choix = 2 then @dynproc := @myproc2; (* if (choix==2) {//ne sais
pas//}
dynproc(47); (*risque de probléme avec le linker pour le C*)
end.

// Définition directe de dynproc:
void (*dynproc)(int);

// Autre méthode, plus lisible, avec un typedef
//typedef void dynproc_t(int);
//dynproc_t* dynproc;

// Procedure Myproc1
void Myproc1(int t)
{
cout << t << endl;
}

// Procedure Myproc2
void Myproc2(int t)
{
cout << t;
}

// program
int main()
{
int choix;
cin >> choix;
// Note: Je n'utilise pratiquement jamais "cin >>".
// Je préfère de loin "getline(cin)" dans un std::string
// puis de convertir.

dynproc = Myproc1;
// Note: on peut aussi faire:
//dynproc = &Myproc1;
// cette notation permet de mieux mettre en évidence
// que l'on prend l'adresse de la function.
// Mais le "&" est inutile, car le compilateur considère
// déjà le symbole Myproc1 comme un pointeur vers fonction.

if (choix == 2) {
dynproc = Myproc2; // ou &Myproc2
}

// Pour appeler une fonction, on utilise l'opérateur "()":
dynproc(47);
// Note: comme on peut utiliser "&" pour prendre l'adresse
// vers une fonction, le compilateur accepte aussi que l'on
// utilise "*" pour déréférencer un pointeur vers fonction:
//(*dynproc)(47);
// Note l'utilisation nécessaire des () car l'opérateur "()"
// est plus prioritaire que "*", donc l'expression:
// *dynproc(47)
// est interprété comme:
// *(dynproc(47))
// et ne donne pas du tout le même résultat...
}

--
Frédéric Lachasse - frederic.lachasse@verizon.net

Sivaller

20/10/2003 à 08:17

merci,je vais le tester
"Frederic Lachasse" a écrit dans le message
de news:pTnkb.1963$

"Sivaller" wrote in message
news:bmol7j$vmm$
Pouvez vous me donner l'équivalent en C++ (le convertir) ,merci beaucoup
:

"
Program TestProc;

{$apptype CONSOLE}

var dynproc : procedure(t : integer);

Procedure Myproc1(t : integer);
begin
writeln(t);(*cout>>t>>endl*)
end;

Procedure Myproc2(t : integer);
begin
write(t);(*cout>>t*)
end;

begin
readln(choix); (*cin <<choix*)
@dynproc := @myproc1; (*ne sais pas (*void*)dynproc = myproc1 ??*)
if choix = 2 then @dynproc := @myproc2; (* if (choix==2) {//ne sais
pas//}
dynproc(47); (*risque de probléme avec le linker pour le C*)
end.

// Définition directe de dynproc:
void (*dynproc)(int);

// Autre méthode, plus lisible, avec un typedef
//typedef void dynproc_t(int);
//dynproc_t* dynproc;

// Procedure Myproc1
void Myproc1(int t)
{
cout << t << endl;
}

// Procedure Myproc2
void Myproc2(int t)
{
cout << t;
}

// program
int main()
{
int choix;
cin >> choix;
// Note: Je n'utilise pratiquement jamais "cin >>".
// Je préfère de loin "getline(cin)" dans un std::string
// puis de convertir.

dynproc = Myproc1;
// Note: on peut aussi faire:
//dynproc = &Myproc1;
// cette notation permet de mieux mettre en évidence
// que l'on prend l'adresse de la function.
// Mais le "&" est inutile, car le compilateur considère
// déjà le symbole Myproc1 comme un pointeur vers fonction.

if (choix == 2) {
dynproc = Myproc2; // ou &Myproc2
}

// Pour appeler une fonction, on utilise l'opérateur "()":
dynproc(47);
// Note: comme on peut utiliser "&" pour prendre l'adresse
// vers une fonction, le compilateur accepte aussi que l'on
// utilise "*" pour déréférencer un pointeur vers fonction:
//(*dynproc)(47);
// Note l'utilisation nécessaire des () car l'opérateur "()"
// est plus prioritaire que "*", donc l'expression:
// *dynproc(47)
// est interprété comme:
// *(dynproc(47))
// et ne donne pas du tout le même résultat...
}

--
Frédéric Lachasse -

merci,je vais le tester
"Frederic Lachasse" <frederic.lachasse@verizon.net> a écrit dans le message
de news:pTnkb.1963$Fc5.1899@nwrdny01.gnilink.net...

"Sivaller" <sivaller@lycos.fr> wrote in message
news:bmol7j$vmm$1@news-reader4.wanadoo.fr...

Pouvez vous me donner l'équivalent en C++ (le convertir) ,merci beaucoup
:

"
Program TestProc;

{$apptype CONSOLE}

var dynproc : procedure(t : integer);

Procedure Myproc1(t : integer);
begin
writeln(t);(*cout>>t>>endl*)
end;

Procedure Myproc2(t : integer);
begin
write(t);(*cout>>t*)
end;

begin
readln(choix); (*cin <<choix*)
@dynproc := @myproc1; (*ne sais pas (*void*)dynproc = myproc1 ??*)
if choix = 2 then @dynproc := @myproc2; (* if (choix==2) {//ne sais
pas//}
dynproc(47); (*risque de probléme avec le linker pour le C*)
end.

// Définition directe de dynproc:
void (*dynproc)(int);

// Autre méthode, plus lisible, avec un typedef
//typedef void dynproc_t(int);
//dynproc_t* dynproc;

// Procedure Myproc1
void Myproc1(int t)
{
cout << t << endl;
}

// Procedure Myproc2
void Myproc2(int t)
{
cout << t;
}

// program
int main()
{
int choix;
cin >> choix;
// Note: Je n'utilise pratiquement jamais "cin >>".
// Je préfère de loin "getline(cin)" dans un std::string
// puis de convertir.

dynproc = Myproc1;
// Note: on peut aussi faire:
//dynproc = &Myproc1;
// cette notation permet de mieux mettre en évidence
// que l'on prend l'adresse de la function.
// Mais le "&" est inutile, car le compilateur considère
// déjà le symbole Myproc1 comme un pointeur vers fonction.

if (choix == 2) {
dynproc = Myproc2; // ou &Myproc2
}

// Pour appeler une fonction, on utilise l'opérateur "()":
dynproc(47);
// Note: comme on peut utiliser "&" pour prendre l'adresse
// vers une fonction, le compilateur accepte aussi que l'on
// utilise "*" pour déréférencer un pointeur vers fonction:
//(*dynproc)(47);
// Note l'utilisation nécessaire des () car l'opérateur "()"
// est plus prioritaire que "*", donc l'expression:
// *dynproc(47)
// est interprété comme:
// *(dynproc(47))
// et ne donne pas du tout le même résultat...
}

--
Frédéric Lachasse - frederic.lachasse@verizon.net

Vous avez filtré cet utilisateur ! Consultez son message

Michaël Monerau

20/10/2003 à 16:17

Sivaller wrote:

merci,je vais le tester

http://www.giromini.org/usenet-fr/repondre.html
--
<=- Michaël "Cortex" Monerau -=>

Sivaller

22/10/2003 à 08:16

// tmp.cpp : Defines the entry point for the console application.
//
ça fonctionne
#include "stdafx.h"

void afficher(int i){printf("%i",i);};

void (*procaff)(int);

int main(int argc, char* argv[])
{
printf("Hello World!n");
procaff=&afficher;
procaff(8);
return 0;
}

"Serge Paccalin" a écrit dans le message
de news:

Le vendredi 17 octobre 2003 à 19:07:01, Gourgouilloult a écrit dans
fr.comp.lang.c++ :

Serge Paccalin wrote:

void (*)(int t) dynproc;

Pour déclarer un pointeur de fonction ? Je dirais plutôt

void (* dynproc) (int t);

Et tu aurais raison.

--
___________ 2003-10-18 18:56:02
_/ _ _`_`_`_) Serge PACCALIN -- sp ad mailclub.net
_L_) Il faut donc que les hommes commencent
-'(__) par n'être pas fanatiques pour mériter
_/___(_) la tolérance. -- Voltaire, 1763

Equivalent en c++

7 réponses

Veuillez sélectionner un problème