une de plus erreur de compilation

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

Answer 1

Bonjour, Jean Noël,

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

Cordialement,
Dimitar

Answer 2

---

Jean Noël Martin

Answer 3

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++

Answer 4

/*--------------------------------------------------------------------------------------------------------------------------------*/
/* 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

Answer 5

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++

Answer 6

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

Answer 7

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++

Answer 8

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

Answer 9

C'est déjà le cas dans le code que vous nous montrez.

---

Paul Bacelar, Ex - MVP VC++

Answer 10

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