none
une de plus erreur de compilation RRS feed

  • Question

  • dans ma migration vers le code managé j'ai ces autres erreurs:

    1>..\..\..\..\Common\src\Database.cpp(92): error C2653: 'CDatabase' : n'est pas un nom de classe ni d'espace de noms
    1>..\..\..\..\Common\src\Database.cpp(93): error C4430: spécificateur de type manquant - int est pris en compte par défaut. Remarque : C++ ne prend pas en charge int par défaut
    1>..\..\..\..\Common\src\Database.cpp(94): error C2065: 'm_wsDBName' : identificateur non déclaré
    1>..\..\..\..\Common\src\Database.cpp(95): error C2065: 'm_wsLogin' : identificateur non déclaré
    1>..\..\..\..\Common\src\Database.cpp(96): error C2065: 'm_wsPassword' : identificateur non déclaré

    je vous met la déclaration de la classe :

    	public ref class CDatabase
    	{
    	public:
    		System::String^         m_wsSrvName;       //Name of the server.
    		System::String^         m_wsSrvLogin;      //Login of the user
    		System::String^         m_wsSrvPassword;   //Password string of the user
    		System::String^         m_wsName;          //Name of the server.
    		System::String^         m_wsDBName;
    		System::String^         m_wsLogin;         //Login of the user
    		System::String^         m_wsPassword;      //Password string of the user
    		System::String^         m_wsHost;
    		System::String^         m_wsUserName;
    		System::String^         m_wsDescription;   //Description text (free field)
    		CDatabase::CDatabase();
    		CDatabase::~CDatabase();
    		static System::String^ CDatabase::SetDBName( System::String^ wsDBName);
    		static void CDatabase::SetLogin( System::String^ wsLogin);
    		static void CDatabase::SetPassword( System::String^ wsPassword);
    		static void CDatabase::SetType(enDATABASE_TYPE enType);
    		static void SetStatus(enDATABASE_STATUS enStatus);
    		System::String^ CDatabase::GetDBName();
    		System::String^ CDatabase::GetLogin();
    		System::String^ CDatabase::GetPassword();
    		enDATABASE_TYPE CDatabase::GetType();
    		enDATABASE_STATUS CDatabase::GetStatus();
    	};


    Jean Noël Martin

    dimanche 12 juillet 2015 07:45

Réponses

  • 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;
    
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    /*Class         CDatabase                                                                                               */
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    /*Name          CDatabase                                                                                                         */
    /*Role          Class constructor with the type as first parameter                                                                */
    /*Interface                                                                                                                       */
    /*In            enType		Type of database define in the enum enDATABASE_TYPE                                                     */
    /*In/Out        None                                                                                                              */
    /*Result        None                                                                                                              */
    /*Constraints   None                                                                                                              */
    /*Resources     None                                                                                                              */
    /*PreCondition  None                                                                                                              */
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    //PROC CDatabase(In: enType (enDATABASE_TYPE))
    //DATA
    //ATAD
    //DO
    //  m_wsDBName			:= [Empty wide string]
    //  m_wsLogin		    := [Empty wide string]
    //  m_wsPassword    := [Empty wide string]
    //  m_enType			  := enType
    //  m_enStatus			:= DATABASE_DISCONNECTED
    //OD
    CDatabase::CDatabase()
    {
    	CDatabase::m_wsDBName = L"";
    	CDatabase::m_wsLogin = L"";
    	CDatabase::m_wsPassword = L"";
    	CDatabase::m_enType = (enDATABASE_TYPE) 1;
    	CDatabase::m_enStatus = enDATABASE_STATUS::DATABASE_DISCONNECTED;
    }
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    /*Name          ~CDatabase                                                                                             */
    /*Role          Class destructor                                                                                                  */
    /*Interface                                                                                                                       */
    /*In            None                                                                                                              */
    /*In/Out        None                                                                                                              */
    /*Result        None                                                                                                              */
    /*Constraints   None                                                                                                              */
    /*Resources     None                                                                                                              */
    /*PreCondition  None                                                                                                              */
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    //PROC ~CDatabase()
    //DATA
    //ATAD
    //DO
    //OD
    CDatabase::~CDatabase()
    {
    }
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    /*Name          Set<private member variable>                                                                                      */
    /*Role          Set the private member variable to the given value                                                                */
    /*Interface                                                                                                                       */
    /*In            <setting value>                                                                                                   */
    /*In/Out        None                                                                                                              */
    /*Result        None                                                                                                              */
    /*Constraints   None                                                                                                              */
    /*Resources     None                                                                                                              */
    /*PreCondition  CDatabase object must exist                                                                            */
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    //PROC Set<private member variable>(In : <setting value> (same type as the private member variable))
    //DATA
    //ATAD
    //DO
    //  m_<private member variable> := <setting value>
    //OD
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    System::String^ CDatabase::SetDBName( System::String^ wsDBName)
    {
      System::String^ ReturnDBName;
      wchar_t Temp[12]={0,0,0,0,0,0,0,0,0,0,0,0};
      wchar_t* wTemp = &Temp[0];
    
      // size_type _Copy_s( value_type *_Dest, size_type _Dest_size, size_type _Count, size_type _Off = 0) const;
      // size_type copy( value_type* _Ptr, size_type _Count, size_type _Off = 0) const;
      ReturnDBName = L"D:" + L"\\" + wsDBName;
      return( ReturnDBName);
    }
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    void CDatabase::SetLogin( System::String^ wsLogin)
    {
      CDatabase::m_wsLogin = wsLogin;
    }
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    void CDatabase::SetPassword( System::String^ wsPassword)
    {
      CDatabase::m_wsPassword = wsPassword;
    }
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    void CDatabase::SetType(enDATABASE_TYPE enType)
    {
      CDatabase::m_enType = enType;
    }
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    void CDatabase::SetStatus(enDATABASE_STATUS enStatus)
    {
      CDatabase::m_enStatus = enStatus;
    }
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    /*Name          Get<private member variable>                                                                                      */
    /*Role          Get the value of the private member variable                                                                      */
    /*Interface                                                                                                                       */
    /*In            None                                                                                                              */
    /*In/Out        None                                                                                                              */
    /*Result        value of the private member variable                                                                              */
    /*Constraints   None                                                                                                              */
    /*Resources     None                                                                                                              */
    /*PreCondition  CDatabase object must exist                                                                            */
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    //PROC Get<private member variable>(Result : <value of the private member variable> (same type as the private member variable))
    //DATA
    //ATAD
    //DO
    //  <value of the private member variable> := m_<private member variable>
    //OD
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    System::String^ CDatabase::GetDBName()
    {
      return( CDatabase::m_wsDBName);
    }
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    System::String^ CDatabase::GetLogin()
    {
      return( CDatabase::m_wsLogin);
    }
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    System::String^ CDatabase::GetPassword()
    {
      return( CDatabase::m_wsPassword);
    }
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    enDATABASE_TYPE CDatabase::GetType()
    {
      return( CDatabase::m_enType);
    }
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    enDATABASE_STATUS CDatabase::GetStatus()
    {
      return( CDatabase::m_enStatus);
    }
    };
    
    /*_____LOCAL-FUNCTIONS________________________________________________________*/
    


    Jean Noël Martin

    • Marqué comme réponse JeanNoel53 vendredi 17 juillet 2015 08:20
    vendredi 17 juillet 2015 08:20

