Bir işaretçiyi tam sayıya dönüştürme

Mevcut bir kodu 64 bitlik bir makineye uyarlamaya çalışıyorum. Temel sorun, bir işlevde, önceki kodlayıcının işlevin kendisinde uygun türe dönüştürülen bir void * bağımsız değişkeni kullanmasıdır. Kısa bir örnek:

void function(MESSAGE_ID id, void* param)
{
    if(id == FOO) {
        int real_param = (int)param;
        // ...
    }
}

Tabii ki 64 bitlik bir makinede şu hatayı alıyorum:

error: cast from 'void*' to 'int' loses precision

Hala 32 bitlik bir makinede ve olabildiğince temiz çalışacak şekilde bunu düzeltmek istiyorum. Herhangi bir fikir ?

Kullanım intptr_tve uintptr_t.

Taşınabilir bir şekilde tanımlandığından emin olmak için, şu şekilde kod kullanabilirsiniz:

#if defined(__BORLANDC__)
    typedef unsigned char uint8_t;
    typedef __int64 int64_t;
    typedef unsigned long uintptr_t;
#elif defined(_MSC_VER)
    typedef unsigned char uint8_t;
    typedef __int64 int64_t;
#else
    #include <stdint.h>
#endif

Bunu bir .h dosyasına koyun ve ihtiyacınız olan yere ekleyin.

Alternatif olarak, Microsoft'un sürümünü indirebilirsiniz stdint.hdosyanın burada ya bir taşınabilir birini kullanın burada .

Bunun modern C ++ yolu olduğunu söyleyebilirim.

#include <cstdint>
void *p;
auto i = reinterpret_cast<std::uintptr_t>(p);

DÜZENLE :

Tamsayı için doğru tür

dolayısıyla bir işaretçiyi tam sayı olarak saklamanın doğru yolu uintptr_tveya intptr_ttürlerini kullanmaktır . (Ayrıca C99 için cppreference tam sayı türlerine bakın ).

bu türler <stdint.h>C99 için ve stdC ++ 11 için ad alanında tanımlanır <cstdint>( C ++ için tam sayı türlerine bakın ).

C ++ 11 (ve sonrası) Sürüm

#include <cstdint>
std::uintptr_t i;

C ++ 03 Sürümü

extern "C" {
#include <stdint.h>
}

uintptr_t i;

C99 Sürümü

#include <stdint.h>
uintptr_t i;

Doğru döküm operatörü

