locked
Migration de Java vers C++ mode managed ou mode std RRS feed

  • Discussion générale

  • Bonjour,

    J'entreprends sur ce sujet de mettre en évidence les éléments clef quand on veut migrer du code de Java.

    J'ai du le faire car mon projet Java était atteint d'une incapacité à s’exécuter en un temps raisonnable sous Java.

    Je vais d'abord tenter un parallèle entre les types et les méthodes de Java, De C++ managed et de C++ std.

    Disons le tout de suite il est plus facile de convertir du code de Java en C++ managed que en C++ std.

    Mais dans certain cas il faut maintenir l'une partie du code en mode std:: et dans ce cas il ne faut jamais mentionner dans ce code la directive #pragma unmanaged

    d'abord les types

                                                 Java                             C++ std                              C++ managed

    les tableaux                      type(size)                       type(size)                         array<Type^, 1>^

                                                                                                                            Cette array est sensible aux includes

                                                                                                                            ci après l'exemple avec un mini projet

                                                                                                                            tous les includes sont documentées

    /*******************************************************************************
     * FILE NAME: AlignStructure.h
     * PURPOSE  : This file contains
     * HISTORY  :
     * Date        Version                   Author
     * 04/06/2003  Initial version :1.0      Rajani
    *******************************************************************************/
    #ifndef AlignStructureH
    #define AlignStructureH
    #pragma unmanaged
    //---------------------------- INCLUDE FILES -----------------------------------
    const int HUNDRED = 100;
    // Enumerated values for the return values required for all the modules.
    
    enum {ZERO,ONE};
    //enum { SUCCESS, FAILURE, EXCEPTION_FAILURE };
    
    //enum enDatabaseServer {DATABASE_TYPE};
    
    // Enumerated values for handling the Criteria values
    enum {SEGMENT_PERCENTAGE,
          CHUNK_PERCENTAGE,
          SERVER_NAME,
          SERVER_TYPE,
          DATABASE_FILE_NAME,
          MAINDATABASE_CHANGED,
          NO_OF_CRITERIA_ELEMENTS
         };
    
    // Enumerated values for handling the Parameter values
    enum {FOCUSED_CELL_BKGND_COLOUR,
          FOCUSED_CELL_TEXT_COLOUR,
          MANUAL_ALIGNED_ELEMENTS_COLOUR,
          EXCLUDED_ELEMENTS_COLOUR,
          RECENTLY_ALIGNED_ELEMENTS_COLOUR,
          FORMERLY_ALIGNED_ELEMENTS_COLOUR,
          NON_ALIGNED_ELEMENTS_COLOUR,
          MMI_LANGUAGE,
          NO_OF_PARAMETERS_ELEMENTS
         };
    //--------------------- Data for SoftwareManager module ------------------------
    enum {STRING_TYPE, INTEGER_TYPE, BOOL_TYPE};
    
    //------------------------------------------------------------------------------
    #endif

    il y a aussi Macro.h

    /*******************************************************************************
    * FILE NAME: Macro.h
    * PURPOSE:   This file contains the macros to be used across COM utility
    * HISTORY:
    * Date        Version                   Author
    * 03/06/2003  initial version :1.0      Shridhar
    *******************************************************************************/
    #ifndef MacroH
    #define MacroH
    //---------------------------------------------------------------------------
    //-------------------CONSTANTS AND USER DEFINED DATA TYPES----------------------
    //Constants to extract the respective numbers from return code
    //#define TYPE_MASK 0xC000000000000000
    #define MESSAGE_CODE_MASK 0x3FFFF80000000000
    #define MODULE_ID_MASK 0x000007FF80000000
    #define CLASS_ID_MASK  0x000000007FF80000
    #define FUNCTION_ID_MASK 0x000000000008FF80
    #define RETURN_FUNCTION_MASK 0x000000000000007F
    #define MESSAGE_TYPE_MASK 0x000003FFFFFFFFFF
    
    //Constants to move bits
    #define MOVE_FOR_FUNCTION_ID 7
    #define MOVE_FOR_CLASS_ID 19
    #define MOVE_FOR_MODULE_ID 31
    #define MOVE_FOR_MESSAGE_CODE 43
    #define MOVE_FOR_TYPE 62
    
    //Constant used to initialize error code
    #define INIT_NO_ERROR      0
    #define MAX_LINE_SIZE  255
    #define WORD_SIZE 40
    #define SUCCESS  0
    #define FAILURE  1
    #define FIRST_ELEMENT   0
    #define END_REQUEST   L"END"
    #define ALIGNER_DOCUMENT   L"'Document Pair'"
    #define OPTION_DB_DIRECTORY  L"DBDirectory"
    #define OPTION_SERVER_INFORMATION L"ServerInformation"
    #define LEMMA_TRANSLATION_NUMBER 100
    #define LEMMA_SIZE 256
    #define WORD_NUMBER_OF_A_BLOC 5000
    #define MAX_LINE_SIZE  255
    #define ALIGNINIFILE L"align.ini"
    #define hidDB unsigned long long
    #define erc hidDB 
    /*
    class CMacro
    {
    public:
       CMacro::CMarco();
       CMacro::~CMacro();
       void CMacro::ChangeMsgRc(enTYPE enType, int iMessageCode, erc *pdwReturnCode);
    };
    
    extern CMacro objCMacro;
    */
    #endif

    puis les énumérations

    /*******************************************************************************
    * FILE NAME: Enumerations.hpp
    * PURPOSE:   This file contains constants and user defined data for all the
    *            classes.
    * HISTORY:
    * Date        Version                   Author
    * 16/05/2003  initial version :1.0      jn Martin
    *******************************************************************************/
    #ifndef Enumerations_H
    #define Enumerations_H
    //--------------------------- INCLUDE-FILES ------------------------------------
    	enum enDocType
    	{
    		DOCTYPE_NONE,
    		DOCTYPE_WORD,					//	the document can be read with MS Word as a word document
    		DOCTYPE_HTML,					//	the document can be read with an HTML parser
    		DOCTYPE_XML,					//	the document can be read with an XML parser
    		NUMBER_OF_DOCTYPE,
    	};
    
    
    	enum enAlignerKernel{
    		ALN_KERNEL_UNDEFINED = 0,
    		ALN_KERNEL_CSOFTWARE_MANAGER_METHOD,
    		ALN_KERNEL_CALIGNER_METHOD,
    		NUMBER_OF_ALN_KERNEL_CLASS
    	};
    
    	//Liste of the existing modules that compose Memoria system
    	enum enModuleID
    	{
    		MODULE_ID_NULL = 0,
    		MODULE_ID_ALN_KERNEL,
    		MODULE_ID_DBMS_MANAGER,
    		MODULE_ID_MDB_MANAGER,
    		MODULE_ID_ALIGNMENT,
    		MODULE_ID_ANALYSER,
    		MODULE_ID_DOCUMENT_MANAGER,
    		MODULE_ID_HTML_READER,
    		MODULE_ID_NARA_MANAGER,
    		MODULE_ID_PARSER_MANAGER,
    		MODULE_ID_WORD_READER,
    		MODULE_ID_XELDA_MANAGER,
    		MODULE_ID_XML_READER,
    		MODULE_ID_EVENT_MANAGER,
    		MODULE_ID_INI_FILE_MANAGER,
    		MODULE_ID_OPTION_MANAGER,
    		MODULE_ID_REPORT_MANAGER,
    		MODULE_ID_TEXT_FILE_MANAGER,
    		MODULE_ID_STATISTIC_MANAGER,
    		NUMBER_OF_MODULE_ID
    	};
    
    	//Definition of the different type
    	enum enTYPE
    	{
    		TYPE_NULL = 0,	    	      //	The initialisation type
    		TYPE_INFO,	    	          //	The info type
    		TYPE_WARNING,	              //	The warning type
    		TYPE_ERROR,	    	          //	The error type
    		NUMBER_OF_TYPE                //    the number of type
    	};
    
    	enum enApplicationName
    	{
    		APPLICATIONNAME_NONE,
    		APPLICATIONNAME_SPECIFICATION_LOADER,
    		APPLICATIONNAME_ALIGNER,					//	the document can be read with MS Word as a word document
    		APPLICATIONNAME_MEMORIA_MANAGER,	//	the document can be read with an HTML parser
    		APPLICATIONNAME_TRANSLATION_TOOL,	//	the document can be read with an XML parser
    		NUMBER_OF_APPLICATIONNAME,
    	};
    //	ENUM enDatabaseServer				Type of database server
    	enum enDatabaseServer
    	{
    		DATABASESERVER_NONE,                                  //  Undefined Database server
    		DATABASESERVER_INTERBASE_6_0,                         //  Interbase server
    		NUMBER_OF_DATABASESERVER,
    	};
    
    //	ENUM enSERVER_STATUS		Status of the server
    	enum enSERVER_STATUS
    	{   //Status of the server
    		SERVER_NONE,                 //Undefined
    		SERVER_CONNECTED,            //Connected to this server
    		SERVER_DISCONNECTED,          //Not connected to this server
    	};
    //  ENUM enDATABASE_TYPE	Database type
    	enum enDATABASE_TYPE
    	{   //Database type
    		NONE,                 //Undefined
    		PROJECT_DATABASE,     //Project database type
    		MISSION_DATABASE,     //Mission database type
    		ON_LINE_DATABASE,      //On line database type
    	};
    
    //  ENUM enDATABASE_STATUS	Status of the database
    	enum enDATABASE_STATUS
    	{ //Status of the database
    		DATABASE_NONE,               //Undefined
    		DATABASE_CONNECTED,          //Connected to this database
    		DATABASE_DISCONNECTED,        //Not connected to this database
    	};
    
    	enum enParserManager
    	{
    		PARSER_UNDEFINED = 0,
    		PARSER_CPARSERMANAGER,
    		NUMBER_OF_PARSER_CLASS,
    	};
    
    	enum enLanguage
    	{
    		LANGUAGE_NONE,                                        //  Undefined language
    		LANGUAGE_FRENCH,                                      //  French
    		LANGUAGE_ENGLISH,                                     //  English
    		LANGUAGE_SPANISH,                                     //  Spanish
    		LANGUAGE_ITALIAN,                                     //  Italian
    		LANGUAGE_GERMAN,                                      //  German
    		NUMBER_OF_LANGUAGE
    	};
    
    	enum enStatusDocument
    	{
    		STATUS_DOC_NONE,
    		STATUS_DOC_SOURCE,
    		STATUS_DOC_TARGET,
    		NUMBER_OF_DOC_STATUS
    	};
    
    	enum enInArray
    	{
    		IN_ARRAY_NULL,          //  DOJ JUST for coding homogeneity
    		IN_ARRAY_TRUE,          //  the element is in Array
    		IN_ARRAY_FALSE,         //  the element is not in Array
    		NUMBER_OF_IN_ARRAY
    	};
    
    	enum enBold
    	{
    		BOLD_NULL,					//	the whole element is not in bold, it is not homogeneous
    		BOLD_TRUE,					//	the element is in bold
    		BOLD_FALSE,					//	the element is not in bold
    		NUMBER_OF_BOLD
    	};
    
    	enum enItalic
    	{
    		ITALIC_NULL,				//	the whole element is not in Italic, it is not homogeneous
    		ITALIC_TRUE,				//	the element is in Italic
    		ITALIC_FALSE,				//	the element is not in Italic
    		NUMBER_OF_ITALIC
    	};
    
    	enum enUnderline
    	{
    		UNDERLINE_NULL,			//	the whole element is not in Underline, it is not homogeneous
    		UNDERLINE_TRUE,			//	the element is in Underline
    		UNDERLINE_FALSE,		//	the element is not in Underline
    		NUMBER_OF_UNDERLINE
    	};
    
    	enum enUppercase
    	{
    		UPPERCASE_NULL,			//	the whole element is not in Uppercase, it is not homogeneous
    		UPPERCASE_TRUE,			//	the element is in Uppercase
    		UPPERCASE_FALSE,		//	the element is not in Uppercase
    		NUMBER_OF_UPPERCASE
    	};
    
    	enum enColor
    	{
    		COLOR_NONE,
    		COLOR_BLACK,
    		COLOR_RED,
    		COLOR_ORANGE,
    		COLOR_YELLOW,
    		COLOR_GREEN,
    		COLOR_BLUE,
    		COLOR_VIOLET,
    		COLOR_WHIGHT,
    		NUMBER_OF_COLOR,
    	};
    
    	enum enGender
    	{
    		GENDER_NONE,
    		GENDER_MASCULINE,
    		GENDER_FEMININE,
    		GENDER_NEUTER,
    		NUMBER_OF_GENDER,
    	};
    
    	enum enFlexNumber
    	{
    		NUMBER_NONE,
    		FLEX_SING,
    		FLEX_PLUR,
    		NUMBER_OF_NUMBER,
    	};
    
    	enum enPers
    	{
    		PERS_NONE,
    		PERS_1,
    		PERS_2,
    		PERS_3,
    		NUMBER_OF_PERS,
    	};
    
    	enum enNbr
    	{
    		NBR_NONE,
    		NBR_SING,
    		NBR_PLUR,
    	};
    
    	enum enPOS
    	{
    		POS_NONE,								//	Undefined                   0
    		POS_PREP,								//	Preposition                 1
    		POS_ART,								//	Article                     2
    		POS_ADJ,								//	Adjective                   3
    		POS_NOUN,								//	Noun                        4
    		POS_NB,									//	Number                      5
    		POS_MARK,								//	Mark                        6
    		POS_SENT,								//	Sentence point              7
    		POS_STOPMARK,							//	Mark of end of sentence     8
    		POS_COMMA,								//	virgule                     9
    		POS_CONJ,								//	Conjunction                 10
    		POS_PRONOUN,							//	Pronoun                     11
    		POS_VERB,								//	Verb                        12
    		POS_AUX,								//	Auxiliary                   13
    		POS_ADV,								//	Adverb                      14
    		POS_PAST_PARTICIPLE,	                //	Participe passé             15
    		POS_PRESENT_PARTICIPLE,                 //  Participe présent           16
    		POS_BLANK,								//	Blank                       17
    		POS_ABREV,								//  Abreviations                18
    		POS_NAMED_ENTITY,						//  Noms propre et Entitée nomée19
    		POS_DECLENCHEUR,						//  mots servant à repèrer les préconditions 20
    		POS_DECLENCHEUR_MOT,					//  noms déclanchant            21
    		POS_PIVOT,								//  mot continuant un syntagme  22
    		POS_SEMI_COLUMN,						//  deux points                 23
    		POS_PASSIVE,							//  mot introduisnat une forme passive 24
    		POS_COLOR,								//  couleurs normalisées        25
    		POS_OTHER,								//	Other POS                   26
    		NUMBER_OF_POS,
    	};
    
    	enum enChunkType
    	{
    		CHUNKTYPE_NONE,                                       // 0 Undefined chunk type
    		CHUNKTYPE_VERB,                                       // 1
    		CHUNKTYPE_NOUN,                                       // 2
    		CHUNKTYPE_FUNCT,                                      // 3
    		CHUNKTYPE_DECLENCHEUR,                                // 4
    		CHUNKTYPE_QUALIFICATEUR,                              // 5
    		CHUNKTYPE_PASSIVE,                                    // 6
    		CHUNKTYPE_OTHER,                                      // 7
    		NUMBER_OF_CHUNKTYPE                                   // 8
    	};
    
    	enum enFonction
    	{
    		FONCTION_NONE,     //0
    		FONCTION_SUJET,
    		FONCTION_PREDICAT,
    		FONCTION_OBJET,
    		FONCTION_VERB,
    		FONCTION_PIVOT,     //5
    		FONCTION_CONJ,
    		FONCTION_SUBSTANTIF,
    		FONCTION_DECLENCHEUR,
    		FONCTION_IDENTIFIANT,
    		FONCTION_FUNCT,     //10
    		FONCTION_ART,
    		FONCTION_NOUN,
    		FONCTION_QUALIFICATEUR,
    		FONCTION_PASSIVE,
    		FONCTION_TITLE,
    		FONCTION_UNKNOWN,
    		NUMBER_OF_FUNCTIONS
    	};
    	
    	enum enElementSemantique
    	{
    		ELEMENT_NONE,								 //0
    		ELEMENT_PREDICAT,                            //1
    		ELEMENT_PREDICAT_QUALIFIANT,                 //2
    		ELEMENT_PRECONDITION,                        //3
    		ELEMENT_QUALIFICATEUR,                       //4
    		ELEMENT_COMMENTAIRE,                         //5
    		ELEMENT_TITLE,                               //6
    		ELEMENT_OTHER,                               //7
    		NUMBER_OF_ELEMENT
    	};
    
    	enum enStatus
    	{
    		STATUS_NONE,                                          //  weak words   0
    		STATUS_NORMAL,                                        //  NormalWords  1
    		STATUS_BIS,                                           //  doubleWords  2
    		STATUS_NB,                                            //               3
    		STATUS_PROPER,                                        //  ProperNoun   4
    		STATUS_NOT_DEFINED2,                                  //               5
    		STATUS_REGULAR,                                       //  The lemma is an identifier  6
    		STATUS_UNDEFINED,
    		STATUS_NEGATIVE,                                      //  The word  holds a negative form  8
    		STATUS_EXCLUDED,
    		STATUS_NOT_ALIGNED,
    		STATUS_MAN_ALIGNED,
    		STATUS_AUTO_ALIGNED,
    		STATUS_FORMER_ALIGNED,
    		NUMBER_OF_STATUS
    	};
    
    	enum enAnalyse
    	{
    		UNDEFINED = 0,
    		ANALYSE_CSEGMENTATION,
    		ANALYSE_CCHUNKER,
    		ANALYSE_CCOMPUTING_FOR_ALIGNMENT,
    		ANALYSE_CNGRAMER,
    		ANALYSE_CSCHEDULER_GLOBAL,
    		ANALYSE_CSCHEDULER_SINGLE,
    		ANALYSE_CANNEX_FUNCTIONS,
    	};
    
    	enum enClueType
    	{
    		CLUETYPE_NONE,                                        //  Undefined clue type
    		CLUETYPE_INTERNAL,                                    //  Identifier of Internal clue type
    		CLUETYPE_EXTERNAL,                                    //  Identifier of External clue type
    		CLUETYPE_NGRAM,                                       //  Identifier of Ngram clue type
    		CLUETYPE_NUMBER,                                      //  Identifier of Number clue type
    		NUMBER_OF_CLUETYPE
    	};
    
    #endif

    et les types du MiniBloc

    /*******************************************************************************
    * FILE NAME: MiniBloc.hpp
    * PURPOSE:   This file contains constants and user defined data for the
    *            classes that interface Word.
    * HISTORY:
    * Date        Version                   Author
    * 16/05/2003  initial version :1.0      jn Martin
    *******************************************************************************/
    #ifndef MINI_BLOC_H
    #define MINI_BLOC_H
    #pragma unmanaged
    //------------------------------------------------------------------------------
    
    //--------------------------- INCLUDE-FILES ------------------------------------
    
    //--------------------------- CLASS-DEFINITION ---------------------------------
    
    	class CLayout
    	{
    	public:
    		bool              bTitle;
    		CLayout::CLayout();
    		CLayout::~CLayout();
    	};
    
    	class CElement
    	{
    	public:
    		std::wstring wsElementText;
    		CLayout* pLayout;
    		CElement()
    		{
    			;
    		}
    		~CElement()
    		{
    			;
    		}
    	};
    
    
    	class CBloc
    	{
    	public:
    		std::wstring wsBlocText;
    		CLayout* pLayoutBloc;
    		std::list<CElement*>* plistElement;
    		CBloc::CBloc()
    		{
    			;
    		}
    		CBloc::~CBloc()
    		{
    			;
    		}
    	};
    
    
    #endif
    Ces includes sont décisifs pour l'aceptation pr le compilatuer du type array
    #pragma managed 
    // SpecificationLoader.cpp : fichier projet principal.
    
    #include "StdAfx.h"
    #include "AlignStructure.h"
    #include "Macro.h"
    #include "Enumerations.hpp"
    //#include "Structure.h"
    #include "MiniBloc.hpp"
    #include "Manager.h"
    #include "WordManager.h"
    #include "MainMenue.h"
    
    namespace SpecificationLoader
    {
        using namespace System;
    	using namespace System::ComponentModel;
    	using namespace System::Collections;
    	using namespace System::Windows::Forms;
    	using namespace System::Data;
    	using namespace System::Drawing;
    	using namespace System::IO;
    	using namespace System::Runtime::InteropServices;
    	using namespace msclr::interop;
    
    	[STAThreadAttribute]
    	int main( array<System::String^, 1>^ args)
    	{
    		// Activation des effets visuels de Windows XP avant la création de tout contrôle
    		Application::SetCompatibleTextRenderingDefault(false);
    		CSoftwareManager::Initialization( true);
    		// Créer la fenêtre principale et l'exécuter
    		Application::EnableVisualStyles();
    		Application::Run(gcnew SpecificationLoader::MainMenue());
    		return 0;
    	};
    };


    les listes                          List<Type>                   std::list<Type>                    List<Type>^ pListe      ci dessous le lien

    les chaines unicode            String                         std::wstring                            System::String^          ci dessous le lien

    ensuite les méthodes

    mettre en liste                   add                             push_back                                      Add                 ci-dessous le lien

                                                                                push_front

    parcourir une liste   List<Type>::iterator it  std::list<Type>::iterator it      for each( Element in pListe)  ci-dessous le lien

                                   List<Type> pTerme;      std::list<Type>* pTerme      List<Terme>::Enumerator it ci-dessous le lien

                                    it = pTerme.begin()         it = pTerme->Begin()

                                while( it =! pTerme.end()) while( it != pTerme->end())

                                        pTerme = it;                     pTerme = *it                                 Reverse()           ci-dessous le lien

    traitement des chaines     find                                find                                            IndexOf             ci-dessous le lien

                                            split                              strtok                                             Split

                                             size                              size                                               Count              ci-dessous le lien

                                                                                                                                    ToLower

                                                                                                                                    ToUpper

                                                                                                                                     

    Ce document est mis à jour à temps perdu. C'est un retour d'investissement pour ceux qui m'ont aidé


    Jean Noël Martin

























    • Modifié JeanNoel53 lundi 16 décembre 2013 11:07
    vendredi 15 novembre 2013 12:07

