警惕rapidxml的陷阱（二）：在Android上默认内存池分配数组过大，容易导致栈溢出

- ::57.840: I/ActivityManager(): Process com.sec.android.psfcore (pid ) (adj ) has died.
- ::57.850: D/Zygote(): Process terminated by signal ()

std::string pack_send_local_context_list_command(const std::string& unique,
std::vector<PSFResource>& key, int count, int state)
{
rapidxml::xml_document<> doc;
rapidxml::xml_node<>* root = doc.allocate_node(rapidxml::node_element, "set_list", NULL);
doc.append_node(root); root->append_node(doc.allocate_node(rapidxml::node_element, "unique_name", APPEND_STRING(unique, &doc)));
root->append_node(doc.allocate_node(rapidxml::node_element, "state", APPEND_STRING(cs::int2string(state), &doc)));
root->append_node(doc.allocate_node(rapidxml::node_element, "count", APPEND_STRING(cs::int2string(count), &doc))); rapidxml::xml_node<>* context_node = doc.allocate_node(rapidxml::node_element, "psfresources", NULL);
root->append_node(context_node); append(&doc, context_node, key);
std::string text;
rapidxml::print(std::back_inserter(text), doc, );
return text;
}

template<class Ch = char>
class xml_document: public xml_node<Ch>, public memory_pool<Ch>
{ public: //! Constructs empty XML document
xml_document()
: xml_node<Ch>(node_document)
{
}
...
}

enum node_type
{
node_document, //!< A document node. Name and value are empty.
node_element, //!< An element node. Name contains element name. Value contains text of first data node.
node_data, //!< A data node. Name is empty. Value contains data text.
node_cdata, //!< A CDATA node. Name is empty. Value contains data text.
node_comment, //!< A comment node. Name is empty. Value contains comment text.
node_declaration, //!< A declaration node. Name and value are empty. Declaration parameters (version, encoding and standalone) are in node attributes.
node_doctype, //!< A DOCTYPE node. Name is empty. Value contains DOCTYPE text.
node_pi //!< A PI node. Name contains target. Value contains instructions.
}; template<class Ch = char>
class xml_node: public xml_base<Ch>
{ public: ///////////////////////////////////////////////////////////////////////////
// Construction & destruction //! Constructs an empty node with the specified type.
//! Consider using memory_pool of appropriate document to allocate nodes manually.
//! \param type Type of node to construct.
xml_node(node_type type)
: m_type(type)
, m_first_node()
, m_first_attribute()
{
} ...
node_type m_type; // Type of node; always valid
xml_node<Ch> *m_first_node; // Pointer to first child node, or 0 if none; always valid
xml_node<Ch> *m_last_node; // Pointer to last child node, or 0 if none; this value is only valid if m_first_node is non-zero
xml_attribute<Ch> *m_first_attribute; // Pointer to first attribute of node, or 0 if none; always valid
xml_attribute<Ch> *m_last_attribute; // Pointer to last attribute of node, or 0 if none; this value is only valid if m_first_attribute is non-zero
xml_node<Ch> *m_prev_sibling; // Pointer to previous sibling of node, or 0 if none; this value is only valid if m_parent is non-zero
xml_node<Ch> *m_next_sibling; // Pointer to next sibling of node, or 0 if none; this value is only valid if m_parent is non-zero }

template<class Ch = char>
class memory_pool
{ public:
//! Constructs empty pool with default allocator functions.
memory_pool()
: m_alloc_func()
, m_free_func()
{
init();
}
void init()
{
m_begin = m_static_memory;
m_ptr = align(m_begin);
m_end = m_static_memory + sizeof(m_static_memory);
}
char *m_begin; // Start of raw memory making up current pool
char *m_ptr; // First free byte in current pool
char *m_end; // One past last available byte in current pool
char m_static_memory[RAPIDXML_STATIC_POOL_SIZE]; // Static raw memory
alloc_func *m_alloc_func; // Allocator function, or 0 if default is to be used
free_func *m_free_func; // Free function, or 0 if default is to be used
}

#ifndef RAPIDXML_STATIC_POOL_SIZE
// Size of static memory block of memory_pool.
// Define RAPIDXML_STATIC_POOL_SIZE before including rapidxml.hpp if you want to override the default value.
// No dynamic memory allocations are performed by memory_pool until static memory is exhausted.
#define RAPIDXML_STATIC_POOL_SIZE (64 * 1024)
#endif

#define RAPIDXML_STATIC_POOL_SIZE 4*1024