Nesneye yönelik C yazmak kötü mü? [kapalı]

Her zaman çoğunlukla nesne yönelimli C kodu yazmak gibi görünüyor, bu yüzden ben bir yapı dosyası veya bir yapı oluşturmak istiyorsunuz bir şey vardı sonra bu yapıya sahip işlevler (yöntemler) için işaretçiyi iletmek demek:

struct foo {
    int x;
};

struct foo* createFoo(); // mallocs foo

void destroyFoo(struct foo* foo); // frees foo and its things

Bu kötü bir uygulama mı? C'yi "doğru yol" yazmayı nasıl öğrenirim?

Hayır, bu bile tek bile gibi kuralları kullanmak her ne kadar bunu yapmak için teşvik edilmektedir kötü uygulama değildir struct foo *foo_new();vevoid foo_free(struct foo *foo);

Tabii ki, bir yorumun dediği gibi, bunu sadece uygun olduğunda yapın. Bir yapıcı kullanmanın bir anlamı yoktur int.

Önek foo_, bir çok kütüphanenin izlediği bir kuraldır, çünkü diğer kütüphanelerin isimlendirilmesiyle çatışmaya karşı koruma sağlar. Diğer işlevler genellikle kullanım kuralına sahiptir foo_<function>(struct foo *foo, <parameters>);. Bu struct fooopak bir tip olmanıza izin verir .

Özellikle "alt ad alanları" ile, kural için libcurl belgelerine bir göz atın , böylece curl_multi_*ilk parametre döndürüldüğünde bir işlevi çağırmak ilk bakışta yanlış görünür curl_easy_init().

Daha da genel yaklaşımlar var, bkz . ANSI-C ile Nesneye Yönelik Programlama

Kötü değil, mükemmel. Nesne Tabanlı Programlama (eğer kaptırıyorum sürece, iyi bir şeydir olabilir çok fazla iyi bir şey var). C, OOP için en uygun dil değildir, ancak bu, bundan en iyi şekilde yararlanmanızı engellememelidir.

Fena değil. Birçok hatayı önleyen RAII kullanımını onaylar (bellek sızıntıları, başlatılmamış değişkenler kullanma, serbest bırakıldıktan sonra kullanma vb. Güvenlik sorunlarına neden olabilir).

Bu nedenle, kodunuzu yalnızca GCC veya Clang ile (ve MS derleyicisi ile değil) derlemek istiyorsanız cleanup, nesnelerinizi düzgün bir şekilde tahrip edecek niteliği kullanabilirsiniz . Nesnenizi böyle beyan ederseniz:

my_str __attribute__((cleanup(my_str_destructor))) ptr;

Sonra my_str_destructor(ptr)ptr kapsam dışına çıktığında çalıştırılacaktır. Sadece işlev argümanlarıyla kullanılamayacağını unutmayın .

Ayrıca, ad alanlarına sahip olmadığı my_str_için yöntem adlarınızda kullanmayı unutmayın Cve başka bir işlev adıyla çarpışmak kolaydır.

Böyle bir kodun birçok avantajı olabilir, ancak maalesef C Standardı bunu kolaylaştırmak için yazılmamıştır. Derleyiciler tarihsel olarak Standardın gerektirdiği şeyin ötesinde, bu kodun Standart C'de mümkün olandan çok daha temiz bir şekilde yazılmasını mümkün kılan etkili davranışsal garantiler sundu, ancak derleyiciler son zamanlarda bu garantileri optimizasyon adına iptal etmeye başladı.

En dikkat çekici olarak, birçok C derleyicisi tarihsel olarak (belgeleme değilse tasarım gereği), iki yapı tipi aynı başlangıç ​​dizisini içeriyorsa, türler ilgisiz olsa bile, bu ortak dizinin üyelerine erişmek için her iki türden bir işaretçinin kullanılabileceğini garanti etmiştir. ve ayrıca, ortak bir başlangıç ​​sekansı oluşturmak amacıyla, yapılara yönelik tüm göstergeler eşdeğerdir. Böyle bir davranışı kullanan kod, kullanmayan koddan çok daha temiz ve daha güvenli olabilir, ancak ne yazık ki Standart, ortak bir başlangıç ​​sırasını paylaşan yapıların aynı şekilde düzenlenmesini gerektirse de, kodun gerçekten kullanılmasını yasaklar bir diğerinin başlangıç ​​sırasına erişmek için bir tür işaretçi.

