Bir işaretçiyi iletmek yerine yapıları C değerine göre geçirmenin dezavantajları var mı?

Bir işaretçiyi iletmek yerine yapıları C değerine göre geçirmenin dezavantajları var mı?

Yapı büyükse, çok sayıda veri kopyalamanın performans açısından açık bir yönü vardır, ancak daha küçük bir yapı için, temel olarak bir işleve birkaç değer iletmekle aynı olmalıdır.

Dönüş değerleri olarak kullanıldığında daha da ilginç olabilir. C'nin işlevlerden yalnızca tek dönüş değerleri vardır, ancak genellikle birkaçına ihtiyacınız vardır. Yani basit bir çözüm onları bir yapıya koymak ve geri vermek.

Buna karşı veya buna karşı bir neden var mı?

Burada bahsettiğim herkese açık olmayabileceğinden, basit bir örnek vereceğim.

C dilinde programlama yapıyorsanız, er ya da geç aşağıdaki gibi işlevler yazmaya başlayacaksınız:

void examine_data(const char *ptr, size_t len)
{
    ...
}

char *p = ...;
size_t l = ...;
examine_data(p, l);

Bu bir sorun değil. Tek sorun, tüm fonksiyonlarda aynı kuralı kullanmanız için parametrelerin hangi sırada olması gerektiği konusunda iş arkadaşınızla anlaşmanız gerektiğidir.

Ancak aynı tür bilgileri geri döndürmek istediğinizde ne olur? Genellikle böyle bir şey alırsınız:

char *get_data(size_t *len);
{
    ...
    *len = ...datalen...;
    return ...data...;
}
size_t len;
char *p = get_data(&len);

Bu iyi çalışıyor, ancak çok daha sorunlu. Bir dönüş değeri, bu uygulamada olmaması dışında bir dönüş değeridir. Yukarıdan, get_data fonksiyonunun neye işaret ettiğine bakmasına izin verilmediğini söylemenin bir yolu yoktur. Ve derleyiciyi bu işaretçiden bir değerin gerçekten döndürüldüğünü kontrol eden hiçbir şey yoktur. Gelecek ay, bir başkası kodu doğru anlamadan değiştirdiğinde (belgeleri okumadığından dolayı?) Fark etmeden kırılır veya rastgele çökmeye başlar.

Yani, önerdiğim çözüm basit yapı

struct blob { char *ptr; size_t len; }

Örnekler şu şekilde yeniden yazılabilir:

void examine_data(const struct blob data)
{
    ... use data.tr and data.len ...
}

struct blob = { .ptr = ..., .len = ... };
examine_data(blob);

struct blob get_data(void);
{
    ...
    return (struct blob){ .ptr = ...data..., .len = ...len... };
}
struct blob data = get_data();

Nedense, çoğu insan içgüdüsel olarak examine_data bir yapı blob için bir işaretçi almak istiyorum düşünüyorum, ama neden görmüyorum. Hala bir işaretçi ve bir tam sayı alır, birlikte gittikleri çok daha açıktır. Ve get_data durumunda, uzunluk için herhangi bir girdi değeri olmadığından ve döndürülen bir uzunluk olması gerektiğinden, daha önce tanımladığım şekilde karıştırmak imkansızdır.

Küçük yapılar için (örn. Nokta, doğrultu) değere göre geçmek mükemmel şekilde kabul edilebilir. Ancak, hızın yanı sıra, büyük yapıları değere göre geçirme / döndürme konusunda dikkatli olmanızın bir başka nedeni daha vardır: Yığın alanı.

Belleğin çok değerli olduğu gömülü sistemler için bir çok C programlama vardır ve yığın boyutları KB veya hatta Bayt cinsinden ölçülebilir ... Yapıları değere göre geçirir veya döndürürseniz, bu yapıların kopyaları yerleştirilir yığın, potansiyel olarak bu sitenin adını almıştır duruma neden ...

Aşırı yığın kullanımı gibi görünen bir uygulama görürsem, değere göre aktarılan yapılar ilk aradığım şeylerden biridir.

Daha önce değinilmemiş olan bunun yapılmamasının bir nedeni, bunun ikili uyumluluğun önemli olduğu bir soruna neden olabilmesidir.

Kullanılan derleyiciye bağlı olarak, yapılar derleyici seçeneklerine / uygulamasına bağlı olarak yığın veya kayıtlardan geçirilebilir

Bkz. Http://gcc.gnu.org/onlinedocs/gcc/Code-Gen-Options.html

-fpcc-yapı-dönüş

-freg-yapı-dönüş

İki derleyici aynı fikirde olmazsa işler patlayabilir. Bunu yapmamanın temel nedenlerinin resmedilmeye gerek yok, yığın tüketimi ve performans nedenleridir.

İçin gerçekten montaj arazi içine derin kazmak, bir ihtiyacı bu soruya cevap:

(Aşağıdaki örnek x86_64 üzerinde gcc kullanır. Herkes MSVC, ARM vb. Gibi başka mimariler ekleyebilir.)

Örnek programımızı yapalım:

// foo.c

typedef struct
{
    double x, y;
} point;

