3. Frage zur Konvertierung von time_t zu DWORD

Frage zur Konvertierung von time_t zu DWORD

  • A

    out schrieb:

    out schrieb:

    Allowed schrieb:

    Das ist es ja, ich will die Warnungen nicht per pragma abschalten, ich will sie schon beheben, nur welche Datentyp wären dafür angebracht.

    Na dann musste halt einen signed-Datentypen nehmen... int oder long int.

    Bzw. mal ne ganz doofe Frage. Wenn du fragst, welchen Datentypen du nehmen sollst, bedeutet das ja, du kannst ihn einfach ändern. Wieso nimmst du dann nicht einfach time_t? Wieso überhaupt iwelche Konvertierungen? 😕

    Ich verstehe jetzt nicht ganz den Sinn deines Satzes.

    Ja natürlich kann ich die Datentypen verändern.
    Ich hatte natürlich auch meine Gründe dafür, jedoch hat sich anscheinend einiges geändert von VS2003 auf 12.

    nGold ist vom Datentyp int
    nPostGold DWORD
    Und GetGold wird von der Klasse CMover abgeleitet welche vom Datentyp int ist.
    GetVisKeepTime ist vom Datentyp auch time_t und wird von der Klasse CItemElem abgeleitet.
    nPosition hat den Datentyp int

    Mfg.

    0
  • A

    Push

    0
  • Mod

    Allowed schrieb:

    Push

    Was willst du wissen? Entweder sind die Datentypen richtig gewählt, dann kannst du die Warnung ignorieren, oder eben nicht. Was von beidem der Fall ist, das können wir dir nicht sagen, das musst du selber wissen.

    0
  • D

    in VC2003 oder VC2012 steht in time.h

    typedef __int64   time_t;

    int hat aber nur 32 Bit, da hätte der VC2003 eigentlich auch schon schimpfen müssen. wenn man einer 32 Bit Variablen einen 64 Bit Wert zuweist, können signifikante Bits verloren gehen, und genau das versucht der Compiler dir irgendwie mitzuteilen

    verwende statt int einfach

    typedef __int64 MyInt;

    wenn das Programm auch unter Linux laufen soll, verwende

    __extension__ typedef long long MyInt;

    wenn dein Compiler das Headerfile cstdint hat, verwende

    typedef std::int64_t MyInt;
    0
  • A

    Naja nicht ganz, bei mir ist es anders definiert.

    #ifndef _TIME_T_DEFINED
    #ifdef _USE_32BIT_TIME_T
    typedef __time32_t time_t; /* time value /
    #else
    typedef __time64_t time_t; /     time value */
    #endif

    Aber, danke den Rest werde ich alleine hinbekommen.

    0
  • A

    So ich hab die ganzen Datentypen angepasst, also für die Konvertierungen von time_t in DWORD hab ich für DWORD, DWORD64 genommen.

    Nur das verursacht noch mehr Probleme wie ich es mir schon gedacht habe.

    IntelliSense: Kein ">>"-Operator stimmt mit diesen Operanden überein.
            Operandentypen sind: CAr >> DWORD64

    Die komplette Funktion mit CAr als Parameter ist wie folgt.

    void CDPClient::OnSetSkillState( CAr & ar )
{
	WORD wType, wID;
	DWORD64 dwLevel;
	DWORD	dwTime;
	OBJID	idTarget;
	ar >> idTarget >> wType >> wID;
#if __VER >= 11 // __SYS_COLLECTING
	if( wType == BUFF_ITEM2 )
	{
		time_t t;
		ar >> t;
		dwLevel		= time_null() + t;
	}
	else
		ar >> dwLevel;
#else	// __SYS_COLLECTING
	ar >> dwLevel;
#endif	// __SYS_COLLECTING
	ar >> dwTime;

	CMover *pTarget = prj.GetMover( idTarget );
	if( IsValidObj( pTarget ) )
		pTarget->AddBuff( wType, wID, dwLevel, dwTime );
}
    0
  • ?

    COffenbar Cist Cin Cder CAr-CKlasse Ckein CStream-CExtraktionsoperator Cfür C64-CInteger Cdefiniert.

    0
  • A

    Decimad schrieb:

    COffenbar Cist Cin Cder CAr-CKlasse Ckein CStream-CExtraktionsoperator Cfür C64-CInteger Cdefiniert.

    Ähm ja. Danke für die Antwort.

    Hier ist noch die kompllete Ar Klasse

    class CAr
{
public:
	CAr(void *lpBuf = NULL, u_int nBufSize = 0);
	~CAr();

// Flag values
	enum	{ store = 0, load = 1 };
	enum	{ nGrowSize = 16384 };