Toutes les réponses

  • Bonjour, Jean Noël,

    Ref est un mot clé du code managé. Compilez-vous votre code en natif ou en C++/CLI ?

    Cordialement,
    Dimitar

    lundi 13 juillet 2015 07:42
    Modérateur

  • Jean Noël Martin

    lundi 13 juillet 2015 10:40
  • Ligne 92 de "Database.cpp", y a quoi avant ?

    Pourquoi déclarer la classe dans un cpp et pas dans .h ???


    Paul Bacelar, Ex - MVP VC++


    lundi 13 juillet 2015 18:00
    Modérateur
  • /*--------------------------------------------------------------------------------------------------------------------------------*/
    /* Global conception    : 06-12-2003 ; 13:36:57                                                                                   */
    /* Specification        : 05-12-2003 ; 14:54:40                                                                                   */
    /* ALITEC                                                                                                                         */
    /* Rue Leonard de vinci                                                                                                           */
    /* 53061 LAVAL CEDEX 09                                                                                                           */
    /* (c) Copyright ALITEC                                                                                                           */
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    /*******************************************************************************
     * NOM:
     * ROLE:
     * HISTORIQUE:
        * 05/05/2001, xxx, initial version
    *******************************************************************************/
    #pragma hdrstop
    /*_____INCLUDE-FILES__________________________________________________________*/
    #include "StdAfx.h"
    #include "AlignStructure.h"
    #include "Macro.h"
    #include "Message.h"
    #include "EnumerationM.hpp"
    #include "StructureM.h"
    #include "TypeDefsM.hpp"
    #include "POSM.h"
    #include "ClasseAlignerManaged.hpp"
    #include "Language.h"
    #include "StrConv.h"
    #include "Database.h"
    #include "Server.h"
    /*_____LOCAL-DEFINE___________________________________________________________*/
    /*_____LOCAL-TYPES____________________________________________________________*/
    /*_____GLOBAL-DATA____________________________________________________________*/
    
    //extern SpecificationLoader::CInterbaseManager objInterbaseManager;
    
    enDatabaseServerM m_enSrvType;
    enSERVER_STATUS m_enSrvStatus;
    enDATABASE_TYPE m_enType;
    enDATABASE_STATUS  m_enStatus;
    
    /*_____LOCAL-DATA_____________________________________________________________*/
    /*_____LOCAL-MACROS___________________________________________________________*/
    
    /*_____LOCAL-FUNCTIONS-PROTOTYPES_____________________________________________*/
    /*_____GLOBAL-FUNCTIONS_______________________________________________________*/
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    /*Class         CServer                                                                                                            */
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    /*Name          CServer                                                                                        */
    /*Role          Class constructor                                                                                                 */
    /*Interface                                                                                                                       */
    /*In            None                                                                                                              */
    /*In/Out        None                                                                                                              */
    /*Result        None                                                                                                              */
    /*Constraints   None                                                                                                              */
    /*Resources     None                                                                                                              */
    /*PreCondition  None                                                                                                              */
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    namespace SpecificationChecker
    {
        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;
    
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    /*Class         CDatabase                                                                                               */
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    /*Name          CDatabase                                                                                                         */
    /*Role          Class constructor with the type as first parameter                                                                */
    /*Interface                                                                                                                       */
    /*In            enType		Type of database define in the enum enDATABASE_TYPE                                                     */
    /*In/Out        None                                                                                                              */
    /*Result        None                                                                                                              */
    /*Constraints   None                                                                                                              */
    /*Resources     None                                                                                                              */
    /*PreCondition  None                                                                                                              */
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    //PROC CDatabase(In: enType (enDATABASE_TYPE))
    //DATA
    //ATAD
    //DO
    //  m_wsDBName			:= [Empty wide string]
    //  m_wsLogin		    := [Empty wide string]
    //  m_wsPassword    := [Empty wide string]
    //  m_enType			  := enType
    //  m_enStatus			:= DATABASE_DISCONNECTED
    //OD
    CDatabase::CDatabase()
    {
      CDatabase::m_wsDBName = L"";
      CDatabase::m_wsLogin = L"";
      CDatabase::m_wsPassword = L"";
      CDatabase::m_enType = (enDATABASE_TYPE) 1;
      CDatabase::m_enStatus = enDATABASE_STATUS::DATABASE_DISCONNECTED;
    }
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    /*Name          ~CDatabase                                                                                             */
    /*Role          Class destructor                                                                                                  */
    /*Interface                                                                                                                       */
    /*In            None                                                                                                              */
    /*In/Out        None                                                                                                              */
    /*Result        None                                                                                                              */
    /*Constraints   None                                                                                                              */
    /*Resources     None                                                                                                              */
    /*PreCondition  None                                                                                                              */
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    //PROC ~CDatabase()
    //DATA
    //ATAD
    //DO
    //OD
    CDatabase::~CDatabase()
    {
    }
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    /*Name          Set<private member variable>                                                                                      */
    /*Role          Set the private member variable to the given value                                                                */
    /*Interface                                                                                                                       */
    /*In            <setting value>                                                                                                   */
    /*In/Out        None                                                                                                              */
    /*Result        None                                                                                                              */
    /*Constraints   None                                                                                                              */
    /*Resources     None                                                                                                              */
    /*PreCondition  CDatabase object must exist                                                                            */
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    //PROC Set<private member variable>(In : <setting value> (same type as the private member variable))
    //DATA
    //ATAD
    //DO
    //  m_<private member variable> := <setting value>
    //OD
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    System::String^ CDatabase::SetDBName( System::String^ wsDBName)
    {
      System::String^ ReturnDBName;
      wchar_t Temp[12]={0,0,0,0,0,0,0,0,0,0,0,0};
      wchar_t* wTemp =&Temp[0];
      size_t len;
      System::String^ wsTemp;
      System::String^ wsName;
    
      // size_type _Copy_s( value_type *_Dest, size_type _Dest_size, size_type _Count, size_type _Off = 0) const;
      // size_type copy( value_type* _Ptr, size_type _Count, size_type _Off = 0) const;
      ReturnDBName.assign( L"D:" + L"\\" + CDatabase::wsDBName);
      return( ReturnDBName);
    }
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    void CDatabase::SetLogin( System::String^ wsLogin)
    {
      CDatabase::m_wsLogin = wsLogin;
    }
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    void CDatabase::SetPassword( System:String^ wsPassword)
    {
      CDatabase::m_wsPassword = wsPassword;
    }
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    void CDatabase::SetType(enDATABASE_TYPE enType)
    {
      CDatabase::m_enType = enType;
    }
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    void CDatabase::SetStatus(enDATABASE_STATUS enStatus)
    {
      CDatabase::m_enStatus = enStatus;
    }
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    /*Name          Get<private member variable>                                                                                      */
    /*Role          Get the value of the private member variable                                                                      */
    /*Interface                                                                                                                       */
    /*In            None                                                                                                              */
    /*In/Out        None                                                                                                              */
    /*Result        value of the private member variable                                                                              */
    /*Constraints   None                                                                                                              */
    /*Resources     None                                                                                                              */
    /*PreCondition  CDatabase object must exist                                                                            */
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    //PROC Get<private member variable>(Result : <value of the private member variable> (same type as the private member variable))
    //DATA
    //ATAD
    //DO
    //  <value of the private member variable> := m_<private member variable>
    //OD
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    System::String^ CDatabase::GetDBName()
    {
      return( CDatabase::m_wsDBName);
    }
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    System::String^ CDatabase::GetLogin()
    {
      return( CDatabase::m_wsLogin);
    }
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    System::String^ CDatabase::GetPassword()
    {
      return( CDatabase::m_wsPassword);
    }
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    enDATABASE_TYPE CDatabase::GetType()
    {
      return( CDatabase::m_enType);
    }
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    enDATABASE_STATUS CDatabase::GetStatus()
    {
      return( CDatabase::m_enStatus);
    }
    };
    
    /*_____LOCAL-FUNCTIONS________________________________________________________*/
    


    Jean Noël Martin

    lundi 13 juillet 2015 23:48
  • La classe "CDatabase" est sensée être déclarée dans quel .h que CDatabase.cpp inclus ?

    Si c'est "Database.h" alors il nous faut le fichier complet, car il y a utilisation d'un namespace dans le cpp, il faut qu'il soit le même dans le .h.


    Paul Bacelar, Ex - MVP VC++

    mercredi 15 juillet 2015 00:46
    Modérateur
  • le code de Database fichier include et fichier de code :

    d'abboird l'include

    /*******************************************************************************
     * NOM: Database.h
     * ROLE:
     * HISTORIQUE:
        * 05/05/2001, xxx, initial version
    *******************************************************************************/
    #ifndef DATABASE_H
    #define DATABASE_H
    /*_____INCLUDE-FILES__________________________________________________________*/
    /*_____GLOBAL-DEFINE__________________________________________________________*/
    
    typedef unsigned short sidDB;
    
    // Database limits
    #define MAX_JOIN            40 // Nombre maximum de jointure (correction FA 37)
    
    // Key word for request
    #define SELECT              L"SELECT "
    #define DELETEFROM          L"DELETE FROM "
    #define STAR                L"*"
    #define INSERT              L"INSERT INTO "
    #define VALUES              L" VALUES"
    #define UPDATE              L"UPDATE "
    #define SET                 L" SET "
    #define FROM                L" FROM "
    #define WHERE               L" WHERE "
    #define DANS                L" IN "
    #define ORDERBY             L" ORDER BY "
    #define AND                 L" AND "
    #define OR                  L" OR "
    #define PB                  L"("
    #define PE                  L")"
    #define CO                  L","
    #define QM                  L"'"
    #define Q2M                 L"\""
    #define EQ                  L" = "
    #define DOT                 L"."
    #define COUNTSTAR           L"COUNT(*)"
    #define COUNT_PB_DIST       L"COUNT (DISTINCT "
    #define SUM_PB              L"SUM("
    #define ISNULL              L" IS NULL"
    #define NULLVALUE           L"NULL"
    #define NULLVAL             L"null"
    #define BLANK               L" "
    #define ASRESULT            L" as LM_Result"
    
    #define DIFFERENT           L" <> "
    #define GREATER             L" > "
    #define LOWER               L" < "
    #define GREATER_EQ          L" >= "
    #define LOWER_EQ            L" <= "
    
    #define INC1                L" + 1"
    
    #define ZEROVALUE           0
    
    // Lemma status
    #define LEM_ST_NOT_EXCLUDED 0
    #define LEM_ST_EXCLUDED     1
    
    // Word  and NGram occurence
    #define FIRST_OCCURRENCE    1
    #define FIST_OCCURRENCE    L"1"
    
    // Segment alignment status
    #define SEG_AL_ST_UNDEF     0
    #define SEG_AL_ST_EXCLUDED  1
    #define SEG_AL_ST_NOALIGNED 2
    #define SEG_AL_ST_ALIGNED   3
    #define SEG_ST_NOALIGNED L"2"
    // Chunk alignment status
    #define CHK_AL_ST_UNDEF     0
    #define CHK_AL_ST_EXCLUDED  1
    #define CHK_AL_ST_NOALIGNED 2
    #define CHK_AL_ST_ALIGNED   3
    #define CHK_AL_NOALIGNED L"2"
    // Segment link alignment status
    #define SEG_LNK_AL_ST_UNDEF 0
    #define SEG_LNK_AL_ST_MANU  1
    #define SEG_LNK_AL_ST_AUTO  2
    
    // Chunk link alignment status
    #define CHK_LNK_AL_ST_UNDEF 0
    #define CHK_LNK_AL_ST_MANU  1
    #define CHK_LNK_AL_ST_AUTO  2
    
    // General Values For AlignmentStatus
    #define AL_ST_UNDEF      0
    #define AL_ST_EXCLUDED   1
    #define AL_ST_NOALIGNED  2
    #define AL_ST_MANU       3
    #define AL_ST_AUTO       4
    #define AL_ST_FORMER     5
    
    
    // Group values
    #define GRP_FALSE 0
    #define GRP_TRUE  1
    
    // Key word for table names
    #define WI_TABLE            L"T_WORK_INFORMATION"
    #define SC_TABLE            L"T_SEG_CHUNK"
    #define SW_TABLE            L"T_SEG_WORD"
    #define WORD_TABLE          L"T_WORD"
    #define LEM_TABLE           L"T_LEMMA"
    #define ELEMENT_CHK         L"T_ELEMENT_CHK"
    #define ELEMENT_LNK_TABLE   L"T_ELEMENT_LINKS"
    #define ELEMENT_TABLE       L"T_ELEMENT_SEMANTIQUE"
    #define SEG_TABLE           L"T_SEGMENT"
    #define CLUES_TABLE         L"T_CLUES"
    #define LAYOUT_TABLE        L"T_LAYOUT"
    #define CHK_TABLE           L"T_CHUNK"
    #define CT_TABLE            L"T_CHUNK_TYPE"
    #define CW_TABLE            L"T_CHUNK_WORD"
    #define PARA_TABLE          L"T_PARAGRAPH"
    
    // Key word for attributes of table CLUES
    #define CLUES_ID_CLUES      L"nuIdClues"
    #define CLUES_EXT_SCORES    L"siExternalScore"
    #define CLUES_INT_SCORES    L"siInternalScore"
    #define CLUES_NB_NGRAM      L"siNbNgram"
    #define CLUES_NB_NUMBER     L"siNbNumber"
    
    // Key word for attributes of table LAYOUT
    #define LAYOUT_ID_LAYOUT      L"nuIdLayout"
    #define LAYOUT_IN_ARRAY       L"cInArray"
    #define LAYOUT_ID_STYLE_NAME  L"siIdStyleName"
    #define LAYOUT_ID_FONT_NAME   L"siIdFontName"
    #define LAYOUT_FONT_SIZE      L"siFontSize"
    #define LAYOUT_BOLD           L"cBold"
    #define LAYOUT_ITALIC         L"cItalic"
    #define LAYOUT_UNDERLINE      L"cUnderline"
    #define LAYOUT_UPPERCASE      L"cUpperCase"
    #define LAYOUT_FG_COLOR       L"iFGColor"
    #define LAYOUT_BG_COLOR       L"iBGColor"
    
    // Key word for attributes of table STYLE_NAME
    #define STYLE_N_ID_STYLE_NAME L"siIdStyleName"
    #define STYLE_N_LABEL          L"vcLabel"
    
    // Key word for attributes of table FONT_NAME
    #define FONT_N_ID_FONT_NAME   L"siIdFontName"
    #define FONT_N_LABEL          L"vcLabel"
    
    // Key word for attributes of table SEGMENT
    #define SEG_ID_SEG          L"nuIdSeg"
    #define SEG_TYPE            L"cType"
    #define SEG_ALIGN_STATUS    L"cAlignStatus"
    #define SEG_NOT_RECOMPOSED  L"cNotRecomposed"
    #define SEG_COVERAGE        L"siCoverage"
    #define SEG_INIT_POS        L"iInitPos"
    #define SEG_SIZE_IN_CHAR    L"siSizeInChar"
    #define SEG_SIZE_IN_WORDS   L"siSizeInWords"
    #define SEG_ID_PREV         L"nuIdPrev"
    #define SEG_ID_NEXT         L"nuIdNext"
    #define SEG_ID_LAYOUT       L"nuIdLayout"
    #define SEG_ID_CLUES        L"nuIdClues"
    #define SEG_ID_DOC          L"siIdDoc"
    #define SEG_TYPE_DOC        L"siIdTypD"
    #define SEG_ID_LANG         L"siIdLang"
    
    // Key word for attributes of table SEGMENT_WORD
    #define SW_ID_SEG_WORD      L"nuIdSegWord"
    #define SW_ID_SEG           L"nuIdSeg"
    #define SW_ID_WORD          L"nuIdWord"
    #define SW_WORD_RANK        L"siWordRank"
    #define SW_CHUNK_NUM        L"siChunkNum"
    #define SW_ID_LAYOUT        L"nuIdLayout"
    #define SW_WORD_ADAPT       L"cWordAdapted"
    
    // Key word for attributes of table SEG_CHUNK
    #define SC_ID_SEG_CHK       L"nuIdSegChk"
    #define SC_ID_SEG           L"nuIdSeg"
    #define SC_ID_CHUNK         L"nuIdChunk"
    #define SC_INIT_POS         L"iInitPos"
    #define SC_ID_PREV          L"nuIdPrev"
    #define SC_ID_NEXT          L"nuIdNext"
    #define SC_MATCH_STATUS     L"cMatchStatus"
    #define SC_ALIGN_STATUS     L"cAlignStatus"
    
    // Key word for attributes of table T_SEG_ELEMENT
    #define SN_ID_SEGNGRAM      L"nuIdSegNGram"
    #define SN_ID_SEG           L"nuIdSeg"
    #define SN_ID_NGRAM         L"nuIdNGram"
    
    // Key word for attributes of table SEG_GROUP
    #define SG_ID_SEGGRP        L"nuIdSegGrp"
    #define SG_ID_GRP           L"nuIdGrpSeg"
    #define SG_ID_SEG           L"nuIdSeg"
    #define SG_SEG_RANK         L"siSegRank"
    
    // Key word for attributes of table ELEMENT_SEMANTIQUE
    #define SEMANTIQUE_ID_ELEMN L"nuIdElemn"
    #define TYPE_ELEMENT        L"nuIdTypeElement"
    #define SN_NB_CHUNK         L"SiNbChunk"
    #define ELEMENT_OCCURRENCE  L"NuIdOccurence"
    #define NU_ID_PAR           L"NuIdPar"
    #define VC_NAME             L"vcName"
    #define WS_TEXTE            L"wsText"
    #define ELMN_FONCTIONNEMENT L"NuIdFonctionnelement"
    #define ELEMENT_ID_DOC      L"siIdD"
    #define ELEMENT_ID_LANG     L"siIdLang"
    
    
    // Key word for attributes of table ELEMENT_WORD
    #define NW_ID_ELEMENT_WORD  L"nuIdElemntWord"
    #define NW_ID_ELEMENT       L"nuIdElemnt"
    #define NW_ID_WORD          L"nuIdWord"
    #define NW_STRING           L"vcString"
    #define NW_ID_POS           L"siIdPOS"
    #define NW_WORD_RANK        L"siWordRank"
    
    // Key word for attributes of table ELEMENT_CHK
    #define EC_ID_ELEMN_CHK     L"nuIdElemnChk"
    #define EC_ID_ELEMN         L"nuIdElemn"
    #define EC_ID_CHK           L"nuIdChunk"
    #define EC_CHUNK_RANK       L"siChkRank"
    
    // Key word for attributes of table ELEMENT_LINKS
    #define NL_ID_ELEMN_LNK     L"nuIdElemnLink"
    #define NL_ID_ELEMN_SRC     L"nuIdElemnSrc"
    #define NL_ID_PARAGRAPH     L"nuIdParagraph"
    #define NL_ID_DOC           L"iIdDoc"
    #define VC_NAME             L"vcName"
    
    // Key word for attributes of table CHUNK
    #define CHK_ID_CHK          L"nuIdChunk"
    #define CHK_NB_WORD         L"siNbWord"
    #define CHK_ID_CHK_TYPE     L"nuIdChunkType"
    #define CHK_TEXT            L"vcText"
    #define CHK_ID_CHK_DRV_POS  L"nuIdDrivingPos"
    #define CHK_ID_LANG         L"siIdLang"
    
    // Key word for attributes of table CHUNK_TYPE
    #define CT_ID_CHK_TYPE      L"nuIdChunkType"
    #define CT_LABEL            L"vcLabel"
    
    // Key word for attributes of table CHUNK_WORD
    #define CW_ID_CHK_WORD      L"nuIdChkWord"
    #define CW_ID_CHUNK         L"nuIdChunk"
    #define CW_ID_WORD          L"nuIdWord"
    #define CW_STRING           L"vcString"
    #define CW_ID_POS           L"siIdPOS"
    #define CW_WORD_RANK        L"siWordRank"
    
    // Key word for attributes of table CHUNK_GROUP
    #define CG_ID_CHKGRP        L"nuIdChkGrp"
    #define CG_ID_GRP           L"nuIdGrpChunk"
    #define CG_ID_CHUNK         L"nuIdChunk"
    #define CG_CHUNK_RANK       L"siChkRank"
    
    // Key word for attributes of table WORD
    #define WORD_ID_WORD        L"nuIdWord"
    #define WORD_STRING         L"vcString"
    #define WORD_ID_POS         L"siIdPOS"
    #define WORD_OCCURRENCE     L"siOccurrence"
    #define WORD_ID_LANG        L"siIdLang"
    #define WORD_ID_LEMMA       L"nuIdLemma"
    
    // Key word for attributes of table LEMMA
    #define LEM_ID_LEMMA        L"nuIdLemma"
    #define LEM_STRING          L"vcString"
    #define LEM_EXCLUDED        L"cExcluded"
    #define LEM_ID_POS          L"siIdPOS"
    #define LEM_ID_GENDER       L"siIdGender"
    #define LEM_ID_LANG         L"siIdLang"
    #define LEM_ID_TYP_DOC      L"siIdTypD"  //SIIDTYPD
    #define LEM_ID_DOC          L"siIdD"
    
    // Key word for attributes of table WORK_INFORMATION
    #define WI_DOCUMENT         L"vcDocument"
    #define WI_ID_SRC_LANG      L"siIdSrcLang"
    #define WI_ID_TYPE_DOC      L"siIdTypDoc"
    #define WI_ID_DOC           L"siIdDocument"
    // Key word for attributes of table PARA_TABLE
    #define PA_ID               L"nuIdPar"
    #define PA_IDENT            L"vcLabel"
    #define PA_TEXT             L"vcPar"
    #define PA_DOCID            L"iIdDoc"
    // Key word for ini file reading
    #define SECTION_DB_SCRIPT   L"DB_SCRIPTS"
    #define KEYNAME_CREATION_MISSION_DB_SCRIPT L"CREATE_MDB_SQL"
    
    /*_____GLOBAL-TYPES___________________________________________________________*/
    /*_____GLOBAL-DATA____________________________________________________________*/
    
    //static enSERVER_STATUS       m_enSrvStatus;        //Status of the server in the enum enSERVER_STATUS
    //static enDatabaseServer      m_enSrvType;          //Type of server define in the enum enDatabaseServer
    
    //static enDATABASE_STATUS     m_enStatus;        //Status of the server in the enum enSERVER_STATUS
    //static enDATABASE_TYPE       m_enType;          //Type of server define in the enum enDatabaseServer
    
    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;
    
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    /*Class         CDatabase                                                                                               */
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    //DATA
    //  CLASS CDatabase
    //    (Private)
    //    m_wsDBName			  	Name of the database.
    //    m_enType     				Type of database define in the enum enDATABASE_TYPE
    //	  m_wsLogin   		  		Login of the user for this database
    // 	  m_wsPassword      		Password string of the user for this database
    //	  m_enStatus	    		Status of the database in the enum enDATABASE_STATUS
    ////  m_wsDescription		    Description text (free field)
    	public ref class CDatabase
    	{
    		System::String^         m_wsSrvName;       //Name of the server.
    		System::String^         m_wsSrvLogin;      //Login of the user
    		System::String^         m_wsSrvPassword;   //Password string of the user
    		System::String^         m_wsName;          //Name of the server.
    		System::String^         m_wsDBName;
    		System::String^         m_wsLogin;         //Login of the user
    		System::String^         m_wsPassword;      //Password string of the user
    		System::String^         m_wsHost;
    		System::String^         m_wsUserName;
    		System::String^         m_wsDescription;   //Description text (free field)
    		CDatabase::CDatabase();
    		CDatabase::~CDatabase();
    		static System::String^ CDatabase::SetDBName( System::String^ wsDBName);
    		static void CDatabase::SetLogin( System::String^ wsLogin);
    		static void CDatabase::SetPassword( System::String^ wsPassword);
    		static void CDatabase::SetType(enDATABASE_TYPE enType);
    		static void SetStatus(enDATABASE_STATUS enStatus);
    		System::String^ CDatabase::GetDBName();
    		System::String^ CDatabase::GetLogin();
    		System::String^ CDatabase::GetPassword();
    		enDATABASE_TYPE CDatabase::GetType();
    		enDATABASE_STATUS CDatabase::GetStatus();
    	};
    };
    //ATAD
    /*_____GLOBAL-DATA____________________________________________________________*/
    /*_____GLOBAL-MACROS__________________________________________________________*/
    /*_____GLOBAL-FUNCTIONS-PROTOTYPES____________________________________________*/
    #endif /* DATABASE_H */
    
    

    puis le source :

    /*******************************************************************************
     * NOM:
     * ROLE:
     * HISTORIQUE:
        * 05/05/2001, xxx, initial version
    *******************************************************************************/
    #pragma hdrstop
    /*_____INCLUDE-FILES__________________________________________________________*/
    #include "StdAfx.h"
    #include "AlignStructure.h"
    #include "Macro.h"
    #include "Message.h"
    #include "EnumerationM.hpp"
    #include "StructureM.h"
    #include "TypeDefsM.hpp"
    #include "POSM.h"
    #include "ClasseAlignerManaged.hpp"
    #include "Language.h"
    #include "StrConv.h"
    #include "Database.h"
    #include "Server.h"
    /*_____LOCAL-DEFINE___________________________________________________________*/
    /*_____LOCAL-TYPES____________________________________________________________*/
    /*_____GLOBAL-DATA____________________________________________________________*/
    
    //extern SpecificationLoader::CInterbaseManager objInterbaseManager;
    
    enDatabaseServerM m_enSrvType;
    enSERVER_STATUS m_enSrvStatus;
    enDATABASE_TYPE m_enType;
    enDATABASE_STATUS  m_enStatus;
    
    /*_____LOCAL-DATA_____________________________________________________________*/
    /*_____LOCAL-MACROS___________________________________________________________*/
    
    /*_____LOCAL-FUNCTIONS-PROTOTYPES_____________________________________________*/
    /*_____GLOBAL-FUNCTIONS_______________________________________________________*/
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    /*Class         CServer                                                                                                            */
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    /*Name          CServer                                                                                        */
    /*Role          Class constructor                                                                                                 */
    /*Interface                                                                                                                       */
    /*In            None                                                                                                              */
    /*In/Out        None                                                                                                              */
    /*Result        None                                                                                                              */
    /*Constraints   None                                                                                                              */
    /*Resources     None                                                                                                              */
    /*PreCondition  None                                                                                                              */
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    namespace SpecificationChecker
    {
        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;
    
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    /*Class         CDatabase                                                                                               */
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    /*Name          CDatabase                                                                                                         */
    /*Role          Class constructor with the type as first parameter                                                                */
    /*Interface                                                                                                                       */
    /*In            enType		Type of database define in the enum enDATABASE_TYPE                                                     */
    /*In/Out        None                                                                                                              */
    /*Result        None                                                                                                              */
    /*Constraints   None                                                                                                              */
    /*Resources     None                                                                                                              */
    /*PreCondition  None                                                                                                              */
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    //PROC CDatabase(In: enType (enDATABASE_TYPE))
    //DATA
    //ATAD
    //DO
    //  m_wsDBName			:= [Empty wide string]
    //  m_wsLogin		    := [Empty wide string]
    //  m_wsPassword    := [Empty wide string]
    //  m_enType			  := enType
    //  m_enStatus			:= DATABASE_DISCONNECTED
    //OD
    CDatabase::CDatabase()
    {
      CDatabase::m_wsDBName = L"";
      CDatabase::m_wsLogin = L"";
      CDatabase::m_wsPassword = L"";
      CDatabase::m_enType = (enDATABASE_TYPE) 1;
      CDatabase::m_enStatus = enDATABASE_STATUS::DATABASE_DISCONNECTED;
    }
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    /*Name          ~CDatabase                                                                                             */
    /*Role          Class destructor                                                                                                  */
    /*Interface                                                                                                                       */
    /*In            None                                                                                                              */
    /*In/Out        None                                                                                                              */
    /*Result        None                                                                                                              */
    /*Constraints   None                                                                                                              */
    /*Resources     None                                                                                                              */
    /*PreCondition  None                                                                                                              */
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    //PROC ~CDatabase()
    //DATA
    //ATAD
    //DO
    //OD
    CDatabase::~CDatabase()
    {
    }
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    /*Name          Set<private member variable>                                                                                      */
    /*Role          Set the private member variable to the given value                                                                */
    /*Interface                                                                                                                       */
    /*In            <setting value>                                                                                                   */
    /*In/Out        None                                                                                                              */
    /*Result        None                                                                                                              */
    /*Constraints   None                                                                                                              */
    /*Resources     None                                                                                                              */
    /*PreCondition  CDatabase object must exist                                                                            */
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    //PROC Set<private member variable>(In : <setting value> (same type as the private member variable))
    //DATA
    //ATAD
    //DO
    //  m_<private member variable> := <setting value>
    //OD
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    System::String^ CDatabase::SetDBName( System::String^ wsDBName)
    {
      System::String^ ReturnDBName;
      wchar_t Temp[12]={0,0,0,0,0,0,0,0,0,0,0,0};
      wchar_t* wTemp =&Temp[0];
      size_t len;
      System::String^ wsTemp;
      System::String^ wsName;
    
      // size_type _Copy_s( value_type *_Dest, size_type _Dest_size, size_type _Count, size_type _Off = 0) const;
      // size_type copy( value_type* _Ptr, size_type _Count, size_type _Off = 0) const;
      ReturnDBName.assign( L"D:" + L"\\" + CDatabase::wsDBName);
      return( ReturnDBName);
    }
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    void CDatabase::SetLogin( System::String^ wsLogin)
    {
      CDatabase::m_wsLogin = wsLogin;
    }
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    void CDatabase::SetPassword( System:String^ wsPassword)
    {
      CDatabase::m_wsPassword = wsPassword;
    }
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    void CDatabase::SetType(enDATABASE_TYPE enType)
    {
      CDatabase::m_enType = enType;
    }
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    void CDatabase::SetStatus(enDATABASE_STATUS enStatus)
    {
      CDatabase::m_enStatus = enStatus;
    }
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    /*Name          Get<private member variable>                                                                                      */
    /*Role          Get the value of the private member variable                                                                      */
    /*Interface                                                                                                                       */
    /*In            None                                                                                                              */
    /*In/Out        None                                                                                                              */
    /*Result        value of the private member variable                                                                              */
    /*Constraints   None                                                                                                              */
    /*Resources     None                                                                                                              */
    /*PreCondition  CDatabase object must exist                                                                            */
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    //PROC Get<private member variable>(Result : <value of the private member variable> (same type as the private member variable))
    //DATA
    //ATAD
    //DO
    //  <value of the private member variable> := m_<private member variable>
    //OD
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    System::String^ CDatabase::GetDBName()
    {
      return( CDatabase::m_wsDBName);
    }
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    System::String^ CDatabase::GetLogin()
    {
      return( CDatabase::m_wsLogin);
    }
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    System::String^ CDatabase::GetPassword()
    {
      return( CDatabase::m_wsPassword);
    }
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    enDATABASE_TYPE CDatabase::GetType()
    {
      return( CDatabase::m_enType);
    }
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    enDATABASE_STATUS CDatabase::GetStatus()
    {
      return( CDatabase::m_enStatus);
    }
    };
    
    /*_____LOCAL-FUNCTIONS________________________________________________________*/
    


    Jean Noël Martin

    mercredi 15 juillet 2015 07:22
  • Je suis fatigué moi. :-(

    CDatabase::m_wsDBName = L"";

    ...

    Vous êtes dans un méthode de CDatabase, il ne faut pas spécifier CDatabase.


    Paul Bacelar, Ex - MVP VC++


    jeudi 16 juillet 2015 08:45
    Modérateur
  • il me met :

    1>  Database.cpp
    1>..\..\..\..\Common\src\Database.cpp(91): error C2653: 'CDatabase' : n'est pas un nom de classe ni d'espace de noms
    1>..\..\..\..\Common\src\Database.cpp(92): error C4430: spécificateur de type manquant - int est pris en compte par défaut. Remarque : C++ ne prend pas en charge int par défaut
    1>..\..\..\..\Common\src\Database.cpp(93): error C2065: 'm_wsDBName' : identificateur non déclaré
    1>..\..\..\..\Common\src\Database.cpp(94): error C2065: 'm_wsLogin' : identificateur non déclaré
    1>..\..\..\..\Common\src\Database.cpp(95): error C2065: 'm_wsPassword' : identificateur non déclaré
    1>..\..\..\..\Common\src\Database.cpp(98): warning C4508: 'SpecificationChecker::CDatabase' : la fonction doit retourner une valeur ; type de retour 'void' pris par défaut
    1>..\..\..\..\Common\src\Database.cpp(115): error C2653: 'CDatabase' : n'est pas un nom de classe ni d'espace de noms
    1>..\..\..\..\Common\src\Database.cpp(115): fatal error C1903: impossible de récupérer à partir des erreurs précédentes ; arrêt de la compilation
    

    il fallait déclarer la classe comme membre de SpecificationLoader


    Jean Noël Martin

    jeudi 16 juillet 2015 19:55
  • C'est déjà le cas dans le code que vous nous montrez.

    Paul Bacelar, Ex - MVP VC++


    vendredi 17 juillet 2015 07:19
    Modérateur
  • 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;
    
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    /*Class         CDatabase                                                                                               */
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    /*Name          CDatabase                                                                                                         */
    /*Role          Class constructor with the type as first parameter                                                                */
    /*Interface                                                                                                                       */
    /*In            enType		Type of database define in the enum enDATABASE_TYPE                                                     */
    /*In/Out        None                                                                                                              */
    /*Result        None                                                                                                              */
    /*Constraints   None                                                                                                              */
    /*Resources     None                                                                                                              */
    /*PreCondition  None                                                                                                              */
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    //PROC CDatabase(In: enType (enDATABASE_TYPE))
    //DATA
    //ATAD
    //DO
    //  m_wsDBName			:= [Empty wide string]
    //  m_wsLogin		    := [Empty wide string]
    //  m_wsPassword    := [Empty wide string]
    //  m_enType			  := enType
    //  m_enStatus			:= DATABASE_DISCONNECTED
    //OD
    CDatabase::CDatabase()
    {
    	CDatabase::m_wsDBName = L"";
    	CDatabase::m_wsLogin = L"";
    	CDatabase::m_wsPassword = L"";
    	CDatabase::m_enType = (enDATABASE_TYPE) 1;
    	CDatabase::m_enStatus = enDATABASE_STATUS::DATABASE_DISCONNECTED;
    }
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    /*Name          ~CDatabase                                                                                             */
    /*Role          Class destructor                                                                                                  */
    /*Interface                                                                                                                       */
    /*In            None                                                                                                              */
    /*In/Out        None                                                                                                              */
    /*Result        None                                                                                                              */
    /*Constraints   None                                                                                                              */
    /*Resources     None                                                                                                              */
    /*PreCondition  None                                                                                                              */
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    //PROC ~CDatabase()
    //DATA
    //ATAD
    //DO
    //OD
    CDatabase::~CDatabase()
    {
    }
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    /*Name          Set<private member variable>                                                                                      */
    /*Role          Set the private member variable to the given value                                                                */
    /*Interface                                                                                                                       */
    /*In            <setting value>                                                                                                   */
    /*In/Out        None                                                                                                              */
    /*Result        None                                                                                                              */
    /*Constraints   None                                                                                                              */
    /*Resources     None                                                                                                              */
    /*PreCondition  CDatabase object must exist                                                                            */
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    //PROC Set<private member variable>(In : <setting value> (same type as the private member variable))
    //DATA
    //ATAD
    //DO
    //  m_<private member variable> := <setting value>
    //OD
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    System::String^ CDatabase::SetDBName( System::String^ wsDBName)
    {
      System::String^ ReturnDBName;
      wchar_t Temp[12]={0,0,0,0,0,0,0,0,0,0,0,0};
      wchar_t* wTemp = &Temp[0];
    
      // size_type _Copy_s( value_type *_Dest, size_type _Dest_size, size_type _Count, size_type _Off = 0) const;
      // size_type copy( value_type* _Ptr, size_type _Count, size_type _Off = 0) const;
      ReturnDBName = L"D:" + L"\\" + wsDBName;
      return( ReturnDBName);
    }
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    void CDatabase::SetLogin( System::String^ wsLogin)
    {
      CDatabase::m_wsLogin = wsLogin;
    }
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    void CDatabase::SetPassword( System::String^ wsPassword)
    {
      CDatabase::m_wsPassword = wsPassword;
    }
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    void CDatabase::SetType(enDATABASE_TYPE enType)
    {
      CDatabase::m_enType = enType;
    }
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    void CDatabase::SetStatus(enDATABASE_STATUS enStatus)
    {
      CDatabase::m_enStatus = enStatus;
    }
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    /*Name          Get<private member variable>                                                                                      */
    /*Role          Get the value of the private member variable                                                                      */
    /*Interface                                                                                                                       */
    /*In            None                                                                                                              */
    /*In/Out        None                                                                                                              */
    /*Result        value of the private member variable                                                                              */
    /*Constraints   None                                                                                                              */
    /*Resources     None                                                                                                              */
    /*PreCondition  CDatabase object must exist                                                                            */
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    //PROC Get<private member variable>(Result : <value of the private member variable> (same type as the private member variable))
    //DATA
    //ATAD
    //DO
    //  <value of the private member variable> := m_<private member variable>
    //OD
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    System::String^ CDatabase::GetDBName()
    {
      return( CDatabase::m_wsDBName);
    }
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    System::String^ CDatabase::GetLogin()
    {
      return( CDatabase::m_wsLogin);
    }
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    System::String^ CDatabase::GetPassword()
    {
      return( CDatabase::m_wsPassword);
    }
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    enDATABASE_TYPE CDatabase::GetType()
    {
      return( CDatabase::m_enType);
    }
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    enDATABASE_STATUS CDatabase::GetStatus()
    {
      return( CDatabase::m_enStatus);
    }
    };
    
    /*_____LOCAL-FUNCTIONS________________________________________________________*/
    


    Jean Noël Martin

    • Marqué comme réponse JeanNoel53 vendredi 17 juillet 2015 08:20
    vendredi 17 juillet 2015 08:20