Discussion :

[superpok]

salut,

Voila j'ai une question bien que a mon avis cela soit impossible.
Y'a t-il une solution (feinte), pour faire en sorte de rediriger printf vers un composant TMemo de borland.

Autre question : ya t-il moyen sous borland ou autre EDI windows, d'utiliser _popen() sans avoir la fenetre msdos qui apparait .?

merci.

[Galip]

Salut,

J'ai pas trop saisi ton problème,

Par ex, tu as des printf dans le même code que ton Memo1, et tu voudrais que les printf de ton programme affiche leur résultat dans des Memo1 ??.

[superpok]

oui tout a fait, car mon appli graphique utilise un classe que j'ai faite pour du programme en console.
Sa marche, mais sa n'affiche pas les printf.

[maxim_um]

Il n'y a aucun problème, tu peux tout faire en c++, cependant ce n'est pas ton printf (ça c'est du C) que tu dois rediriger, mais la ou les variables que tu utilises dans ta fonction printf.

[Galip]

Ouais sinon utilise l'outil de recherche de Borland, tu remplces printf par Memo1->Lines->Add.

Mais bon après t'aura toujours 2 3 trucs à retoucher, dsl mais j'ai pas d'autres idées, ptre que une autre personne aura une méthode un peu plus clair


A+

[superpok]

bha oui, je connais bien memo->lines-add ..

mais voila, je vais quand meme pas passer en parametre de mon constructeur de ma classe (console) l'adresse de l'objet Tmemo, et remplacer mes printf par des memo->lines->add ?

c laid.

[maxim_um]

Ton problème est pourtant simple, tout ce que tu as à faire, c'est de rajouter une méthode à ta classe qui te renvoi une chaîne string. cela te permet de faire évoluer ta classe tout en lui permettant de rester compatible avec tes anciennes applications. Est-ce qu'il te faut un exemple ?

[Pierre Levy]

Bonjour maxim_um.
En ce qui me concerne je serai très interessé par un exemple.
Merci

[maxim_um]

Salut Pierre Levy,
je vais essayer de te proposer un exemple, je réfléchis à la question, notamment à la manière dont je peux présenter la chose, à dans quelques minutes

[maxim_um]

Bon, après relecture du topique, il est essentiellement questions,

1: de class (donc de C++/iso)
2: de printf (donc de C, mais comme en 1 il y a class et que C est implémenté dans C++, alors de C++/iso)
3: de Memo (donc de C++/VCL)

Ceci conduit au constat suivant, ma classe devra être programmé en C++/iso et ne doit pas faire intervenir la VCL.
Pour m'assurer de la portabilité du code, et résister à la tentation de la VCL, j'aime bien travailler avec deux compilateurs différents. Ainsi, j'utiliserais d'abord MingW Developer Studio pour définir ma classe, ensuite C++ Builder pour le TMemo, et enfin revenir à Ming Developer studio pour m'assurer que mon code initial est toujours valide, autrement dit que ma classe est restée indépendante de la VCL et est donc toujours portable.

Voilà, j'ai tracé les grandes lignes, je prépare le code.

Grrrrrrrrrrrrr, quand c'est pas le téléphone qui sonne c'est l'interphone, Grrrrrrrrrrrrr

[maxim_um]

Bon voilà l'étape 1:

Avec MingW Developer Studio, vous pouvez rester sur C++ Builder mais il faut désactiver la VCL dans votre projet console

L'en-tête de la classe exemple classexp.h

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
17
18
19
20
21
22
23
24
25
26
27
28
29
 
 
//classexp.h
 
//Suite à la demande de Pierre Levy, voici une des solutions possibles répondant à la requête
//[BORLAND c++] rediriger printf sur http://www.developpez.net/forums/showthread.php?p=2196243
//Pour l'exemple, j'utilise ici le strict minimum, ceci à titre d'illustration.
//Cependant si vous en ressentez le besoin, il est possible de l'agrémenter ou de le compléter. 
 
 
//inclusion pour l'utilisation de printf
#include <stdio.h>
 
 
//je déclare une classe quelconque que j'appelle ClasseExemple
class CExemple	
{
private:
	//je déclare une variable nbr pour l'exemple
	int nbr;
public:
	//Constucteur de la class, il initialisera la variable nbr
	CExemple();
	//je déclare une méthode de Classe public FonctionInitiale, 
	//son implémentation est définie dans corp.cpp
	int FInitiale(void);
};
 
//fin de classexp.h

L'implémentation de la classe exemple classexp.cpp

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
17
18
19
20
21
22
23
 
 
//classexp.cpp
 
//inclusion de la déclaration de la méthode de classe
#include "classexp.h"
 
//initialisation de la variable nbr
CExemple::CExemple()
{
  nbr=1;
}
 
//implémentation de la méthode FInitiale
int CExemple::FInitiale()
{
  char *chaine = "Le langage C++ = Le langage C";
  printf("Bonjour\n");
  printf("Il faut savoir que %s + %d\n",chaine,nbr);
  return 0;
}
 
//fin de l'implémentation classexp.cpp

Voilà enfin le corp de l'application console main.cpp

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
17
18
19
20
21
22
 
 
//main.cpp
 
#include <stdio.h>
//inclusion de la déclaration et de l'implémentation 
//de la classe CExemple utilisé plus bas
#include "classexp.h"
 
 
 
int main() 
{
//déclaration d'un objet classeAppel de type ClassExemple, cet objet
//"hérite" des attributs et des méthodes de la classe CExemple
CExemple cAppel;
//appel de la fonction FInitiale "héritée"
cAppel.FInitiale();
return 0;
}
 
// fin de main.cpp

Voilà, je vous laisse compiler le code et lancer l'exécutable produit.

[maxim_um]

NB:La mise en forme sera faite au fur et à mesure, elle me prend du temps...

Attaquons-nous maintenant à l'étape avec le Memo et à la modification de notre classe:

Remarque: On peut faire la modification parce qu'on est responsable de l'entretien de notre classe.
S'il en était autrement, il aurait été plus judicieux d'utiliser l'héritage au lieu de la modification directe.

Lancement de C++ Builder

On lance C++ Builder puis Fichier-> nouveau -> application fiche vcl.
Ensuite Fichier -> enregistrer le projet sous -> précédentdossier*

*utiliser le même dossier que le précédent projet sous Ming Developer studio, c'est à dire là où se trouve classexp.h et classexp.cpp

Une fois le projet enregistré, on ajoute un TMemo Memo1 et un TButton Button1 sur notre Form1.
Enfin, on termine par un double clique sur le bouton Button1, pour générer le code correspondant à l'événement OnClick de Button1, c'est à dire la méthode void __fastcall TForm1::Button1Click(TObject *Sender).

Le squelette de notre application VCL est fait, reste à intégrer notre classe dans le projet et à la modifier.


Intégration de notre classe dans le projet:

Bon maintenant clique droit sur le projet dans la fenêtre de projet, on clique sur ajouté, et on sélectionne classexp.cpp, on fait de même pour classexp.h pour y accéder facilement.
Maintenant notre classe est référencée dans notre projet, mais pas encore incluse (l'inclusion se fera avec #include "classexp.h" dans l'unit1 du projet)...

On ouvre classexp.cpp ou classexp.h par un double clique dessus sur la fenêtre de projet, et ainsi on peut procéder aux modifications...

Comme spécifié plus haut, en #7, on va ajouter une méthode à notre classe qui renvoie une chaîne de type string. Cela permet de faire évoluer notre classe tout en lui permettant de rester compatible avec les autres applications qui l'utilisent.


Définissant nos besoins :
nous utiliserons le type string et les flux du C++, nous devront inclure <string> <sstream> et <iostream>, bien qu'ils ne soient pas tous indispensables.

PS: Je sais qu'il est aussi possible de faire quelque chose d'intéressant avec la fonction stdout, elle permet de rediriger la sortie standard, comme j'ai pris une autre voie, je ne l'utiliserais pas, mais rien ne vous empêche d'approfondir ce point.


Modification de notre classe depuis le projet

voici de manière brute les modifications qui seront apportées:

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
17
18
19
20
21
22
23
24
25
26
 
 
//modification 1/2 pour classxp.h
//inclusion
#include <string>
#include <iostream>
#include <sstream>
//fin de la modification  1/2
 
//modification 2/2  pour classxp.h
//déclaration de ma nouvelle méthode de classe FSecondaire
std::string FSecondaire(void);
//fin de la modification  2/2
 
//modification 1/1 pour classxp.cpp
//implémentation de la méthode de classe FSecondaire
std::string CExemple::FSecondaire()
{
	//je commenterai ce code plus tard si le besoin s'en fait ressentir
	char *chaine = "Le langage C++ = Le langage C";
	std::ostringstream vretour;
	vretour << "Bonjour\r\n"
			<< "Il faut savoir que " <<  std::string(chaine) << " + " << nbr << "\r\n";
	return vretour.str();
}
//fin de la modification  1/1

Voici maintenant notre classe modifiée

L'en-tête de la classe exemple classexp.h

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
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
 
//classexp.h
 
//Suite à la demande de Pierre Levy, voici une des solutions possibles répondant à la requête
//[BORLAND c++] rediriger printf sur http://www.developpez.net/forums/showthread.php?p=2196243
//Pour l'exemple, j'utilise ici le strict minimum, ceci à titre d'illustration.
//Cependant si vous en ressentez le besoin, il est possible de l'agrémenter ou de le compléter. 
 
//modification 1/2
//inclusion
#include <string>
#include <iostream>
#include <sstream>
//fin de la modification  1/2
 
//inclusion pour l'utilisation de printf
#include <stdio.h>
 
 
 
//je déclare une classe quelconque que j'appelle ClasseExemple
class CExemple	
{
private:
	//je déclare une variable nbr pour l'exemple
	int nbr;
public:
	//Constucteur de la class, il initialisera la variable nbr
	CExemple();
	//je déclare une méthode de Classe public FonctionInitiale, 
	//son implémentation est définie dans corp.cpp
	int FInitiale(void);
 
//modification 2/2
//déclaration de ma nouvelle méthode de classe FSecondaire
std::string FSecondaire(void);
//fin de la modification  2/2
 
 
};
 
//fin de classexp.h

L'implémentation de notre classe classexp.cpp

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
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
 
//inclusion de la déclaration de la méthode de classe
#include "classexp.h"
 
//initialisation de la variable nbr
CExemple::CExemple()
{
  nbr=1;
}
 
//implémentation de la méthode FInitiale
int CExemple::FInitiale()
{
  char *chaine = "Le langage C++ = Le langage C";
  printf("Bonjour\n");
  printf("Il faut savoir que %s + %d\n",chaine,nbr);
  return 0;
}
 
//modification 1/1
//implémentation de la méthode de classe FSecondaire
std::string CExemple::FSecondaire()
{
	//je commenterai ce code plus tard si le besoin s'en fait ressentir
	char *chaine = "Le langage C++ = Le langage C";
	std::ostringstream vretour;
	vretour << "Bonjour\r\n"
			<< "Il faut savoir que " <<  std::string(chaine) << " + " << nbr << "\r\n";
	return vretour.str();
}
//fin de la modification  1/1
 
 
//fin de l'implémentation classexp

et enfin pour finire, voici ce à quoi ressemble
l'unit1.cpp du projet C++ Builder,

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
17
18
19
20
21
22
23
24
25
26
 
 
//---------------------------------------------------------------------------
 
#include <vcl.h>
#pragma hdrstop
 
#include "Unit1.h"
#include "classexp.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
	: TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
CExemple cAppel;
AnsiString vtexmemo = cAppel.FSecondaire().c_str();
Memo1->Lines->Add(vtexmemo);
}
//---------------------------------------------------------------------------