	static CHeapMng*	m_pHeapMng;

// Attributes
	BOOL	IsLoading()	const;
	BOOL	IsStoring()	const;

// Operations
	void	Read( void* lpBuf, u_int nSize );
	void	Write( const void* lpBuf, u_int nSize );
	void	CheckBuf( u_int nSize );
	void	Reserve( u_int nSize );
	void	Flush( void );
	void	ReelIn( u_int uOffset );

	// reading and writing strings
	void WriteString(LPCTSTR lpsz);
	LPTSTR ReadString(LPTSTR lpsz );
	LPTSTR ReadString( LPTSTR lpsz, int nBufSize );

	LPBYTE	GetBuffer( int* pnBufSize );
	u_long	GetOffset( void );
/*
	void	Copy( CAr & ar );
	CAr& operator = ( CAr & ar );
*/
	// insertion operations
	CAr& operator<<(BYTE by);
	CAr& operator<<(WORD w);
	CAr& operator<<(LONG l);
	CAr& operator<<(DWORD dw);
	CAr& operator<<(float f);
	CAr& operator<<(double d);

	CAr& operator<<(int i);
	CAr& operator<<(short w);
	CAr& operator<<(char ch);
	CAr& operator<<(unsigned u);

	// extraction operations
	CAr& operator>>(BYTE& by);
	CAr& operator>>(WORD& w);
	CAr& operator>>(DWORD& dw);
	CAr& operator>>(LONG& l);
	CAr& operator>>(float& f);
	CAr& operator>>(double& d);

	CAr& operator>>(int& i);
	CAr& operator>>(short& w);
	CAr& operator>>(char& ch);
	CAr& operator>>(unsigned& u);

#ifdef __CLIENT
#ifdef _DEBUG
static	DWORD	s_dwHdrPrev;
static	DWORD	s_dwHdrCur;
#endif	// _DEBUG
#endif	// __CLIENT

protected:
	BYTE	m_nMode;	// read or write
	u_int	m_nBufSize;
	LPBYTE	m_lpBufCur;
	LPBYTE	m_lpBufMax;
	LPBYTE	m_lpBufStart;
	BYTE	m_lpBuf[nGrowSize];
};
/*
inline void CAr::Copy( CAr & ar )
	{	ASSERT( IsLoading() );	ASSERT( ar.IsStoring() );	ar.Write( (void*)m_lpBufStart, (u_int)( m_lpBufMax - m_lpBufStart ) );	}
inline CAr& CAr::operator = ( CAr & ar )
	{	ar.Copy( *this );	return *this;	}
*/
inline BOOL CAr::IsLoading() const
	{ return (m_nMode & CAr::load) != 0; }
inline BOOL CAr::IsStoring() const
	{ return (m_nMode & CAr::load) == 0; }

inline CAr& CAr::operator<<(int i)
	{ return CAr::operator<<((LONG)i); }
inline CAr& CAr::operator<<(unsigned u)
	{ return CAr::operator<<((LONG)u); }
inline CAr& CAr::operator<<(short w)
	{ return CAr::operator<<((WORD)w); }
inline CAr& CAr::operator<<(char ch)
	{ return CAr::operator<<((BYTE)ch); }
inline CAr& CAr::operator<<(BYTE by)
	{ CheckBuf( sizeof(BYTE) );
		*(UNALIGNED BYTE*)m_lpBufCur = by; m_lpBufCur += sizeof(BYTE); return *this; }