Toutes les réponses

  • Bonjour

    Je ne peux pas arrêter de me demander pour quels raisons vous avez décidé de convertir le projet Java dans un mix C++ manage et non manage.

    La conversion je la comprends. C’était trop lent. Ce que je ne comprends pas c’est pourquoi mélanger code C++ managée avec non managée.

    C# par exemple c’est beaucoup plus proche de Java que c++.  En plus le développement c’est beaucoup plus rapide avec C#. 

    En plus pourquoi mélanger le code? De point de vue vitesse d’exécution je dirais que le code manage et non managée sont comparables. On gagne la vitesse avec le code non managée mais pour des réservations /libération de mémoire le code managée c’est plus rapide. Comme vitesse de exécution C++ managée c’est pareil avec C#, mais le développement c’est beaucoup plus difficile avec C++.

    Si je me rappelle bien vous utilisez les outils d’interopérabilité pour Office. Ils sont utiles pour exécuter du code non managée dans du code managée.  Mais j’ai l’impression de que vous faites le passage non managée – managée plusieurs fois.

    Je pose ces questions/explications pour ceux qui vont démarrer ce type de traitements. 

    Cordialement,


    Aurel BERA, MSFT
    MSDN Community Support. LE CONTENU EST FOURNI "TEL QUEL" SANS GARANTIE D'AUCUNE SORTE, EXPLICITE OU IMPLICITE.
    S'il vous plaît n'oubliez pas de "Marquer comme réponse" les réponses qui ont résolu votre problème. C'est une voie commune pour reconnaître ceux qui vous ont aidé, et rend plus facile pour les autres visiteurs de trouver plus tard la résolution.

    lundi 18 novembre 2013 11:48
  • J'ai deux phases dans mon projet: La première phase repose sur du code de bcb que j'ai intégrer en tant que code std. L'interface se résume à un appel de méthode dans WordManager.

    La deuxième phase provient de code Java parce que ce code alourdissait trop le code de Java et que je voulais bénéficier des facultés de C++ de compiler du code pour l'exécuter plus rapidement. Dans ma migration, j'ai commis une erreur qui était de passer par la phase std::. Je m'en suis rendu compte suite à des problèmes d'allocation de mémoire qui se passaient sur l'initialisation de basic_string.

    C'est pour cela que je suis passé pour cette deuxième phase par du code managé


    Jean Noël Martin


    • Modifié JeanNoel53 lundi 18 novembre 2013 15:15
    lundi 18 novembre 2013 15:14
  • Il faudra ajouter à ce thread des exemples au fur et à mesure que les solutions auront été validées

    Jean Noël Martin

    mercredi 20 novembre 2013 15:21