Probleme mit den bekanntmachen von Funktionen in Header bei C++

#include <content_xml.hpp>

#include <Parser.hpp>

#include <stdint.h>

#include <stdlib.h>

#include <string.h>

using namespace std;

extern volatile uint32_t Memory[1024];

void ParserChar(char *ptr, uint16_t Len){

  //...

}

void ParserMem(uint32_t *ptr){

  //...

}

uint8_t StartParserXml(char *ptr, uint16_t Len){

    //...

    return 1;

}

uint8_t StartParserByte(uint32_t *ptr){

    //...

    return 1;

}

ClContent_xml** contentAdd(uint16_t inkrement){

    //...

}

uint8_t StartCheckXml(void){

  //...

    return 1;

}

uint8_t StartGenerateByte(uint32_t* ptr, uint16_t MaxLen){

  //...

    return 1;

}

uint32_t getByte(uint16_t i){

    //...

    return Value;

}

uint8_t NumData(char* ptr){

    //...

    return Nummer;

}

uint8_t IsNumeric(char* ptr){

    //...

    return 0;

}

uint8_t strToU8(char* ptr){

    //...

    return Val;

}

uint16_t strToU16(char* ptr){

    //...

}

uint32_t strToU32(char* ptr){

    //...

    return Val;

}

uint32_t strXToU32(char* ptr){

    //...

    return Val;

}

uint16_t* strToU16Array(char* ptr){

    uint16_t Val = 0;

    uint8_t Num = 0;

    uint8_t st = 0;

    uint16_t *Array, *LArray;

    char *Sptr;

    Sptr = ptr;

    // Anzahl der Zahlen ermitteln

    do{

        switch(*ptr){

        case '0':

        case '1':

        case '2':

        case '3':

        case '4':

        case '5':

        case '6':

        case '7':

        case '8':

        case '9':

            if((st & 0x02) == 0x00){

                Num++;

                st |= 0x02;

            }

            break;

        case ' ':

        case ',':

            if((st & 0x02) == 0x02){

                st = (st & ~0x02);

            }

            break;

        default:

            st |= 0x01;

            break;

        }

        ptr++;

    }while((st & 0x01) == 0);

    Array = new uint16_t[Num];

    LArray = Array;

    for(uint8_t i = 0; i < Num; i++){

        while((*Sptr == ' ') || (*Sptr == ',')){

            Sptr++;

        }

        *LArray = strToU16(Sptr);

        //printf("\n%i, Wert: %i, Adresse: 0x%x", i, *LArray, LArray);

        while(IsNumeric(Sptr)){

            Sptr++;

        }

        LArray++;

    }

    return Array;

}

uint32_t* strToU32Array(char* ptr, uint8_t Num){

    uint32_t Val = 0;

    uint8_t st = 0;

    uint32_t *Array, *LArray;

    char *Sptr;

    Sptr = ptr;

    Array = new uint32_t[Num];

    LArray = Array;

    for(uint8_t i = 0; i < Num; i++){

        // Leerzeichen ignurieren

        while(*ptr == ' '){

            ptr++;

        }

        if(1 == IsNumeric(ptr)){

            *LArray = strToU32(ptr);

            LArray++;

            do{

                ptr++;

            }while(1 == IsNumeric(ptr));

        }

        else{

            return Array;

        }

    }

    return Array;

}

uint32_t* strXToU32Array(char* ptr, uint8_t Num){

    uint32_t Val = 0;

    uint8_t st = 0;

    uint32_t *Array, *LArray;

    Array = new uint32_t[Num];

    LArray = Array;

    for(uint8_t i = 0; i < Num; i++){

        // Leerzeichen ignurieren

        while((*ptr == ' ') || (*ptr == ',')){

            ptr++;

        }

        if((1 == IsNumeric(ptr))){

            *LArray = strXToU32(ptr);

            LArray++;

            do{

                ptr++;

            }while((1 == IsNumeric(ptr)) || (*ptr == 'x') || (*ptr == 'X'));

        }

        else{

            return Array;

        }

    }

    return Array;

}

uint16_t setByteU8(uint8_t Value, uint16_t Inkrement){

    //...

    return Inkrement + 1;

}

uint16_t setByteU16(uint16_t Value, uint16_t Inkrement){

    //...

    return Inkrement + 2;

}

uint16_t setByteU32(uint32_t Value, uint16_t Inkrement){

    //...

    return Inkrement + 4;

}

uint16_t setByte(void){

    // MemByte in das Flash schreiben

    return 0;

}

#ifndef PARSER_H

#define PARSER_H

#include <stdint.h>

#include <content_xml.hpp>

#include <loopdef.hpp>

#include <trigger.hpp>

namespace std{

  void ParserChar(char*, uint16_t);

  void ParserMem(uint32_t*);

  // Funktionsprototypen

  uint8_t pstringp(char*, uint16_t);

  uint8_t GetValue(void);

  // Variablen

  ClContent_xml **contentXml;

  uint8_t contentXml_Load;

  uint8_t StartParserXml(char*, uint16_t);

  uint8_t StartCheckXml(void);

  uint8_t StartParserByte(uint32_t*);

  uint8_t StartGenerateByte(uint32_t*, uint16_t);

  uint32_t *BytePtr;

  uint8_t NumData(char*);

  uint8_t IsNumeric(char*);

  uint8_t strToU8(char*);

  uint16_t strToU16(char*);

  uint32_t strToU32(char*);

  uint32_t strXToU32(char*);

  uint16_t* strToU16Array(char*);

  uint32_t* strToU32Array(char*, uint8_t);

  uint32_t* strXToU32Array(char*, uint8_t);

  char StrGreet[30];

  // Variablen

  char* StringPtr;

  uint16_t StringLen;

  // Prototypen

  ClContent_xml **contentAdd(uint16_t);

  uint32_t getByte(uint16_t);

  uint16_t setByteU8(uint8_t, uint16_t);

  uint16_t setByteU16(uint16_t, uint16_t);

  uint16_t setByteU32(uint32_t, uint16_t);

  uint16_t setByte(void);

  uint32_t MemByte;

  ClLoopdef **StmLoop;

  uint8_t StmLoopLoad;

  ClTrigger **StmTrigger;

  uint8_t StmTriggerLoad;

}

#endif // PARSER_H