inline CAr& CAr::operator<<(WORD w)
	{ CheckBuf( sizeof( WORD ) );
		*(UNALIGNED WORD*)m_lpBufCur = w; m_lpBufCur += sizeof(WORD); return *this; }
inline CAr& CAr::operator<<(LONG l)
	{ CheckBuf( sizeof(LONG) );
		*(UNALIGNED LONG*)m_lpBufCur = l; m_lpBufCur += sizeof(LONG); return *this; }
inline CAr& CAr::operator<<(DWORD dw)
	{ CheckBuf( sizeof(DWORD) );
		*(UNALIGNED DWORD*)m_lpBufCur = dw; m_lpBufCur += sizeof(DWORD); return *this; }
inline CAr& CAr::operator<<(float f)
	{ CheckBuf( sizeof(float) );
		*(UNALIGNED FLOAT*)m_lpBufCur = *(FLOAT*)&f; m_lpBufCur += sizeof(float); return *this; }
inline CAr& CAr::operator<<(double d)
	{ CheckBuf( sizeof(double) );
		*(UNALIGNED double*)m_lpBufCur = *(double*)&d; m_lpBufCur += sizeof(double); return *this; }

inline CAr& CAr::operator>>(int& i)
	{ return CAr::operator>>((LONG&)i); }
inline CAr& CAr::operator>>(unsigned& u)
	{ return CAr::operator>>((LONG&)u); }
inline CAr& CAr::operator>>(short& w)
	{ return CAr::operator>>((WORD&)w); }
inline CAr& CAr::operator>>(char& ch)
	{ return CAr::operator>>((BYTE&)ch); }

#define	CAR_SAFE_READ( type, value )	\
	if( m_lpBufCur + sizeof(type) <= m_lpBufMax )	\
		{	value	= *(UNALIGNED type*)m_lpBufCur;	m_lpBufCur += sizeof(type);	}	\
	else	\
		{	value	= (type)0;	m_lpBufCur	= m_lpBufMax;	}	\
	return *this

inline CAr& CAr::operator>>(BYTE& by)
	{	CAR_SAFE_READ( BYTE, by );	}
inline CAr& CAr::operator>>(WORD& w)
	{	CAR_SAFE_READ( WORD, w );	}
inline CAr& CAr::operator>>(DWORD& dw)
	{	CAR_SAFE_READ( DWORD, dw );	}
inline CAr& CAr::operator>>(float& f)
	{	CAR_SAFE_READ( float, f );	}
inline CAr& CAr::operator>>(double& d)
	{	CAR_SAFE_READ( double, d );	}
inline CAr& CAr::operator>>(LONG& l)
	{	CAR_SAFE_READ( LONG, l );	}

#include <D3DX9Math.h>

inline CAr& operator<<(CAr & ar, D3DXVECTOR3 v)
	{	ar.Write( &v, sizeof(D3DXVECTOR3) );	return ar;	}

inline CAr& operator>>(CAr & ar, D3DXVECTOR3& v)
	{	ar.Read( &v, sizeof(D3DXVECTOR3) );		return ar;	}

inline CAr& operator<<(CAr & ar, __int64 i)
	{	ar.Write( &i, sizeof(__int64) );	return ar;	}

inline CAr& operator>>(CAr & ar, __int64& i)
	{	ar.Read( &i, sizeof(__int64) );	return ar;	}

/*
inline CAr& operator<<(CAr & ar, CRect rect)
	{	ar.Write( &rect, sizeof(CRect) );	return ar;	}

inline CAr& operator>>(CAr & ar, CRect & rect)
	{	ar.Read( &rect, sizeof(CRect) );	return ar;	}
*/

inline CAr& operator<<(CAr & ar, RECT rect)
	{	ar.Write( &rect, sizeof(RECT) );	return ar;	}

inline CAr& operator>>(CAr & ar, RECT & rect)
	{	ar.Read( &rect, sizeof(RECT) );	return ar;	}

