warning C4311: 'type cast' : pointer truncation
CodeGuru Home VC++ / MFC / C++ .NET / C# Visual Basic VB Forums Developer.com
Results 1 to 2 of 2

Thread: warning C4311: 'type cast' : pointer truncation

  1. #1
    Join Date
    Jun 2007
    Posts
    79

    warning C4311: 'type cast' : pointer truncation

    Hi all,

    when i called the function below :
    Code:
    unsigned long
    ChaineInc::hache() const
    {
      if ((!stock) || (!*(stock->c)))
        return 0;
      unsigned long graine = 398477;
      char* car;
    
      for (car = stock->c; *car; car++)
        {
          graine += *car, graine  = (((graine ? graine : 1) * 785398169) % 151147861);
        }
      
      POSTCONDITION(graine >= 0);
      return graine;
    }
    from my code :
    Code:
    //const Key g
    unsigned long i=hache(g) + (unsigned long)this;
    i got this warning:

    warning C4311: 'type cast' : pointer truncation from 'Index_Dico *const ' to 'unsigned long'


    How can i avoid this warning ?

    P.S : i can modify the function hache

    Best regars,

  2. #2
    Join Date
    May 2007
    Posts
    437

    Re: warning C4311: 'type cast' : pointer truncation

    This problem arises when A 64-bit pointer was truncated to a 32-bit int or 32-bit long.

    This warning is only issued when /Wp64 is used.

    From MSDN


    Error Message
    'variable' : pointer truncation from 'type' to 'type'

    This warning detects 64-bit portability issues. For example, if code is compiled on a 64-bit platform, the value of a pointer (64 bits) will be truncated if it is assigned to an int (32 bits).


    See /Wp64


    Detects 64-bit portability problems on types that are also marked with the __w64 keyword.
    /Wp64

    /Wp64 is off by default in the Visual C++ 32-bit compiler and on by default in the Visual C++ 64-bit compiler.

    Variables of the following types are tested on a 32-bit operating system as if they were being used on a 64-bit operating system:

    • int
    • long
    • pointer
    If you regularly compile your application with a 64-bit compiler, you may want to disable /Wp64 in your 32-bit compilations, as the 64-bit compiler will detect all issues. For more information about targeting a Windows 64-bit operating system, see 64-Bit Programming with Visual C++.

    To set this compiler option in the Visual Studio development environment
    1. Open the project's Property Pages dialog box. For details, see How to: Open Project Property Pages.
    2. Click the C/C++ folder.
    3. Click the General property page.
    4. Modify the Detect 64-bit Portability Issues property.
    To set this compiler option programmatically

    • use Detect64BitPortabilityProblems.

    Also, Have a look Rules for Using Pointers.


    Rules for Using Pointers

    Porting your code to compile for both 32- and 64-bit Microsoft® Windows® is straightforward. You need only follow a few simple rules about casting pointers, and use the new data types in your code. The rules for pointer manipulation are as follows.


    1. Do not cast pointers to int, long, ULONG, or DWORD. If you must cast a pointer to test some bits, set or clear bits, or otherwise manipulate its contents, use the UINT_PTR or INT_PTR type. These types are integral types that scale to the size of a pointer for both 32- and 64-bit Windows (for example, ULONG for 32-bit Windows and _int64 for 64-bit Windows). For example, assume you are porting the following code:



      ImageBase = (PVOID)((ULONG)ImageBase | 1);

      As a part of the porting process, you would change the code as follows:



      ImageBase = (PVOID)((ULONG_PTR)ImageBase | 1);

      Use UINT_PTR and INT_PTR where appropriate (and if you are uncertain whether they are required, there is no harm in using them just in case). Do not cast your pointers to the types ULONG, LONG, INT, UINT, or DWORD.



      Note that HANDLE is defined as a void*, so typecasting a HANDLE value to a ULONG value to test, set, or clear the low-order 2 bits is an error on 64-bit Windows.
    2. Use the PtrToLong or PtrToUlong function to truncate pointers. If you must truncate a pointer to a 32-bit value, use the PtrToLong or PtrToUlong function (defined in Basetsd.h). These functions disable the pointer truncation warning for the duration of the call.



      Use these functions carefully. After you convert a pointer variable using one of these functions, never use it as a pointer again. These functions truncate the upper 32 bits of an address, which are usually needed to access the memory originally referenced by pointer. Using these functions without careful consideration will result in fragile code.
    3. Be careful using OUT parameters. For example, suppose you have a function defined as follows:

      void func( OUT PULONG *PointerToUlong );

      Do not call this function as follows:


      ULONG ul;

      PULONG lp;

      func((PULONG *)&ul);

      lp = (PULONG)ul;

      Instead, use the following call:



      PULONG lp;

      func(&lp);

      Typecasting &ul to PULONG* prevents a compiler error, but the function will write a 64-bit pointer value into the memory at &ul. This code works on 32-bit Windows, but will cause data corruption on 64-bit Windows—and it will be subtle, hard-to-find corruption. The bottom line: Do not play tricks with the C code—straightforward and simple is better.
    4. Be careful with polymorphic interfaces. Do not create functions that accept DWORD parameters for polymorphic data. If the data can be a pointer or an integral value, use the UINT_PTR or PVOID type.



      For example, do not create a function that accepts an array of exception parameters typed as DWORD values. The array should be an array of DWORD_PTR values. Therefore, the array elements can hold addresses or 32-bit integral values. (The general rule is that if the original type is DWORD and it needs to be pointer width, convert it to a DWORD_PTR value. That is why there are corresponding pointer-precision types.) If you have code that uses DWORD, ULONG, or other 32-bit types in a polymorphic way (that is, you really want the parameter or structure member to hold an address), use UINT_PTR in place of the current type.
    5. Use the new window class functions. If you have window or class private data that contains pointers, your code will need to use the following new functions:
      • GetClassLongPtr
      • GetWindowLongPtr
      • SetClassLongPtr
      • SetWindowLongPtr
      These functions can be used on both 32- and 64-bit Windows, but they are required on 64-bit Windows. Prepare for the transition by using these functions now.

      Additionally, you must access pointers or handles in class private data using the new functions on 64-bit Windows. To aid you in finding these cases, the following indexes are not defined in Winuser.h during a 64-bit compile:


      • GWL_WNDPROC
      • GWL_HINSTANCE
      • GWL_HWDPARENT
      • GWL_USERDATA
      Instead, Winuser.h defines the following new indexes:


      • GWLP_WNDPROC
      • GWLP_HINSTANCE
      • GWLP_HWNDPARENT
      • GWLP_USERDATA
      • GWLP_ID
      For example, the following code does not compile:

      SetWindowLong(hWnd, GWL_WNDPROC, (LONG)MyWndProc);
      It should be changed as follows:

      SetWindowLongPtr(hWnd, GWLP_WNDPROC, (LONG_PTR)MyWndProc);
      When setting the cbWndExtra member of the WNDCLASS structure, be sure to reserve enough space for pointers. For example, if you are currently reserving sizeof(DWORD) bytes for a pointer value, reserve sizeof(DWORD_PTR) bytes.
    6. Access all window and class data using FIELD_OFFSET. It is common to access window data using hard-coded offsets. This technique is not portable to 64-bit Windows. To make your code portable, access your window and class data using the FIELD_OFFSET macro. Do not assume that the second pointer has an offset of 4.
    7. The LPARAM, WPARAM, and LRESULT types change size with the platform. When compiling 64-bit code, these types expand to 64 bits, because they typically hold pointers or integral types. Do not mix these values with DWORD, ULONG, UINT, INT, int, or long values. Examine how you use these types and ensure that you do not inadvertently truncate values.
    Last edited by ashukasama; August 10th, 2007 at 07:56 AM. Reason: remove link
    ashu
    always use code tag

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •  


Windows Mobile Development Center


Click Here to Expand Forum to Full Width

This is a CodeGuru survey question.


Featured


HTML5 Development Center