CODEWITHSUNDEEP
c++typeswarnings
Cpp
Cpp

Reputation:

warning C4244: 'argument' : conversion from 'SIZE_T' to 'DWORD', possible loss of data

I need to have a set of overloaded functions in my code but I get convertion wanrings. Here is a test code:

#include windows.h

void f(DWORD arg){...}

//void f(SIZE_T arg){}

void main(void)
{
DWORD dword=0;
SIZE_T size_t=dword;
f(size_t);

}

The compiler gives warning:

test.cpp(11) : warning C4244: 'argument' : conversion from 'SIZE_T' to 'DWORD', possible loss of data

If I uncomment void f(SIZE_T arg) I get

test.cpp(5) : error C2084: function 'void f(DWORD)' already has a body

How can I avoid having this warning or error?

Upvotes: 4

Views: 20002

Answers (3)

KunMing Xie
KunMing Xie

Reputation: 1667

SIZE_T takes 8 bytes in 64bit system while DWORD takes 4 bytes

from Windows Data Types

typedef ULONG_PTR SIZE_T;

#if defined(_WIN64)
 typedef unsigned __int64 ULONG_PTR;
#else
 typedef unsigned long ULONG_PTR;
#endif

Upvotes: -2

Max Lybbert
Max Lybbert

Reputation: 20041

The simplest answer is to get rid of f(DWORD) and redefine it f(size_t). Unless, of course, f() operates on values other than size_ts.

Upvotes: 0

Adam Rosenfield
Adam Rosenfield

Reputation: 400274

size_t is guaranteed to be an unsigned integral type, but the number of bits it has isn't specified. It could be equal to a DWORD (32 bits), or it could be 64 bits on a 64-bit platform. For maximal portability, you shouldn't assume it has a certain number of bits, which is what the compiler is warning you about. If you know your value will never exceed 2^32 (which is a reasonable assumption in 99.99% of cases), then you can just cast to a DWORD to get rid of the warning:

SIZE_T sz = dword;
f((DWORD)sz);  // no warning here

The error you're getting is because in your case, size_t is actually 32 bits, and so the function signatures of your two f functions are identical - they both take a single unsigned 32-bit parameter. You'll have to use separate names for them in order to guarantee that your program is portable between 32- and 64-bit platforms:

void f_DWORD(DWORD arg) { ... }
void f_size_t(size_t arg) { ... }

One final note: size_t is a built-in type. SIZE_T is non-standard and is almost definitely a typedef or a #define for size_t. You should use size_t instead of SIZE_T, and you should also avoid naming your variables size_t, since that introduces confusion by shadowing a type name with a variable name.

Upvotes: 15

Related Questions