inline CAr& operator<<(CAr & ar, PLAY_ACCOUNT pa)
	{	ar.Write( &pa, sizeof(PLAY_ACCOUNT) );	return ar;	}

inline CAr& operator>>(CAr & ar, PLAY_ACCOUNT& pa)
	{	ar.Read( &pa, sizeof(PLAY_ACCOUNT) );	return ar;	}

inline u_long CAr::GetOffset( void )
{
	ASSERT( IsStoring() );
	return( m_lpBufCur - m_lpBufStart );
}
    0
  • D

    da sind wohl Operatoren für "__int64" definiert, ein DWORD64 ist aber ein "unsigned __int64"

    0
  • A

    dd++ schrieb:

    da sind wohl Operatoren für "__int64" definiert, ein DWORD64 ist aber ein "unsigned __int64"

    Hab jetzt DWORD64 noch extra in die Ar Klasse hinzugefügt. Funktioniert auch jetzt soweit nur jetzt kommt ein Problem was normalerweise leicht zu lösen ist, ich hab auch alle nötigen Dateien includiert (DPClient.cpp und .h) Jedoch scheint es nicht die Lösung zu sein.

    DPClient.obj : error LNK2019: Verweis auf nicht aufgelöstes externes Symbol ""public: class CAr & __thiscall CAr::operator>>(unsigned __int64 &)" (??5CAr@@QAEAAV0@AA_K@Z)" in Funktion ""private: void __thiscall CDPClient::OnSetSkillState(class CAr &)" (?OnSetSkillState@CDPClient@@AAEXAAVCAr@@@Z)".

    Die ar.h sieht momentan so aus.

    #ifndef __AR_H__
#define __AR_H__

#pragma once

#include "HeapMng.h"

class CAr
{
public:
	CAr(void *lpBuf = NULL, u_int nBufSize = 0);
	~CAr();

// Flag values
	enum	{ store = 0, load = 1 };
	enum	{ nGrowSize = 16384 };

	static CHeapMng*	m_pHeapMng;

// Attributes
	BOOL	IsLoading()	const;
	BOOL	IsStoring()	const;

// Operations
	void	Read( void* lpBuf, u_int nSize );
	void	Write( const void* lpBuf, u_int nSize );
	void	CheckBuf( u_int nSize );
	void	Reserve( u_int nSize );
	void	Flush( void );
	void	ReelIn( u_int uOffset );

	// reading and writing strings
	void WriteString(LPCTSTR lpsz);
	LPTSTR ReadString(LPTSTR lpsz );
	LPTSTR ReadString( LPTSTR lpsz, int nBufSize );

	LPBYTE	GetBuffer( int* pnBufSize );
	u_long	GetOffset( void );
/*
	void	Copy( CAr & ar );
	CAr& operator = ( CAr & ar );
*/
	// insertion operations
	CAr& operator<<(BYTE by);
	CAr& operator<<(WORD w);
	CAr& operator<<(LONG l);
	CAr& operator<<(DWORD dw);
	CAr& operator<<(float f);
	CAr& operator<<(double d);
	CAr& operator<<(DWORD64 dw64);

	CAr& operator<<(int i);
	CAr& operator<<(short w);
	CAr& operator<<(char ch);
	CAr& operator<<(unsigned u);

	// extraction operations
	CAr& operator>>(BYTE& by);
	CAr& operator>>(WORD& w);
	CAr& operator>>(DWORD& dw);
	CAr& operator>>(LONG& l);
	CAr& operator>>(float& f);
	CAr& operator>>(double& d);

