İşlev işaretçileri ve veri işaretçileri neden C / C ++ ile uyumsuz?

Bir işlev işaretçisini bir veri işaretçisine dönüştürmenin ve bunun tersinin çoğu platformda çalıştığını, ancak çalışmasının garanti edilmediğini okudum. Bu neden böyle? Her ikisinin de basitçe ana belleğe adres olması ve dolayısıyla uyumlu olması gerekmez mi?

Bir mimarinin kod ve verileri aynı bellekte depolaması gerekmez. Harvard mimarisi ile kod ve veriler tamamen farklı bir bellekte saklanır. Çoğu mimari, aynı bellekte kod ve veri bulunan Von Neumann mimarileridir, ancak C kendisini mümkünse yalnızca belirli mimari türleriyle sınırlamaz.

Bazı bilgisayarların kod ve veriler için ayrı adres alanları vardır (vardı). Böyle bir donanımda işe yaramıyor.

Dil, yalnızca mevcut masaüstü uygulamaları için değil, aynı zamanda geniş bir donanım setinde uygulanmasına izin verecek şekilde tasarlanmıştır.

Görünüşe göre C dili komitesi hiçbir zaman void*işlev gösterme amacı taşımıyordu, sadece nesnelere genel bir işaretçi istiyorlardı.

C99 Gerekçesi diyor ki:

6.3.2.3 İşaretçiler
C artık çok çeşitli mimarilerde uygulanmıştır. Bu mimarilerin bazıları, bazı tamsayı türlerinin boyutu olan tekdüze işaretçiler içerirken, maksimum taşınabilir kod, farklı işaretçi türleri ve tam sayı türleri arasında gerekli herhangi bir uyuşmayı üstlenemez. Bazı uygulamalarda işaretçiler herhangi bir tam sayı türünden bile daha geniş olabilir.

Kullanılması void*( “işaretçi voidbir genel amacı, işaretçi türü”) C89 Komitesi bir buluştur. Bu türün benimsenmesi, ya rastgele işaretçileri (olduğu gibi fread) sessizce dönüştüren veya argüman türü tam olarak eşleşmediğinde (olduğu gibi strcmp) şikayet eden işlev prototip argümanlarını belirtme arzusuyla teşvik edildi . Nesne işaretçileri ve / veya tam sayılarla orantısız olabilecek işlevlere işaretçiler hakkında hiçbir şey söylenmez.

Not Son paragrafta işlevlere işaretçiler hakkında hiçbir şey söylenmez . Diğer işaretçilerden farklı olabilirler ve komite bunun farkındadır.

MS-DOS, Windows 3.1 ve daha eski sürümleri hatırlayanlar için cevap oldukça kolaydır. Bunların tümü, kod ve veri işaretçileri için değişen özellik kombinasyonları ile birkaç farklı bellek modelini desteklemek için kullanılır.

Örneğin Compact modeli için (küçük kod, büyük veri):

sizeof(void *) > sizeof(void(*)())

ve tersine Orta modelde (büyük kod, küçük veri):

sizeof(void *) < sizeof(void(*)())

Bu durumda, kod ve tarih için ayrı depolama alanınız yoktu, ancak yine de iki işaretçi arasında dönüştürme yapamazsınız (standart olmayan __near ve __far değiştiricileri kullanmanın kısaltması).

Ek olarak, işaretçiler aynı boyutta olsalar bile, aynı şeyi işaret ettiklerinin garantisi yoktur - DOS Küçük bellek modelinde, hem kod hem de verilerin işaretçilerin yakınında kullanılır, ancak farklı segmentleri işaret ederler. Dolayısıyla, bir işlev işaretçisini bir veri işaretçisine dönüştürmek, size işlevle hiçbir ilişkisi olan bir işaretçi vermez ve bu nedenle böyle bir dönüşümün bir faydası yoktur.