C'de yalnızca bir cast vardır ve C ++ 'da C dökümünü kullanmak hoş karşılanmaz (bu yüzden C ++' da kullanmayın). C ++ 'da farklı yayınlar vardır. reinterpret_castbu dönüşüm için doğru atama (ayrıca buraya bakın ).

C ++ 11 Sürümü

auto i = reinterpret_cast<std::uintptr_t>(p);

C ++ 03 Sürümü

uintptr_t i = reinterpret_cast<uintptr_t>(p);

C Sürümü

uintptr_t i = (uintptr_t)p; // C Version

ilgili sorular

• Uintptr_t veri türü nedir

Mimarinize (her ne olursa olsun) uyması için 'size_t' ve 'ptrdiff_t' gereklidir. Bu nedenle, 'int' kullanmak yerine, 64 bitlik bir sistemde 64 bit tip olması gereken 'size_t' kullanabilmeniz gerektiğini düşünüyorum.

Bu tartışma unsigned int vs size_t biraz daha ayrıntıya giriyor.

uintptr_tTam sayı türünüz olarak kullanın .

Çeşitli cevaplar üzerinde yoğunlaşmaktadır uintptr_tve #include <stdint.h>'çözüm olarak. Bence cevabın bir parçası, ama cevabın tamamı değil. Ayrıca, FOO'nun ileti kimliği ile işlevin nerede çağrıldığına da bakmanız gerekir.

Bu kodu ve derlemeyi düşünün:

$ cat kk.c
#include <stdio.h>
static void function(int n, void *p)
{
    unsigned long z = *(unsigned long *)p;
    printf("%d - %lu\n", n, z);
}

int main(void)
{
    function(1, 2);
    return(0);
}
$ rmk kk
        gcc -m64 -g -O -std=c99 -pedantic -Wall -Wshadow -Wpointer-arith \
            -Wcast-qual -Wstrict-prototypes -Wmissing-prototypes \
            -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE kk.c -o kk 
kk.c: In function 'main':
kk.c:10: warning: passing argument 2 of 'func' makes pointer from integer without a cast
$

Çağıran konumda (içinde main()) bir problem olduğunu gözlemleyeceksiniz - bir tamsayıyı, atamasız bir göstericiye dönüştürmek. function()Değerlerin ona nasıl aktarıldığını görmek için tüm kullanımlarında analiz etmeniz gerekecek . function()Aramalar yazılsaydı içimdeki kod çalışırdı :

unsigned long i = 0x2341;
function(1, &i);

Sizinki muhtemelen farklı yazıldığından, gösterilen değeri kullanmanın anlamlı olduğundan emin olmak için işlevin çağrıldığı noktaları gözden geçirmeniz gerekir. Unutmayın, gizli bir hata buluyor olabilirsiniz.

Ayrıca, void *parametrenin değerini (dönüştürüldüğü gibi) biçimlendirecekseniz , <inttypes.h>başlığa dikkatlice bakın (- yerine stdint.h-inttypes.hstdint.h alışılmadık olan hizmetlerini sağlar , ancak C99 standardı [t] başlığının başlığı <inttypes.h>içerdiğini <stdint.h>ve bunu barındırılan uygulamalar tarafından sağlanan ek olanaklarla genişletir ) ve biçim dizelerinizde PRIxxx makrolarını kullanın.

Ayrıca, yorumlarım kesinlikle C ++ yerine C'ye uygulanabilir, ancak kodunuz C ve C ++ arasında taşınabilir olan C ++ alt kümesinde. Yorumlarımın geçerli olma şansı oldukça iyi.

1. #include <stdint.h>
2. uintptr_tDahil edilen standart başlık dosyasında tanımlanan standart türü kullanın .

SQLite'ın kaynak kodunu incelerken bu soruyla karşılaştım .

Gelen sqliteInt.h , tamsayı ve olası arasında bir makro dönüştürmek tanımlanan kodu bir paragraf vardır. Yazar, önce derleyiciye bağlı bir sorun olması gerektiğine işaret eden çok iyi bir açıklama yaptı ve ardından çözümü oradaki popüler derleyicilerin çoğunu hesaba katmak için uyguladı.

#if defined(__PTRDIFF_TYPE__)  /* This case should work for GCC */
# define SQLITE_INT_TO_PTR(X)  ((void*)(__PTRDIFF_TYPE__)(X))
# define SQLITE_PTR_TO_INT(X)  ((int)(__PTRDIFF_TYPE__)(X))
#elif !defined(__GNUC__)       /* Works for compilers other than LLVM */
# define SQLITE_INT_TO_PTR(X)  ((void*)&((char*)0)[X])
# define SQLITE_PTR_TO_INT(X)  ((int)(((char*)X)-(char*)0))
#elif defined(HAVE_STDINT_H)   /* Use this case if we have ANSI headers */
# define SQLITE_INT_TO_PTR(X)  ((void*)(intptr_t)(X))
# define SQLITE_PTR_TO_INT(X)  ((int)(intptr_t)(X))
#else                          /* Generates a warning - but it always works     */
# define SQLITE_INT_TO_PTR(X)  ((void*)(X))
# define SQLITE_PTR_TO_INT(X)  ((int)(X))
#endif

Ve işte daha fazla ayrıntı için yorumun bir alıntı:

/*
** The following macros are used to cast pointers to integers and
** integers to pointers.  The way you do this varies from one compiler
** to the next, so we have developed the following set of #if statements
** to generate appropriate macros for a wide range of compilers.
**
** The correct "ANSI" way to do this is to use the intptr_t type.
** Unfortunately, that typedef is not available on all compilers, or
** if it is available, it requires an #include of specific headers
** that vary from one machine to the next.
**
** Ticket #3860:  The llvm-gcc-4.2 compiler from Apple chokes on
** the ((void*)&((char*)0)[X]) construct.  But MSVC chokes on ((void*)(X)).
** So we have to define the macros in different ways depending on the
** compiler.
*/

Kredi taahhüt edenlere gider.

Yapılacak en iyi şey, işaretçi türünden işaretçi olmayan türlere dönüştürmekten kaçınmaktır. Ancak, sizin durumunuzda bu kesinlikle mümkün değil.

Herkesin dediği gibi, uintptr_t kullanmanız gereken şeydir.

Bu bağlantı , 64 bit koda dönüştürme hakkında iyi bilgiler içerir.

Comp.std.c'de bununla ilgili iyi bir tartışma da var.

Bu durumda boşluk * "anlamının" genel bir tutamaç olduğunu düşünüyorum. Bir değere işaretçi değil, değerin kendisidir. (Bu sadece void * 'in C ve C ++ programcıları tarafından nasıl kullanıldığıdır.)

Bir tamsayı değeri tutuyorsa, tamsayı aralığında olması daha iyi!

İşte tamsayıya dönüştürme kolay:

int x = (char*)p - (char*)0;

Sadece bir uyarı vermelidir.

Yana uintptr_tolduğunu ++ / C ++ 11 C orada olması garanti edilmez bu düşünebilirsiniz tek yönlü dönüşüm ise, uintmax_ther zaman tanımlanmış <cstdint>.

auto real_param = reinterpret_cast<uintmax_t>(param);

Güvenli oynamak için, kodun herhangi bir yerine bir iddia eklenebilir:

static_assert(sizeof (uintmax_t) >= sizeof (void *) ,
              "No suitable integer type for conversion from pointer type");