On enregistre les changements, on recompile et on exécute notre application.

Après avoir vérifié que ça fonctionne conformément à nos attentes, on retourne sous Ming Developer studio.
On ouvre à nouveau notre ancien projet, on le compile, et on remarque qu'il s'exécute correctement.

On a redirigé printf (pensez aussi à la possible utilisation de stdout cité plus haut) et
Notre classe est restée compatible avec notre ancienne application. Donc mission accomplie, enfin presque, reste à optimiser le code en fonction des besoins.

Voilà, j'espère que cet exemple apportera satisfaction aux lecteurs, et en particulier à Pierre Levy

[Pierre Levy]

Merci beaucoup à maxim_um.

[superpok]

oui, par contre sa ne resout pas mon probleme.
je ne peux pas faire de methode qui renvoi des string ou char* ou autre.

sans utiliser le principe du return, il me faut une autre solution.

[superpok]

bon j'ai reussi

j'ai crée un fichier header qui selon le define :
#define BORLANDGUI

Affichera l'information avec printf ou avec Memo->Lines->Add()

/*---------------------------------------------------------------------------------------------------
Header by superpok (M. Pauquet) - 2007

Rediriger l'affichage facilement [ STDOUT ou TMEMO ] !
aide: Sous borland, veillez a bien laisser le #define BORLANDGUI
Créer l'objet CDebug en passant en parametre le pointeur
vers votre objet TMemo, puis faite :
MDEBUG("mon message !");

En mode console, commenter #define BORLANDGUI et faite simplement :
MDEBUG("mon message !");
----------------------------------------------------------------------------------------------------*/
#ifndef CDEBUG_H
#define CDEBUG_H

