Fatal编程技术网

C++ CMarkup XML处理

c++ visual-studio-2010 visual-c++

C++ CMarkup XML处理,c++,visual-studio-2010,visual-c++,C++,Visual Studio 2010,Visual C++,这是我的第一篇文章，如果我犯了错误，很抱歉。目前我在VisualC++ 2010 Express项目中使用了CMAKUP，它是FrestObject所做的XML修改器/解析器。当我尝试使用函数CMarkup:：load（“Filename.xml”）加载一个xml文件时，所有的编译都很好，但我得到了一个运行时错误，我认为这是由于指针错误引起的，但我不理解！这是我使用的代码 g_XMLSeamanConversations.Load(MCD_T("SeamanVocabulary.xml"));

这是我的第一篇文章，如果我犯了错误，很抱歉。目前我在VisualC++ 2010 Express项目中使用了CMAKUP，它是FrestObject所做的XML修改器/解析器。当我尝试使用函数CMarkup:：load（“Filename.xml”）加载一个xml文件时，所有的编译都很好，但我得到了一个运行时错误，我认为这是由于指针错误引起的，但我不理解！这是我使用的代码

g_XMLSeamanConversations.Load(MCD_T("SeamanVocabulary.xml"));
g_XMLSeamanConversations.FindElem(MCD_T("SeamanVocabulary"));
g_XMLSeamanConversations.IntoElem();
g_XMLSeamanConversations.FindElem(MCD_T("SeamanQuestions"));
g_XMLSeamanConversations.IntoElem();
当我的代码调用Load（）时；函数，程序在此停止

template <class _T1, class _T2>
inline void _Param_Construct_aux(_T1* __p, const _T2& __val, const __true_type&) 
{
// We use binary copying for POD types since it results
// in a considerably better code at least on MSVC.
// This is the problem -----> *__p = _T1(__val);
}
然后

然后

然后

然后

模板
基本字符串&
基本字符串：：_M_append（const\u CharT*u first，
常数图*（最后一个）{
如果（第一个！=\u最后一个）{
大小\类型\ n=\静态\类型转换（大小\类型，最后一个-\第一个）；
如果（\uu n>=this->\u M\u rest（））{
大小\类型\长度=\计算\下一个大小（\ n）；
指针\uuuu new\u start=此->存储的\u M\u start\u分配（\uuuu len，\uuuu len）；
指针\uuuu new\u finish=\u STLP\u PRIV\uuuuu ucopy（this->\u M\u Start（），
此->\u M\u Finish（），\u new\u start）；
__新饰面=\u STLP\u PRIV\u ucopy（\uuuuu first，\uuuuu last，\uuuu new\u finish）；
_M_construct_null（u new_finish）；
此->_M_解除分配_块（）；
此->\u M\u重置（\u新\u开始，\u新\u结束，\u新\u开始+\u长度）；
}
否则{
常数图*\uuuu f1=\uuuu优先；
++__f1；
_STLP_PRIV_uuucopy（uu f1，uu last，this->u M_finish+1）；
_M_construct_null（此->M_finish+u n）；
_Traits:：assign（*end（），*\u first）；
这个->\u M\u finish+=\u n；
}
}
归还*这个；
}
然后

模板
内联输出程序ucopy（\u RandomAccessIter\uuuuuuuuuuuuuuuuuuuuuuuuuu优先，
_随机存取器（最后一个，输出器（结果）
{return uuuuUCopy（uuuu first，uuuu last，uuuuu result，
随机访问迭代器标记（），（ptrdiff t*）0）；}
然后

模板
内联输出程序ucopy（\u RandomAccessIter\uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu，
_输出程序uuu结果，常量随机u访问u迭代器u标记&，u距离*）{
_输出程序uuu cur=uuuuu结果；
_试一下{
对于（_距离u n=u最后一次-u第一次；u n>0；--u n）{
_参数构造（&*.\u cur，*.\u first）；
++__第一,；
++__cur；
}
返回当前值；
}
_STLP_展开（_STLP_STD:：_Destroy_Range（__结果，_cur））
_投掷后重新投掷（当前）
}
然后

模板
内联void(参数)构造(辅助)(T1*),常数(T2&),常数(val),常数(true)(类型&){
//我们对POD类型使用二进制复制，因为它会导致
//在一个相当好的代码中，至少在MSVC上是这样。
*__p=_T1（_val）；
}
最后

template <class _T1, class _T2>
inline void _Param_Construct_aux(_T1* __p, const _T2& __val, const __true_type&) {
// We use binary copying for POD types since it results
// in a considerably better code at least on MSVC.
*__p = _T1(__val);
}

模板
内联void(参数)构造(辅助)(T1*),常数(T2&),常数(val),常数(true)(类型&){
//我们对POD类型使用二进制复制，因为它会导致
//在一个相当好的代码中，至少在MSVC上是这样。
*__p=_T1（_val）；
}
希望这有帮助

