Es handelt sich um folgende Code Zeile:

log.Gold2	= pItem->GetVisKeepTime( nPosition ) - time_null();

warning C4244: '=': Konvertierung von 'time_t' in 'DWORD', möglicher Datenverlust

Ich hab schon versucht mit deinem static_cast es zu DWORD downzucasten, jedoch hat das auch nicht funktioniert, deswegen wäre es lieb wenn es mir einer erklären könnte.

Dazu hab ich noch 2 Konflikte zwischen signed und unsigned

Hier:

if( pUser->GetGold() <  (UINT)( ( nPostGold + nGold ) ) )

und hier:

if( pEquip->GetProp()->dwItemLV >= it->first )

Mit freundlichen Grüßen,

Steve

Wofür du aber sicher keinen guten Grund hast, sind die ganzen Casts, noch dazu C-Style Casts . Benutz in C++ unbedingt die C++-Casts, die sind
1. Besser lesbar
2. Es ist klar was du erreichen willst und es kann auch kein überraschender Nebeneffekt auftreten. Ein C-Style Cast ist ein static-, const- und reinterpret-Cast in einem. Bist du immer sicher, dass du weißt, was passiert^*?
Außerdem sind viele Casts häufig ein Zeichen von schlechtem Design, was wieder zurück zum ersten Absatz dieser Antwort führt: Sollen denn da wirklich Variablen unterschiedlicher Signedness verglichen werden? Dies deutet darauf hin, dass dort Äpfel mit Birnen verglichen werden, oder dass die Äpfel eigentlich von vornherein Birnen sein sollten. Ebenso bei dem Datenverlust, wobei man es dort noch eher rechtfertigen kann.

^*: Klar gibt es Regeln, aber erfahrungsgemäß sind diese nicht immer bekannt.

Die restlichen Fehler und Warnungen konnte ich auch leicht beheben, nur die wollen nicht so ganz.

Die static_cast habe ich lieber genommen als es mit voller Gewalt zB. so zu machen mit (Datentyp).

Mfg.

#pragma warning(disable : 4244)

Die korrekten Datentypen benutzen wäre natürlich hübscher.

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.

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?

Wenn du fragst, welchen Datentypen du nehmen sollst, bedeutet das ja, du kannst ihn einfach ändern.

Noch viel wichtiger: Wenn einfach solche Änderungen von signed nach unsigned vorgenommen werden können, ohne mit der Wimper zu zucken, dann war mein vorheriger Einwurf genau richtig

SeppJ schrieb:

Außerdem sind viele Casts häufig ein Zeichen von schlechtem Design, [...]: Sollen denn da wirklich Variablen unterschiedlicher Signedness verglichen werden? Dies deutet darauf hin, dass dort Äpfel mit Birnen verglichen werden, oder dass die Äpfel eigentlich von vornherein Birnen sein sollten.

und die Antwort des Threaderstellers etwas voreilig:

Allowed schrieb:

Ah ok, danke ich verstehe was du meinst, diese Operationen sind schon gerechtfertigt,

Die Diagnose steht also: Falsches Design, die Datentypen repräsentieren nicht die Art von Objekten die sie sollten. Daher Tipp für den Threadersteller: Nochmal darüber nachdenken, welche Größe was ist und welche Eigenschaften sie hat und welcher Datentyp daher angebracht wäre. Das ist eine viel bessere Lösungsmethode als den Compiler über Casts und pragmas ruhig zustellen. Wie schon in der ersten Antwort gesagt wurde, hat der Compiler schließlich Recht.

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.

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.

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;

#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.

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 );
}

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 );
}

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 );
}

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;

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

Du brauchst Hilfe?
Warum dir keiner helfen will