void give_two_doubles(double * x, double * y)
{
    *x = 1.0;
    *y = 2.0;
}

point give_point()
{
    point a = {1.0, 2.0};
    return a;
}

int main()
{
    return 0;
}

Tam optimizasyonlarla derleyin

gcc -Wall -O3 foo.c -o foo

Meclise bakın:

objdump -d foo | vim -

Elde ettiğimiz bu:

0000000000400480 <give_two_doubles>:
    400480: 48 ba 00 00 00 00 00    mov    $0x3ff0000000000000,%rdx
    400487: 00 f0 3f 
    40048a: 48 b8 00 00 00 00 00    mov    $0x4000000000000000,%rax
    400491: 00 00 40 
    400494: 48 89 17                mov    %rdx,(%rdi)
    400497: 48 89 06                mov    %rax,(%rsi)
    40049a: c3                      retq   
    40049b: 0f 1f 44 00 00          nopl   0x0(%rax,%rax,1)

00000000004004a0 <give_point>:
    4004a0: 66 0f 28 05 28 01 00    movapd 0x128(%rip),%xmm0
    4004a7: 00 
    4004a8: 66 0f 29 44 24 e8       movapd %xmm0,-0x18(%rsp)
    4004ae: f2 0f 10 05 12 01 00    movsd  0x112(%rip),%xmm0
    4004b5: 00 
    4004b6: f2 0f 10 4c 24 f0       movsd  -0x10(%rsp),%xmm1
    4004bc: c3                      retq   
    4004bd: 0f 1f 00                nopl   (%rax)

noplPedler hariç give_two_doubles(), 27 bayt give_point(), 29 bayt vardır. Öte yandan, give_point()bir daha az talimat verirgive_two_doubles()

İlginç olan şey, derleyicinin movdaha hızlı SSE2 varyantlarına optimize edebildiğini fark etmemiz movapdve movsd. Dahası, give_two_doubles()aslında verileri bellekten içeri ve dışarı taşır, bu da işleri yavaşlatır.

