spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

void CApplication::AddAddress()
{
    //! Adds an address to the list.

    NetStream::CIP  IP;
    ETargetType     Type;
    char            acBuffer[64];

    std::cout << "IP: "; std::cin.getline(acBuffer, 64);    IP.SetH(acBuffer);
    std::cout << "Type: "; std::cin.getline(acBuffer, 64);
    switch(tolower(acBuffer[0]))
    {
    case 's':   Type    =   TYPE_SERVER;        break;
    case 'w':   Type    =   TYPE_WORKSTATION;   break;
    default:    std::cout << "Unknown type!"; std::cin.sync(); std::cin.get(); return;
    }

    std::cout << "New ID: " << m_Targets.AddIP(IP, Type)->usID;
}   // <-- Hier tritt angeblich der Fehler auf.

C-/C++-Quelltext

PingTargetVecIt CTargetList::AddIP(const NetStream::CIP &IP, const ETargetType &Type)
{
    SPingTarget Target;
    Target.IP   =   IP;
    Target.Type =   Type;
    Target.usID =   m_Targets.size();
    m_Targets.push_back(Target);
    return FindEntryByID(Target.usID);
}

C-/C++-Quelltext

PingTargetVecIt CTargetList::FindEntryByID(const unsigned short usID)
{
    for(PingTargetVecIt It = m_Targets.begin(); It != m_Targets.end(); It++)
    {
        if(It->usID == usID)
            return It;
    }

    return m_Targets.end();
}

C-/C++-Quelltext

// Target type enumeration


enum ETargetType
{
    TYPE_SERVER         =   0,
    TYPE_WORKSTATION    =   1
};


// Address structure


struct SPingTarget
{
    unsigned short      usID;
    NetStream::CIP      IP;
    ETargetType         Type;
};

const bool operator == (const SPingTarget &Left, const SPingTarget &Right);

typedef std::vector<SPingTarget>        PingTargetVec;
typedef PingTargetVec::iterator         PingTargetVecIt;
typedef PingTargetVec::const_iterator   PingTargetVecConstIt;

C-/C++-Quelltext

namespace NetStream
{
    /*!
    This is a class for IP-Addresses.
    */
    class NETSTREAM_API CIP
    {
    public:
        // --- Constructors ---------------------

        CIP();
        CIP(const std::string &IP);
        CIP(const char *pcIP);
        CIP(const CIP &pSrc);
        ~CIP();

        // --- Basic-Methods --------------------

        void    SetH(const std::string &IP);
        void    SetN(const unsigned long ulAddr);

        std::string     GetH() const;
        unsigned long   GetN() const;

        // --- Operators ------------------------

        unsigned char   &operator [] (unsigned char ucIndex);
        const bool      operator == (const CIP &Right) const;
        const bool      operator != (const CIP &Right) const;

    private:
        // --- Variables ------------------------

        unsigned char   m_ucAddr[4];
    };
}

C-/C++-Quelltext

namespace NetStream
{
    CIP::CIP()
    {
        //! Default constructor.

        SetH("0.0.0.0");
    }

    CIP::CIP(const std::string &IP)
    {
        //! Initialising constructor.

        //! \param[in] IP the IP-Address.

        SetH(IP);
    }

    CIP::CIP(const char *pcIP)
    {
        //! Initialising constructor.

        //! \param[in] pcIP The IP-Address.

        SetH(pcIP);
    }

    CIP::CIP(const CIP &pSrc)
    {
        //! Copy constructor.

        //! \param[in] pSrc Reference to the Source object.

        m_ucAddr[0] =   pSrc.m_ucAddr[0];
        m_ucAddr[1] =   pSrc.m_ucAddr[1];
        m_ucAddr[2] =   pSrc.m_ucAddr[2];
        m_ucAddr[3] =   pSrc.m_ucAddr[3];
    }

    CIP::~CIP()
    {
        //! Destructor.

    }

// =================================================================================================

// Basic-Methods


    void CIP::SetH(const std::string &IP)
    {
        //! Sets the IP-Address with an IP-String.

        //! \param[in] IP The IP String.

        if(sscanf_s(IP.c_str(), "%d.%d.%d.%d", &m_ucAddr[0], &m_ucAddr[1], &m_ucAddr[2], &m_ucAddr[3]) == -1)
            throw(std::bad_exception("Can not create IP-Address from String."));
    }

    void CIP::SetN(const unsigned long ulAddr)
    {
        //! Sets the IP-Address with an Network-Ordered Address.

        //! \param[in] ulAddr The Address.

        char    acBuffer[32];
        in_addr Addr;
        Addr.S_un.S_addr    =   ulAddr;
        strcpy_s(acBuffer, 32, inet_ntoa(Addr));
        SetH(acBuffer);
    }

    std::string CIP::GetH() const
    {
        //! Returns the Address in Host-Byte-Order.

        //! \return The IP-String.

        std::string Buffer;
        char        acBuffer[32];
        Buffer.clear();
        /*_itoa_s(static_cast<signed>(m_ucAddr[0]), acBuffer, 32);  Buffer  +=  acBuffer;   Buffer  +=  ".";
        _itoa_s(static_cast<signed>(m_ucAddr[1]), acBuffer, 32);    Buffer  +=  acBuffer;   Buffer  +=  ".";
        _itoa_s(static_cast<signed>(m_ucAddr[2]), acBuffer, 32);    Buffer  +=  acBuffer;   Buffer  +=  ".";
        _itoa_s(static_cast<signed>(m_ucAddr[3]), acBuffer, 32);    Buffer  +=  acBuffer;
        Buffer  +=  static_cast<signed>(m_ucAddr[0]);   Buffer  +=  ".";
        Buffer  +=  static_cast<signed>(m_ucAddr[1]);   Buffer  +=  ".";
        Buffer  +=  static_cast<signed>(m_ucAddr[2]);   Buffer  +=  ".";
        Buffer  +=  static_cast<signed>(m_ucAddr[3]);*/
        sprintf_s(acBuffer, "%d.%d.%d.%d", &m_ucAddr[0], &m_ucAddr[1], &m_ucAddr[2], &m_ucAddr[3]);
        return Buffer;
    }

    unsigned long CIP::GetN() const
    {
        // Returns the Address in Network-Byte-Order.

        // \return The IP-Address.

        return inet_addr(GetH().c_str());
    }

// =================================================================================================

// Operators


    unsigned char &CIP::operator [] (unsigned char ucIndex)
    {
        //! Returns one Byte of the Address.

        assert(ucIndex < 4);
        return m_ucAddr[ucIndex];
    }

    const bool CIP::operator == (const CIP &Right) const
    {
        for(unsigned i = 0; i < 4; i++)
        {
            if(m_ucAddr[i] != Right.m_ucAddr[i])    return false;
        }

        return true;
    }

    const bool CIP::operator != (const CIP &Right) const
    {
        for(unsigned i = 0; i < 4; i++)
        {
            if(m_ucAddr[i] != Right.m_ucAddr[i])    return true;
        }

        return false;
    }
}