	CAr& operator>>(int& i);
	CAr& operator>>(short& w);
	CAr& operator>>(char& ch);
	CAr& operator>>(unsigned& u);
	CAr& operator>>(DWORD64& dw64);

#ifdef __CLIENT
#ifdef _DEBUG
static	DWORD	s_dwHdrPrev;
static	DWORD	s_dwHdrCur;
#endif	// _DEBUG
#endif	// __CLIENT

protected:
	BYTE	m_nMode;	// read or write
	u_int	m_nBufSize;
	LPBYTE	m_lpBufCur;
	LPBYTE	m_lpBufMax;
	LPBYTE	m_lpBufStart;
	BYTE	m_lpBuf[nGrowSize];
};
/*
inline void CAr::Copy( CAr & ar )
	{	ASSERT( IsLoading() );	ASSERT( ar.IsStoring() );	ar.Write( (void*)m_lpBufStart, (u_int)( m_lpBufMax - m_lpBufStart ) );	}
inline CAr& CAr::operator = ( CAr & ar )
	{	ar.Copy( *this );	return *this;	}
*/
inline BOOL CAr::IsLoading() const
	{ return (m_nMode & CAr::load) != 0; }
inline BOOL CAr::IsStoring() const
	{ return (m_nMode & CAr::load) == 0; }

inline CAr& CAr::operator<<(int i)
	{ return CAr::operator<<((LONG)i); }
inline CAr& CAr::operator<<(unsigned u)
	{ return CAr::operator<<((LONG)u); }
inline CAr& CAr::operator<<(short w)
	{ return CAr::operator<<((WORD)w); }
inline CAr& CAr::operator<<(char ch)
	{ return CAr::operator<<((BYTE)ch); }
inline CAr& CAr::operator<<(BYTE by)
	{ CheckBuf( sizeof(BYTE) );
		*(UNALIGNED BYTE*)m_lpBufCur = by; m_lpBufCur += sizeof(BYTE); return *this; }
inline CAr& CAr::operator<<(WORD w)
	{ CheckBuf( sizeof( WORD ) );
		*(UNALIGNED WORD*)m_lpBufCur = w; m_lpBufCur += sizeof(WORD); return *this; }
inline CAr& CAr::operator<<(LONG l)
	{ CheckBuf( sizeof(LONG) );
		*(UNALIGNED LONG*)m_lpBufCur = l; m_lpBufCur += sizeof(LONG); return *this; }
inline CAr& CAr::operator<<(DWORD dw)
	{ CheckBuf( sizeof(DWORD) );
		*(UNALIGNED DWORD*)m_lpBufCur = dw; m_lpBufCur += sizeof(DWORD); return *this; }
inline CAr& CAr::operator<<(float f)
	{ CheckBuf( sizeof(float) );
		*(UNALIGNED FLOAT*)m_lpBufCur = *(FLOAT*)&f; m_lpBufCur += sizeof(float); return *this; }
inline CAr& CAr::operator<<(double d)
	{ CheckBuf( sizeof(double) );
		*(UNALIGNED double*)m_lpBufCur = *(double*)&d; m_lpBufCur += sizeof(double); return *this; }

inline CAr& CAr::operator>>(int& i)
	{ return CAr::operator>>((LONG&)i); }
inline CAr& CAr::operator>>(unsigned& u)
	{ return CAr::operator>>((LONG&)u); }
inline CAr& CAr::operator>>(short& w)
	{ return CAr::operator>>((WORD&)w); }
inline CAr& CAr::operator>>(char& ch)
	{ return CAr::operator>>((BYTE&)ch); }

#define	CAR_SAFE_READ( type, value )	\
	if( m_lpBufCur + sizeof(type) <= m_lpBufMax )	\
		{	value	= *(UNALIGNED type*)m_lpBufCur;	m_lpBufCur += sizeof(type);	}	\
	else	\
		{	value	= (type)0;	m_lpBufCur	= m_lpBufMax;	}	\
	return *this

inline CAr& CAr::operator>>(BYTE& by)
	{	CAR_SAFE_READ( BYTE, by );	}
inline CAr& CAr::operator>>(WORD& w)
	{	CAR_SAFE_READ( WORD, w );	}
inline CAr& CAr::operator>>(DWORD& dw)
	{	CAR_SAFE_READ( DWORD, dw );	}
inline CAr& CAr::operator>>(float& f)
	{	CAR_SAFE_READ( float, f );	}
inline CAr& CAr::operator>>(double& d)
	{	CAR_SAFE_READ( double, d );	}