Geçersiz kılınan işaretçilerin, herhangi bir tür veriye bir işaretçiyi yerleştirebilmesi gerekir - ancak bir işleve yönelik bir işaretçi olması gerekmez. Bazı sistemlerin, işlevlere işaretçiler için verilere yönelik işaretçilerden farklı gereksinimleri vardır (örneğin, veri ve kod için farklı adreslemeye sahip DSP'ler vardır, MS-DOS üzerindeki orta model, kod için 32 bit işaretçiler kullanır, ancak veriler için yalnızca 16 bit işaretçiler kullanır) .

Burada daha önce söylenenlere ek olarak, POSIX'e bakmak ilginçtir dlsym():

ISO C standardı, işlevlere işaretçilerin verilere işaretçiler olarak ileri geri gönderilebilmesini gerektirmez. Aslında, ISO C standardı, void * türündeki bir nesnenin bir işleve işaretçi tutabilmesini gerektirmez. Ancak, XSI uzantısını destekleyen uygulamalar, void * türündeki bir nesnenin bir işleve yönelik bir işaretçiyi tutabilmesini gerektirir. Bir işaretçiyi bir işleve başka bir veri türüne (void * dışında) bir göstericiye dönüştürmenin sonucu yine de tanımsızdır. ISO C standardına uyan derleyicilerin, void * işaretçisinden bir işlev işaretçisine dönüştürme girişiminde bulunulduğunda bir uyarı oluşturması gerektiğini unutmayın:

 fptr = (int (*)(int))dlsym(handle, "my_function");

Burada belirtilen sorun nedeniyle, gelecekteki bir sürüm, işlev işaretlerini döndürmek için yeni bir işlev ekleyebilir veya mevcut arayüz iki yeni işlev lehine kullanımdan kaldırılabilir: biri veri işaretçileri döndüren ve diğeri işlev işaretçileri döndüren.

C ++ 11, C / C ++ ve POSIX arasındaki uzun süredir devam eden uyumsuzluğa karşı bir çözüme sahiptir dlsym(). Biri kullanabilirreinterpret_castUygulama bu özelliği desteklediği sürece bir işlev işaretçisini bir veri işaretçisine / veri işaretçisinden dönüştürmek için .

Standarttan, 5.2.10 para. 8, "bir işlev işaretçisini bir nesne işaretçisi türüne dönüştürmek veya bunun tersi koşullu olarak desteklenmektedir." 1.3.5, "koşullu olarak desteklenen" yi, "bir uygulamanın desteklemesi gerekmeyen bir program yapısı" olarak tanımlar.

Hedef mimariye bağlı olarak, kod ve veriler temelde uyumsuz, fiziksel olarak farklı bellek alanlarında depolanabilir.

undefined, mutlaka izin verilmediği anlamına gelmez, derleyici uygulayıcısının bunu istediği gibi yapmak için daha fazla özgürlüğe sahip olduğu anlamına gelebilir.

Örneğin, bazı mimarilerde bu mümkün olmayabilir - tanımsız, siz bunu yapamasanız bile onların uyumlu bir 'C' kitaplığına sahip olmalarına izin verir.

Başka bir çözüm:

POSIX'in işlev ve veri işaretçilerinin aynı boyut ve gösterime sahip olmasını garanti ettiğini varsayarsak (bunun için metni bulamıyorum, ancak alıntılanan örnek OP, en azından bu gereksinimi yerine getirmeyi amaçladıklarını gösteriyor ), aşağıdakiler çalışmalıdır:

double (*cosine)(double);
void *tmp;
handle = dlopen("libm.so", RTLD_LAZY);
tmp = dlsym(handle, "cos");
memcpy(&cosine, &tmp, sizeof cosine);

Bu, takma ad kurallarının ihlal edilmesini önler. char [] tüm türlere takma ad vermesine izin verilen temsilden takma ad .

Yine başka bir yaklaşım:

union {
    double (*fptr)(double);
    void *dptr;
} u;
u.dptr = dlsym(handle, "cos");
cosine = u.fptr;

Ama memcpykesinlikle% 100 doğru C istiyorsanız bu yaklaşımı tavsiye ederim .

Farklı alan gereksinimleri olan farklı tipler olabilirler. Birine atamak, işaretçinin değerini geri alınamaz bir şekilde dilimleyebilir, böylece geri atamak farklı bir şeyle sonuçlanır.

Farklı türler olabileceğine inanıyorum çünkü standart, ihtiyaç duyulmadığında veya boyut CPU'nun onu kullanmak için fazladan şeyler yapmak zorunda kalmasına neden olabileceğinde alan tasarrufu sağlayan olası uygulamaları sınırlamak istemiyor.

Gerçekten taşınabilir olan tek çözüm, dlsymişlevler için kullanmak değil , bunun yerine dlsymişlev işaretçileri içeren verilere bir işaretçi elde etmek için kullanmaktır . Örneğin, kitaplığınızda:

struct module foo_module = {
    .create = create_func,
    .destroy = destroy_func,
    .write = write_func,
    /* ... */
};

ve sonra uygulamanızda:

struct module *foo = dlsym(handle, "foo_module");
foo->create(/*...*/);
/* ... */

Bu arada, bu yine de iyi bir tasarım uygulamasıdır ve dlopendinamik bağlamayı desteklemeyen veya kullanıcı / sistem entegratörünün dinamik bağlantı kullanmak istemediği sistemlerdeki tüm modüllerin hem dinamik yüklemeyi hem de statik bağlamayı desteklemeyi kolaylaştırır .

İşlev işaretçilerinin boyut olarak veri işaretçilerinden farklı olabileceği modern bir örnek: C ++ sınıf üyesi işlev işaretçileri

Doğrudan https://blogs.msdn.microsoft.com/oldnewthing/20040209-00/?p=40713/ adresinden alıntılanmıştır.

class Base1 { int b1; void Base1Method(); };
class Base2 { int b2; void Base2Method(); };
class Derived : public Base1, Base2 { int d; void DerivedMethod(); };

Şimdi iki olası thisişaret var.

Bir üye işlevine Base1bir işaretçi Derived, her ikisi de aynı this işaretçiyi kullandığından, bir üye işlevine işaretçi olarak kullanılabilir . Ancak öğesinin bir üye işlevine Base2bir işaretçi, üye işlevine işaretçi olarak olduğu gibi kullanılamaz Derived, çünküthis göstericinin ayarlanması gerektiğinden .

Bunu çözmenin birçok yolu var. Visual Studio derleyicisinin bunu nasıl işlemeye karar verdiği aşağıda açıklanmıştır:

Çoklu miras alınan bir sınıfın üye işlevine işaretçi gerçekten bir yapıdır.

[Address of function]
[Adjustor]

Birden çok kalıtım kullanan bir sınıfın bir işaretçi-üyeye-işlevinin boyutu, bir göstericinin boyutu artı bir size_t.

tl; dr: Çoklu miras kullanırken, bir üye işlevine bir işaretçi (derleyiciye, sürüme, mimariye, vb. bağlı olarak) aslında şu şekilde depolanabilir:

struct { 
    void * func;
    size_t offset;
}

ki bu açıkça a'dan daha büyüktür void *.

Çoğu mimaride, tüm normal veri türlerine yönelik işaretçiler aynı gösterime sahiptir, bu nedenle veri işaretçisi türleri arasında geçiş yapmak işlemsizdir.

Bununla birlikte, işlev işaretçilerinin farklı bir temsil gerektirebileceği düşünülebilir, belki de diğer işaretçilerden daha büyükler. Eğer void * fonksiyon işaretçileri tutabiliyorsa, bu, void * 'in temsilinin daha büyük boyutta olması gerektiği anlamına gelir. Ve void * 'e / void *' den tüm veri işaretçilerinin bu ekstra kopyayı gerçekleştirmesi gerekecektir.

Birinin bahsettiği gibi, buna ihtiyacınız varsa bir sendika kullanarak başarabilirsiniz. Ancak void * 'in çoğu kullanımı yalnızca veri içindir, bu nedenle bir işlev göstericisinin depolanması gerektiğinde tüm bellek kullanımlarını artırmak zahmetli olacaktır.

Bu 2012 yılından bu yana yorumladı edilmediğini biliyoruz, ama bunu eklemek yararlı olacağını düşündük yapmak olan bir mimariyi biliyor çok o mimari denetler ayrıcalık üzerinde bir çağrı beri veri ve işlevleri için uyumsuz işaretçileri ve ekstra bilgi taşır. Hiçbir miktar döküm yardımcı olmayacak. Bu var Değirmen .