这可能是Unicode集合的问题。试试这些选项

  • 在预处理器部分使用
    MARKUP\u STL
  • 取消选中“从父项或项目默认值继承”
  • 复制除
    UNICODE
    和
    \u UNICODE
    以外的任何其他预处理器宏，并将其与
    WIN32标记\u STL
  • 从您自己的代码中删除
    MCD\u T（“”
    ，只需使用
    .Load（“filename.xml”）
这应该行得通。

这可能是Unicode集合的问题。试试这些选项

  • 在预处理器部分使用
    MARKUP\u STL
  • 取消选中“从父项或项目默认值继承”
  • 复制除
    UNICODE
    和
    \u UNICODE
    以外的任何其他预处理器宏，并将其与
    WIN32标记\u STL
  • 从您自己的代码中删除
    MCD\u T（“”
    ，只需使用
    .Load（“filename.xml”）
那应该行。

我们需要查看调用此函数的代码…嗯，我如何回复，因为它不允许我对多个单词进行注释lol？我们需要查看调用此函数的代码…嗯，我如何回复，因为它不允许我对多个单词进行注释lol？ 
bool CMarkup::ReadTextFile( MCD_CSTR_FILENAME szFileName, MCD_STR& strDoc, 
MCD_STR* pstrResult, int* pnDocFlags, MCD_STR* pstrEncoding )
{
// Static utility method to load text file into strDoc
//
FilePos file;
file.m_nDocFlags = (pnDocFlags?*pnDocFlags:0) | MDF_READFILE;
bool bSuccess = file.FileOpen( szFileName );
if ( pstrResult )
*pstrResult = file.m_strIOResult;
MCD_STRCLEAR(strDoc);
if ( bSuccess )
{
file.FileSpecifyEncoding( pstrEncoding );
file.m_nOpFileByteLen = (int)((MCD_INTFILEOFFSET)
(file.m_nFileByteLen - file.m_nFileByteOffset));
bSuccess = file.FileReadText( strDoc );
file.FileClose();
if ( pstrResult )
*pstrResult += file.m_strIOResult;
if ( pnDocFlags )
*pnDocFlags = file.m_nDocFlags;
}
return bSuccess;
}

public:                         // Append, operator+=, push_back.

_Self& operator+=(const _Self& __s) { return append(__s); }

public:
_Self& append(const _Self& __s)
{ return _M_append(__s._M_Start(), __s._M_Finish()); }

template <class _CharT, class _Traits, class _Alloc>
basic_string<_CharT, _Traits, _Alloc>&
basic_string<_CharT, _Traits, _Alloc>::_M_append(const _CharT* __first,
const _CharT*     __last) {
if (__first != __last) {
size_type __n = __STATIC_CAST(size_type, __last - __first);
if (__n >= this->_M_rest()) {
size_type __len = _M_compute_next_size(__n);
pointer __new_start = this->_M_start_of_storage.allocate(__len, __len);
pointer __new_finish = _STLP_PRIV __ucopy(this->_M_Start(),
this->_M_Finish(),    __new_start);
__new_finish = _STLP_PRIV __ucopy(__first, __last, __new_finish);
_M_construct_null(__new_finish);
this->_M_deallocate_block();
this->_M_reset(__new_start, __new_finish, __new_start + __len);
}
else {
const _CharT* __f1 = __first;
++__f1;
_STLP_PRIV __ucopy(__f1, __last, this->_M_finish + 1);
_M_construct_null(this->_M_finish + __n);
_Traits::assign(*end(), *__first);
this->_M_finish += __n;
}
}
return *this;
}

template <class _RandomAccessIter, class _OutputIter>
inline _OutputIter __ucopy(_RandomAccessIter __first,
_RandomAccessIter __last,  _OutputIter __result)
{ return __ucopy(__first, __last, __result,
random_access_iterator_tag(),    (ptrdiff_t*)0); }

template <class _RandomAccessIter, class _OutputIter, class _Distance>
inline _OutputIter __ucopy(_RandomAccessIter __first, _RandomAccessIter __last,
_OutputIter __result, const random_access_iterator_tag &,    _Distance*) {
_OutputIter __cur = __result;
_STLP_TRY {
for (_Distance __n = __last - __first; __n > 0; --__n) {
_Param_Construct(&*__cur, *__first);
++__first;
++__cur;
}
return __cur;
}
_STLP_UNWIND(_STLP_STD::_Destroy_Range(__result, __cur))
_STLP_RET_AFTER_THROW(__cur)
}

template <class _T1, class _T2>
inline void _Param_Construct_aux(_T1* __p, const _T2& __val, const __true_type&) {
// We use binary copying for POD types since it results
// in a considerably better code at least on MSVC.
*__p = _T1(__val);
}

template <class _T1, class _T2>
inline void _Param_Construct_aux(_T1* __p, const _T2& __val, const __true_type&) {
// We use binary copying for POD types since it results
// in a considerably better code at least on MSVC.
*__p = _T1(__val);
}