Görünüşe göre bunların çoğu gömülü ortamlarda (C'nin oyun alanının günümüzde çoğu zaman olduğu yerde) geçerli olmayabilir. Bir montaj sihirbazı değilim, bu yüzden herhangi bir yorum hoş geldiniz!

Basit bir çözüm, dönüş değeri olarak bir hata kodu ve işlevdeki bir parametre olarak her şeyi döndürecektir,
Bu parametre elbette bir yapı olabilir, ancak değere göre geçen herhangi bir avantaj görmüyorum, sadece bir işaretçi gönderdi.
Yapıyı değere göre geçirmek tehlikelidir, geçmekte olduğunuz şeylere çok dikkat etmeniz gerekir, C'de kopya oluşturucu olmadığını unutmayın, yapı parametrelerinden biri bir işaretçi ise işaretçi değeri kopyalanır, çok kafa karıştırıcı ve zor olabilir sürdürmek.

Sadece cevabı tamamlamak için ( Roddy'ye tam kredi ) yığın kullanımı, değere göre yapıyı geçmemek için başka bir nedendir, inanıyorum ki yığın taşması hata ayıklama gerçek PITA.

Yorum yapmak için tekrar et:

Yapıyı işaretçi olarak geçirmek, bazı varlıkların bu nesne üzerinde bir mülkiyete sahip olduğu ve ne zaman ve ne zaman serbest bırakılması gerektiği konusunda tam bilgiye sahip olduğu anlamına gelir. Yapıyı değere göre geçirmek, yapının iç verilerine gizli bir referans oluşturur (başka yapılara işaretçiler vb.) Bu bakımını yapmak zordur (mümkün ama neden?).

Buradaki insanların şimdiye kadar bahsetmeyi unuttukları bir şey (ya da gözden kaçırdım), yapıların genellikle bir dolguya sahip olmasıdır!

struct {
  short a;
  char b;
  short c;
  char d;
}

Her karakter 1 bayt, her kısa 2 bayttır. Yapı ne kadar büyük? Hayır, 6 bayt değil. En azından daha sık kullanılan sistemlerde değil. Çoğu sistemde 8 olacaktır. Sorun, hizalama sabit değil, sisteme bağlıdır, bu nedenle aynı yapı farklı sistemlerde farklı hizalama ve farklı boyutlara sahip olacaktır.

Sadece bu dolgu, yığınızı daha fazla yiyemez, aynı zamanda sistem pedlerinizi nasıl bildiğini ve uygulamanızdaki her bir yapıya nasıl bakacağınızı ve boyutunu hesaplayamazsanız, dolguları önceden tahmin edememe belirsizliğini de ekler. onun için. Bir işaretçiyi geçmek tahmin edilebilir miktarda alan gerektirir - belirsizlik yoktur. İşaretçinin boyutu sistem için bilinir, yapının neye benzediğine bakılmaksızın her zaman eşittir ve işaretçi boyutları her zaman hizalanacak ve dolgu gerektirmeyecek şekilde seçilir.

Sorunuzun bir şeyleri oldukça iyi özetlediğini düşünüyorum.

Yapıları değere göre geçirmenin bir diğer avantajı da bellek sahipliğinin açık olmasıdır. Yapının öbekten olup olmadığı ve serbest bırakılmasından kimin sorumlu olduğu hakkında bir merak yoktur.

Hem parametre olarak hem de dönüş değerleri olarak değere göre (çok büyük olmayan) yapıları geçirmenin mükemmel bir meşru teknik olduğunu söyleyebilirim. Elbette, yapının bir POD tipi olduğuna ya da kopya semantiğinin iyi belirtildiğine dikkat etmek gerekir.

Güncelleme: Üzgünüm, C ++ düşünme başlığım vardı. Bir işlevden bir yapı döndürmenin C'de yasal olmadığı bir zamanı hatırlıyorum, ancak bu muhtemelen o zamandan beri değişti. Kullanmayı beklediğiniz tüm derleyiciler uygulamayı desteklediği sürece bunun geçerli olduğunu söyleyebilirim.

İşte kimsenin bahsetmediği bir şey:

void examine_data(const char *c, size_t l)
{
    c[0] = 'l'; // compiler error
}

void examine_data(const struct blob blob)
{
    blob.ptr[0] = 'l'; // perfectly legal, quite likely to blow up at runtime
}

Bir üyeleri const structvardır const, ama bu eleman bir işaretçi (gibi ise char *), o olur char *constyerine const char *biz gerçekten istiyoruz. Tabii ki,const niyetin dokümantasyonu olduğunu ve bunu ihlal eden herkesin kötü kod yazdığını (ki bunlar), bu bazıları için yeterince iyi değil (özellikle de bir nedeni araştırmak için dört saat harcayanlar) ) çökmesine.

Alternatif bir yapmak struct const_blob { const char *c; size_t l }ve kullanmak olabilir, ama bu oldukça dağınık - typedefişaretçilerle sahip olduğum aynı adlandırma düzeni sorununa giriyor . Bu nedenle, çoğu insan sadece iki parametreye bağlı kalır (veya bu durumda bir dize kütüphanesi kullanarak daha olasıdır).

Http://www.drpaulcarter.com/pcasm/ adresindeki PC Meclisi Eğiticisinin 150. sayfası , C'nin bir işlevin bir yapıyı döndürmesine nasıl izin verdiğine ilişkin net bir açıklamaya sahiptir:

C ayrıca bir fonksiyon tipinin dönüş değeri olarak bir yapı tipinin kullanılmasına izin verir. Açıkçası EAX kaydında bir yapı döndürülemez. Farklı derleyiciler bu durumu farklı şekilde ele alır. Derleyicilerin kullandığı yaygın bir çözüm, işlevi bir yapı işaretçisini parametre olarak alan işlev olarak dahili olarak yeniden yazılmasıdır. İşaretçi, dönüş değerini çağrılan rutinin dışında tanımlanan bir yapıya koymak için kullanılır.

Yukarıdaki ifadeyi doğrulamak için aşağıdaki C kodunu kullanın:

struct person {
    int no;
    int age;
};

struct person create() {
    struct person jingguo = { .no = 1, .age = 2};
    return jingguo;
}

int main(int argc, const char *argv[]) {
    struct person result;
    result = create();
    return 0;
}

Bu C kodu parçası için montaj oluşturmak için "gcc -S" kullanın:

    .file   "foo.c"
    .text
.globl create
    .type   create, @function
create:
    pushl   %ebp
    movl    %esp, %ebp
    subl    $16, %esp
    movl    8(%ebp), %ecx
    movl    $1, -8(%ebp)
    movl    $2, -4(%ebp)
    movl    -8(%ebp), %eax
    movl    -4(%ebp), %edx
    movl    %eax, (%ecx)
    movl    %edx, 4(%ecx)
    movl    %ecx, %eax
    leave
    ret $4
    .size   create, .-create
.globl main
    .type   main, @function
main:
    pushl   %ebp
    movl    %esp, %ebp
    subl    $20, %esp
    leal    -8(%ebp), %eax
    movl    %eax, (%esp)
    call    create
    subl    $4, %esp
    movl    $0, %eax
    leave
    ret
    .size   main, .-main
    .ident  "GCC: (Ubuntu 4.4.3-4ubuntu5) 4.4.3"
    .section    .note.GNU-stack,"",@progbits

Çağrıdan önceki yığın oluşturur:

        +---------------------------+
ebp     | saved ebp                 |
        +---------------------------+
ebp-4   | age part of struct person | 
        +---------------------------+
ebp-8   | no part of struct person  |
        +---------------------------+        
ebp-12  |                           |
        +---------------------------+
ebp-16  |                           |
        +---------------------------+
ebp-20  | ebp-8 (address)           |
        +---------------------------+

Create öğesini çağırdıktan hemen sonra yığın:

        +---------------------------+
        | ebp-8 (address)           |
        +---------------------------+
        | return address            |
        +---------------------------+
ebp,esp | saved ebp                 |
        +---------------------------+

Yapılarınızı değere göre geçirmenin bir avantajına işaret etmek istiyorum, optimize edici bir derleyici kodunuzu daha iyi optimize edebilir.