inline CAr& CAr::operator>>(LONG& l)
	{	CAR_SAFE_READ( LONG, l );	}

#include <D3DX9Math.h>

inline CAr& operator<<(CAr & ar, D3DXVECTOR3 v)
	{	ar.Write( &v, sizeof(D3DXVECTOR3) );	return ar;	}

inline CAr& operator>>(CAr & ar, D3DXVECTOR3& v)
	{	ar.Read( &v, sizeof(D3DXVECTOR3) );		return ar;	}

inline CAr& operator<<(CAr & ar, __int64 i)
	{	ar.Write( &i, sizeof(__int64) );	return ar;	}

inline CAr& operator>>(CAr & ar, __int64& i)
	{	ar.Read( &i, sizeof(__int64) );	return ar;	}

/*
inline CAr& operator<<(CAr & ar, CRect rect)
	{	ar.Write( &rect, sizeof(CRect) );	return ar;	}

inline CAr& operator>>(CAr & ar, CRect & rect)
	{	ar.Read( &rect, sizeof(CRect) );	return ar;	}
*/

inline CAr& operator<<(CAr & ar, RECT rect)
	{	ar.Write( &rect, sizeof(RECT) );	return ar;	}

inline CAr& operator>>(CAr & ar, RECT & rect)
	{	ar.Read( &rect, sizeof(RECT) );	return ar;	}

inline CAr& operator<<(CAr & ar, PLAY_ACCOUNT pa)
	{	ar.Write( &pa, sizeof(PLAY_ACCOUNT) );	return ar;	}

inline CAr& operator>>(CAr & ar, PLAY_ACCOUNT& pa)
	{	ar.Read( &pa, sizeof(PLAY_ACCOUNT) );	return ar;	}

inline u_long CAr::GetOffset( void )
{
	ASSERT( IsStoring() );
	return( m_lpBufCur - m_lpBufStart );
}

#endif //__AR_H__

    Und der Teil der DPClient.cpp

    void CDPClient::OnSetSkillState( CAr & ar )
{
	//typedef DWORDLONG MyDword;
	WORD wType, wID;
	DWORD64 dw64Level;
	DWORD	dwTime;
	OBJID	idTarget;
	ar >> idTarget >> wType >> wID;
#if __VER >= 11 // __SYS_COLLECTING
	if( wType == BUFF_ITEM2 )
	{
		time_t t;
		ar >> t;
		dw64Level		= time_null() + t;
	}
	else
		ar >> dw64Level;
#else	// __SYS_COLLECTING
	ar >> dw64Level;
#endif	// __SYS_COLLECTING
	ar >> dwTime;

	CMover *pTarget = prj.GetMover( idTarget );
	if( IsValidObj( pTarget ) )
		pTarget->AddBuff( wType, wID, dw64Level, dwTime );
}
    0
  • D

    nunja, wie der Compiler schon sagt, ist "CAr& operator>>(DWORD64& dw64);" zwar deklariert, aber nicht definiert

    0
  • A

    dd++ schrieb:

    nunja, wie der Compiler schon sagt, ist "CAr& operator>>(DWORD64& dw64);" zwar deklariert, aber nicht definiert

    Ich hab nun die Definition noch hinzugefügt = same error.

    typedef unsigned long long DWORD64;

    0
  • A

    Allowed schrieb:

    dd++ schrieb:

    nunja, wie der Compiler schon sagt, ist "CAr& operator>>(DWORD64& dw64);" zwar deklariert, aber nicht definiert

    Ich hab nun die Definition noch hinzugefügt = same error.

    typedef unsigned long long DWORD64;

    Push

    0
  • Mod

    Du pusht nun schon zum wiederholten Mal deine Fragen. Wenn deine Fragen nicht beantwortet werden, dann liegt das an den Fragen, nicht daran, dass dir keiner helfen möchte. Beziehungsweise ein bisschen möchte dir schon keiner helfen, denn deine Fragen sind nicht hilfreich 😃 :

    Du brauchst Hilfe?
    Warum dir keiner helfen will

    0
Anmelden zum Antworten