<?xml version="1.0" encoding="utf-16" standalone="no" ?>
<bankomat>
  <kunde>
    <vorname>test1</vorname>
    <nachname>test2</nachname>
    <pin>123</pin>
    <kontostand>5000</kontostand>
  </kunde>
  <kunde>
    <vorname>test3</vorname>
    <nachname>test4</nachname>
    <pin>456</pin>
    <kontostand>6000</kontostand>
  </kunde>
</bankomat>

Nun will ich die Value rausfiltern (Elemente sind kein Problem)
Also sprich test1, test2 ....
Dies probiere ich mit getNodeValue wie folgt:

const XMLCh* value = currentNode->getNodeValue();
			std::string	currentValue;
			if (value)
			{
				currentValue = xercesc::XMLString::transcode(value);
				std::cout << value << std::endl;
				std::cout << currentValue << std::endl;
			}
			else
			{
				currentValue = "No Value";
				std::cout << currentValue;
			}

Hier der gesamte Code:

class XStr
{
public :
    // -----------------------------------------------------------------------
    //  Constructors and Destructor
    // -----------------------------------------------------------------------
    XStr(const char* const toTranscode)
    {
        // Call the private transcoding method
        fUnicodeForm = XMLString::transcode(toTranscode);
    }

    ~XStr()
    {
        XMLString::release(&fUnicodeForm);
    }

    // -----------------------------------------------------------------------
    //  Getter methods
    // -----------------------------------------------------------------------
    const XMLCh* unicodeForm() const
    {
        return fUnicodeForm;
    }

private :
    // -----------------------------------------------------------------------
    //  Private data members
    //
    //  fUnicodeForm
    //      This is the Unicode XMLCh format of the string.
    // -----------------------------------------------------------------------
    XMLCh*   fUnicodeForm;
};
char* xmlFile;
#define X(str) XStr(str).unicodeForm()

void traverseXml(xercesc::DOMElement *element)
{   

    xercesc::DOMNodeList *children = element->getChildNodes();
    const  XMLSize_t nodeCount = children->getLength();    

    for( XMLSize_t n = 0; n < nodeCount; ++n )
    {        
        xercesc::DOMNode *currentNode = children->item(n);

        if( currentNode->getNodeType() &&
                ( currentNode->getNodeType() == xercesc::DOMNode::ELEMENT_NODE )) // is element
        {
        // Found node which is an Element. Re-cast node as element
            xercesc::DOMElement* currentElement = dynamic_cast< xercesc::DOMElement* > ( currentNode );

            std::string currentName(xercesc::XMLString::transcode(currentElement->getTagName()));
            std::string elementName(xercesc::XMLString::transcode(element->getTagName()));

			const XMLCh* value = currentNode->getNodeValue();
			std::string	currentValue;
			if (value)
			{
				currentValue = xercesc::XMLString::transcode(value);
				std::cout << value << std::endl;
				std::cout << currentValue << std::endl;
			}
			else
			{
				currentValue = "No Value";
				std::cout << currentValue;
			}

            //xercesc::DOMElement* tempElement = dynamic_cast< xercesc::DOMElement* > ( currentNode );

            //std::cout << " - " << xercesc::XMLString::transcode(tempElement->getTagName()) << std::endl ;
			//std::cout << "Element: " << elementName << std::endl;  
			//std::cout << "Current: " << currentName << std::endl;
			//std::cout << "Value: " << currentValue << std::endl;

            traverseXml(currentElement);
        }
    }
}

bool parseXML()
{
    try
    {
        XMLPlatformUtils::Initialize();
    }

    catch(const XMLException& toCatch)
    {
        char *pMsg = XMLString::transcode(toCatch.getMessage());
        XERCES_STD_QUALIFIER cerr << "Error during Xerces-c Initialization.\n"
             << "  Exception message:"
             << pMsg;
        XMLString::release(&pMsg);
        return 1;
    }

  XercesDOMParser* parser = new XercesDOMParser();

    xercesc::XMLPlatformUtils::Initialize();

    XercesDOMParser* m_configFileParser = new xercesc::XercesDOMParser;

    m_configFileParser->setValidationScheme( xercesc::XercesDOMParser::Val_Never );
    m_configFileParser->setDoNamespaces( false );
    m_configFileParser->setDoSchema( false );
    m_configFileParser->setLoadExternalDTD( false );
    m_configFileParser->parse("Kunden.xml");
    parser->getDocument();
    xercesc::DOMDocument *xmlDoc = m_configFileParser->getDocument();
    xercesc::DOMElement *elementRoot = xmlDoc->getDocumentElement();

    if( !elementRoot )
    {
        std::cout << "empty XML document" << std::endl;
        return false;
    }
    else
    {
        traverseXml(elementRoot);
    }

    return true;

}

int main()
{
 parseXML();
}

Hoffe auf Hilfe :-))

http://xerces.apache.org/xerces-c/apiDocs-3/classDOMNode.html#676aacf9c5bcc6335be34bd952b10d44

Gruß,
XSpille