Sonuç olarak, C'ye nesne yönelimli kod yazmak istiyorsanız, C'nin işaretçi türü kurallarına uymak için çok fazla çembere atlamaya karar vermeniz (ve bu kararı erkenden vermeniz gerekir) ve modern derleyiciler, eski derleyiciler istendiği gibi çalışan bir kod üretmiş olsa bile, kayıyorsa saçma sapan kod üretir veya kodun yalnızca eski stil işaretçi davranışını destekleyecek şekilde yapılandırılmış derleyicilerle (örn. Bazı insanlar "-fno-katı-aliasing") Bazı insanlar "-fno-katı-aliasing" i kötülük olarak görürler, ancak "-fno-katı-aliasing" C'yi bir dil olarak düşünmenin daha yararlı olacağını söyleyebilirim. bazı amaçlar için "standart" C'den daha büyük anlamsal güç sunar,ancak başka amaçlar için önemli olabilecek optimizasyonlar pahasına.

Örneğin, geleneksel derleyicilerde, tarihsel derleyiciler aşağıdaki kodu yorumlayacaktır:

struct pair { int i1,i2; };
struct trio { int i1,i2,i3; };

void hey(struct pair *p, struct trio *t)
{
  p->i1++;
  t->i1^=1;
  p->i1--;
  t->i1^=1;
}

aşağıdaki adımları sırayla gerçekleştirerek: ilk üyesini artırın, ilk üyenin *pen düşük bitini tamamlayın *t, ardından ilk üyesini azaltın ve ilk üyesinin *pen düşük bitini tamamlayın *t. Modern derleyiciler, işlem sırasını farklı nesneler için daha verimli olacak pve ttanımlayacak bir kodla yeniden düzenler , ancak yapmazlarsa davranışı değiştirir.

Bu örnek elbette kasıtlı olarak konfirme edilmiştir ve pratikte, başka bir türün ortak başlangıç ​​sırasının bir parçası olan üyelere erişmek için bir tür işaretçiyi kullanan kod genellikle işe yarayacaktır, ancak ne yazık ki böyle bir kodun ne zaman başarısız olabileceğini bilmenin bir yolu yoktur. tür temelli örtüşme analizini devre dışı bırakmak dışında hiç güvenli bir şekilde kullanmak mümkün değildir.

İki işaretçi rasgele tiplere takas gibi bir şey yapmak için bir işlev yazmak isterse daha az çelişkili bir örnek ortaya çıkabilir. "1990'ların C" derleyicilerinin büyük çoğunluğunda, bu şu şekilde gerçekleştirilebilir:

void swap_pointers(void **p1, void **p2)
{
  void *temp = *p1;
  *p1 = *p2;
  *p2 = temp;
}

Bununla birlikte Standart C'de, aşağıdakileri kullanmak gerekir:

#include "string.h"
#include "stdlib.h"
void swap_pointers2(void **p1, void **p2)
{
  void **temp = malloc(sizeof (void*));
  memcpy(temp, p1, sizeof (void*));
  memcpy(p1, p2, sizeof (void*));
  memcpy(p2, temp, sizeof (void*));
  free(temp);
}

Eğer *p2tahsis depoda tutulur ve geçici işaretçi tahsis depoda muhafaza edilmez, etkin tip *p2girişimleri kullanmak geçici pointer tipi ve kod olacak *p2geçici-işaretçi eşleşmedi herhangi türü olarak type Tanımsız Davranışı çağırır. Bir derleyicinin böyle bir şeyi fark edeceğinden son derece düşüktür, ancak modern derleyici felsefesi programcıların Tanımlanmamış Davranışlardan kaçınmasını gerektirdiğinden, tahsis edilmiş depolama alanı kullanmadan yukarıdaki kodu yazmanın başka güvenli yollarını düşünemiyorum. .

Bir sonraki adım, yapı bildirimini gizlemektir. Bunu .h dosyasına koydunuz:

typedef struct foo_s foo_t;

foo_t * foo_new(...);
void foo_destroy(foo_t *foo);
some_type foo_whatever(foo_t *foo, ...);
...

Ve sonra .c dosyasında:

struct foo_s {
    ...
};