#include <stdio.h>

#define BORLANDGUI

#ifdef BORLANDGUI
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
// on estime qu'une ligne ne fera jamais plus de 256 caracteres
static char CDebugBuffer[256]="";
static TMemo* CDebugMemo;

// verification ...
// si la classe n'as pas été créee
// pointeur CDebugMemo pointe sur rien...
static CDebugCreated = 0;

#define MDEBUG(x...) \
if(CDebugCreated) \
{ \
snprintf(CDebugBuffer,256,x); \
CDebugMemo->Lines->Add(CDebugBuffer); \
}

class CDebug
{
public:
CDebug(TMemo* myptr)
{
CDebugMemo = myptr;
CDebugCreated = 1;
}
};

#else
#define MDEBUG(x...) { printf(x); printf("\n"); }
#endif

#endif

voila le resultat est sympatique, avec exactement le meme code dans les 2 application,
on obtient le meme affichage : RESULTAT FLAGRANT

par contre, sa marche aussi sans ';' a la fin de la commande, je sais pas trop pourquoi

[superpok]

par contre, il faut faire attention a qui crée l'objet CDebug
c'est assez flou pour moi aussi ^^

[DjmSoftware]

bonjour
cela n'est malheureuement pas exact Superpok

en effet

Rediriger l'affichage facilement [ STDOUT ou TMEMO ] !
aide: Sous borland, veillez a bien laisser le #define BORLANDGUI
Créer l'objet CDebug en passant en parametre le pointeur
vers votre objet TMemo, puis faite :
MDEBUG("mon message !");

c'est une macro , et rien n'assure qu'elle sera soit ré implémentée ou modifiée ou existante dans toutes les versions de c++ Builder

La solution apportée par <maxim_um> est par contre parfaitement portable et convient mieux a ce genre d'exercice

cordialement